Deploy the results API

README.md

@@ -16,18 +16,21 @@ The results API behind the leaderboard pop-up of the Steerability Challenge site
 
 The index of runs is `leaderboard/runs.json` in the archive, which `challenge-leaderboard` rebuilds on every render: `{"schema", "latest", "runs": [{"name", "label", "layer", "date", "deadline", "n_ranked", "n_baselines"}, ...]}`. A run's site board is `leaderboard/<run>/site.json`, `{"schema", "run", "rows"}` with the same `run` block and one row per ranked submission and baseline.
 
+The pending run is the run being evaluated between its intake and the publication of its board: the `run` block `{"name", "label", "layer", "pull_finished", "n_pulled", "models"}` of `leaderboard/pending.json` (written by `challenge-leaderboard --pending`, cleared to null by the render that publishes the board), unless the index lists that run. It has no site board. Each organization of its pull manifest has a pending file `leaderboard/<run>/pending/<org>.json`, `{"schema", "run", "org", "team", "entry"}` with the entry block of a team file, and the API adds `evaluation`, the status of the organization's submission per base model (`not_started`, `in_progress`, `completed`, or `error`) read from the run's `status.json` on every request. Nothing else of the status file reaches a viewer.
+
 | Request | Response |
 |---|---|
 | `GET /healthz` | `200 {"run", "date"}` of the index's latest run, both null before one is published. The pop-up also pings it to wake the Space. |
-| `GET /runs` | `200` with the index verbatim, or `503 {"error": "no_board"}` without one. No authentication. |
+| `GET /runs` | `200` with the index verbatim plus `"pending": <the pending run's block or null>`, or `503 {"error": "no_board"}` without an index. No authentication. |
 | `GET /board/<run>` | `200` with the run's site board verbatim, or `404 {"error": "not_found"}` for a run that is not a run name, is not in the index, or has no site board. No authentication. |
 | `GET /me[?run=<run>]` with `Authorization: Bearer <token>` | `200` with `{"role": "participant", "run", "teams", "missing"}` or `{"role": "organizer", "run", "board", "teams", "pull", "progress", "failures"}` for the run, by default the index's latest; `run` is the site board's `run` block. |
+| `GET /me?run=<pending run>` | `200` with `{"role": "participant", "pending": true, "run", "teams", "missing"}`, `teams` being the viewer's organizations' pending files each with `evaluation`, or `{"role": "organizer", "pending": true, "run", "board": null, "teams", "pull", "progress", "failures"}` with every pending file. The published view has no `pending` key. |
 | | `401 {"error": "invalid_token"}` when Hugging Face does not accept the token (checked before the run). |
-| | `404 {"error": "not_found"}` for a `run` that is not a run name or is not in the index. |
+| | `404 {"error": "not_found"}` for a `run` that is not a run name, or is neither in the index nor pending. |
 | | `503 {"error": "no_board"}` before a board is published. |
 | any of the above | `503 {"error": "archive_unavailable"}` when the archive cannot be read. |
 
-HTTPS only, no cookies, `GET` and the `Authorization` header only. CORS allows `ALLOWED_ORIGINS` and, when set, `ALLOWED_ORIGIN_REGEX`. The hf.space proxy in front of the app answers CORS requests from any origin by design, and browsers do not enforce this list there. Access rests on the bearer token, which another site cannot obtain, and the app refuses no request by its `Origin`. Logs give the viewer's handle, role, run, and status code, never a token or a file's contents.
+HTTPS only, no cookies, `GET` and the `Authorization` header only. CORS allows `ALLOWED_ORIGINS` and, when set, `ALLOWED_ORIGIN_REGEX`. The hf.space proxy in front of the app answers CORS requests from any origin by design, and browsers do not enforce this list there. Access rests on the bearer token, which another site cannot obtain, and the app refuses no request by its `Origin`. Logs give the viewer's handle, role, run, whether it is pending, and status code, never a token or a file's contents.
 
 ## Settings at deploy time
 
@@ -47,4 +50,4 @@ Optional: `USERINFO_URL` (default `https://huggingface.co/oauth/userinfo`) and `
 
 ## Tests
 
-From the repository that contains this Space: `python -m pytest spaces/leaderboard-api/tests`. They run against a stub userinfo server on a loopback port and a fixture archive directory with two runs.
+From the repository that contains this Space: `python -m pytest spaces/leaderboard-api/tests`. They run against a stub userinfo server on a loopback port and a fixture archive directory with two published runs and a pending one.

app.py

@@ -1,12 +1,15 @@
 """The results API behind the competition site's leaderboard pop-up, served from a public Hugging Face Space.
 
 The index of runs is `leaderboard/runs.json` in the archive (`RUNS`), which `challenge-leaderboard` rebuilds on every
-render. `GET /healthz` gives the latest run and its date (both null without an index), `GET /runs` gives the index,
+render, and the pending run (the run being evaluated between its intake and the publication of its board) is the
+`run` of `leaderboard/pending.json` (`PENDING`) when the index does not list it. `GET /healthz` gives the latest
+run and its date (both null without an index), `GET /runs` gives the index with the pending run under `pending`,
 and `GET /board/<run>` gives a run's site board (`leaderboard/<run>/site.json`), each without authentication.
 `GET /me` gives a signed-in viewer the files they may see for one run (`?run=<run>`, by default the index's
 latest): a participant gets the team file of each of their organizations, and an organizer gets every file of the
-run. The server decides the viewer's handle, organizations, and role from their OAuth token alone; a request names
-no organization.
+run. For the pending run it gives the pending files instead (`leaderboard/<run>/pending/<org>.json`), each with
+the evaluation's progress per base model read from the run's `status.json` (`evaluation`). The server decides the
+viewer's handle, organizations, and role from their OAuth token alone; a request names no organization.
 
 Settings (environment):
 - `HF_TOKEN` (a Space secret): the token that reads the archive dataset. It is read from the environment only, a
@@ -19,7 +22,8 @@ Settings (environment):
 - `USERINFO_URL`: the OAuth userinfo endpoint, `https://huggingface.co/oauth/userinfo` by default.
 - `ARCHIVE_DIR`: a local directory read in place of the archive dataset (tests and local previews).
 
-Logs give the viewer's handle, role, run, and status code only, never a token or a file's contents.
+Logs give the viewer's handle, role, run, whether it is pending, and the status code only, never a token or a
+file's contents.
 """
 from __future__ import annotations
 
@@ -42,6 +46,9 @@ logger = logging.getLogger("leaderboard-api")
 
 USERINFO_URL = "https://huggingface.co/oauth/userinfo"
 RUNS = "leaderboard/runs.json"  # the index of the runs with a site board, written by `challenge-leaderboard`
+PENDING = "leaderboard/pending.json"  # the run being evaluated, written by `challenge-leaderboard --pending`
+STATUS_FILE = "status.json"  # `<run>/status.json`, the evaluation's record of the run's work, one entry per key
+EVALUATION_STATUSES = ("not_started", "in_progress", "completed", "error")  # the status codes of its entries
 CACHE_SECONDS = 60  # how long a userinfo answer and a directory listing are reused
 USERINFO_TIMEOUT_SECONDS = 15
 HANDLE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,95}$")  # a Hugging Face user or organization handle
@@ -155,6 +162,34 @@ def site_board(archive, run: str) -> dict | None:
     return board if isinstance(board, dict) else None
 
 
+def pending_run(archive, index: dict | None) -> dict | None:
+    """The pending run's block, i.e., the `run` of `PENDING`, or None without one, for a malformed one (`run` not a
+    mapping, `name` not matching `RUN_NAME`, `models` not a list of strings), or when the index lists the run, since
+    a run in the index has been published whatever the pending index says."""
+    pending = _json(archive, PENDING)
+    run = pending.get("run") if isinstance(pending, dict) else None
+    if not isinstance(run, dict) or not RUN_NAME.fullmatch(str(run.get("name"))):
+        return None
+    if not isinstance(run.get("models"), list) or not all(isinstance(model, str) for model in run["models"]):
+        return None
+    if index is not None and index_entry(index, run["name"]) is not None:
+        return None
+    return run
+
+
+def evaluation(status: dict | None, org: str, models: list[str]) -> dict[str, str]:
+    """The evaluation's progress of one organization's submission per base model, in the order of `models`: the
+    status code of the `status.json` entry `submission-<org>/<model slug>` (the ref with `/` replaced by `__`), and
+    `not_started` without the file, the entry, or a code of `EVALUATION_STATUSES`. The code is the only field read
+    from an entry, and no other entry is read."""
+    codes = {}
+    for model in models:
+        entry = status.get(f"submission-{org}/{model.replace('/', '__')}") if isinstance(status, dict) else None
+        code = entry.get("status") if isinstance(entry, dict) else None
+        codes[model] = code if code in EVALUATION_STATUSES else "not_started"
+    return codes
+
+
 def viewer_role(info: dict, settings: dict) -> tuple[str, list[str]]:
     """`organizer` for a handle in `ORGANIZER_USERS` or a member of `ORGANIZER_ORG`, else `participant`, with the
     viewer's organization handles in the order the userinfo lists them."""
@@ -194,6 +229,41 @@ def organizer_payload(archive, entry: dict) -> dict:
             "failures": _text(archive, f"{run}/failures.md")}
 
 
+def _with_evaluation(archive, run: dict, org: str, team: dict | None, status: dict | None) -> dict | None:
+    """A pending file with the organization's `evaluation` block added, or None without the file."""
+    if not isinstance(team, dict):
+        return None
+    return {**team, "evaluation": evaluation(status, org, run["models"])}
+
+
+def pending_participant_payload(archive, run: dict, orgs: list[str]) -> dict:
+    """The pending run's `run` block, the pending file of each of the viewer's organizations that has one, in the
+    userinfo's order, each with its `evaluation` block from the run's `status.json` (read on every request), and
+    the organizations without one under `missing`."""
+    status = _json(archive, f"{run['name']}/{STATUS_FILE}")
+    teams, missing = [], []
+    for org in orgs:
+        team = _with_evaluation(archive, run, org, _json(archive, f"leaderboard/{run['name']}/pending/{org}.json"),
+                                status)
+        (missing.append(org) if team is None else teams.append(team))
+    return {"role": "participant", "pending": True, "run": run, "teams": teams, "missing": missing}
+
+
+def pending_organizer_payload(archive, run: dict) -> dict:
+    """The pending run's `run` block, a null board, every pending file of the run with its `evaluation` block, the
+    pull manifest, and the run's progress and failures files."""
+    name = run["name"]
+    status = _json(archive, f"{name}/{STATUS_FILE}")
+    teams = {}
+    for path in archive.listing(f"leaderboard/{name}/pending"):
+        if path.endswith(".json"):
+            org = Path(path).stem
+            teams[org] = _with_evaluation(archive, run, org, _json(archive, path), status)
+    return {"role": "organizer", "pending": True, "run": run, "board": None, "teams": teams,
+            "pull": _json(archive, f"{name}/manifest.json"), "progress": _text(archive, f"{name}/progress.txt"),
+            "failures": _text(archive, f"{name}/failures.md")}
+
+
 def create_app(settings: dict | None = None) -> FastAPI:
     """The API with CORS for the configured origins, `GET` and the `Authorization` header only, and no cookies."""
     settings = settings_from_env() if settings is None else settings
@@ -251,8 +321,12 @@ def create_app(settings: dict | None = None) -> FastAPI:
         if index is None:
             logger.info("runs: 503")
             return JSONResponse({"error": "no_board"}, status_code=503)
-        logger.info("runs: 200")
-        return index
+        try:
+            pending = pending_run(archive, index)
+        except HfHubHTTPError as exc:
+            return unavailable("runs", exc)
+        logger.info("runs: 200 (pending %s)", pending["name"] if pending else "-")
+        return {**index, "pending": pending}
 
     @app.get("/board/{run}")
     def board(run: str):
@@ -278,21 +352,27 @@ def create_app(settings: dict | None = None) -> FastAPI:
         role, orgs = viewer_role(info, settings)
         try:
             index = runs_index(archive)
-            if index is None:
-                logger.info("me: %s %s %s 503", handle, role, run or "-")
-                return JSONResponse({"error": "no_board"}, status_code=503)
-            name = index["latest"] if run is None else run
-            entry = index_entry(index, name) if RUN_NAME.fullmatch(name) else None
-            if entry is None:
-                logger.info("me: %s %s %s 404", handle, role, name)
-                return JSONResponse({"error": "not_found"}, status_code=404)
-            payload = (organizer_payload(archive, entry) if role == "organizer"
-                       else participant_payload(archive, entry, orgs))
+            pending = pending_run(archive, index) if run is not None else None
+            if pending is not None and run == pending["name"]:
+                name, kind = run, "pending"
+                payload = (pending_organizer_payload(archive, pending) if role == "organizer"
+                           else pending_participant_payload(archive, pending, orgs))
+            else:
+                if index is None:
+                    logger.info("me: %s %s %s 503", handle, role, run or "-")
+                    return JSONResponse({"error": "no_board"}, status_code=503)
+                name, kind = (index["latest"] if run is None else run), "published"
+                entry = index_entry(index, name) if RUN_NAME.fullmatch(name) else None
+                if entry is None:
+                    logger.info("me: %s %s %s 404", handle, role, name)
+                    return JSONResponse({"error": "not_found"}, status_code=404)
+                payload = (organizer_payload(archive, entry) if role == "organizer"
+                           else participant_payload(archive, entry, orgs))
         except HfHubHTTPError as exc:  # e.g., no read token yet
             logger.error("me: %s %s %s 503; the archive could not be read (%s)", handle, role, run or "-",
                          type(exc).__name__)
             return JSONResponse({"error": "archive_unavailable"}, status_code=503)
-        logger.info("me: %s %s %s 200", handle, role, name)
+        logger.info("me: %s %s %s %s 200", handle, role, name, kind)
         return payload
 
     return app

tests/conftest.py

@@ -23,7 +23,10 @@ TOKENS = {
                           "orgs": [{"preferred_username": "team-a"}, {"preferred_username": "team-z"}]},
     "organizer-token": {"preferred_username": ORGANIZER, "orgs": []},
     "member-token": {"preferred_username": "bob", "orgs": [{"preferred_username": ORGANIZER_ORG}]},
+    "other-token": {"preferred_username": "carol", "orgs": [{"preferred_username": "team-q"}]},
 }
+PENDING_RUN = {"name": "week_03", "label": "Week 3", "layer": "public", "pull_finished": "2026-10-13T12:41:10+00:00",
+               "n_pulled": 2, "models": ["m/one", "m/two", "m/three"]}
 RUN_BLOCKS = {
     "week_01": {"name": "week_01", "label": "Week 1", "layer": "public", "date": "2026-10-02",
                 "deadline": "2026-09-29T12:00:00+00:00", "n_ranked": 2, "n_baselines": 1},
@@ -74,6 +77,22 @@ def site_board(run: str) -> dict:
                       "delta": 0.2, "r_side": 0.01, "r_guard": 0.02}]}
 
 
+def pending_file(org: str, team: str) -> dict:
+    return {"schema": 1, "run": PENDING_RUN, "org": org, "team": team,
+            "entry": {"status": "pulled", "repo_private": True, "evaluator_role": "read", "commit": "c" * 40,
+                      "commit_time": "2026-10-12T10:00:00+00:00", "pulled_at": "2026-10-13T12:03:51+00:00",
+                      "files": [{"path": "method_card.md", "bytes": 3120}], "card": None, "label": "ccccccc",
+                      "intake": None, "record": [["repo", f"{org}/submission"], ["commit", f"{'c' * 12}  2026-10-12 10:00 UTC"],
+                                                 ["pulled", "2026-10-13 12:03 UTC"], ["files", "method_card.md  3 KB"],
+                                                 ["intake", "no intake report for this run"]],
+                      "method_card": {"file": "method_card.md", "text": f"# {team}\n", "truncated": False}}}
+
+
+def status_entry(status: str, **fields) -> dict:
+    return {"after": ["elicit/m__one"], "error": None, "heartbeat": "2026-10-13T14:00:00+00:00", "kind": "submission",
+            "status": status, "updated_at": "2026-10-13T14:00:00+00:00", "worker": "worker-7:12345", **fields}
+
+
 def team_file(run: str, org: str) -> dict:
     return {"schema": 2, "run": {**RUN_BLOCKS[run], "pull_finished": None, "models": ["m/one"]}, "org": org,
             "team": org.title(), "entry": {"status": "pulled", "record": [["repo", f"{org}/submission"]]},
@@ -83,7 +102,8 @@ def team_file(run: str, org: str) -> dict:
 @pytest.fixture()
 def archive(tmp_path: Path) -> Path:
     """An archive with the runs `week_01` and `week_02` indexed, `week_00` indexed without a site board, `week_03`
-    with an internal board and no site board (not indexed), and the pull files of `week_02`."""
+    pending (an internal board and no site board, not indexed, with a pending index, two pending files, and a status
+    file), and the pull files of `week_02` and `week_03`."""
     root = tmp_path / "archive"
     write(root, "leaderboard/runs.json", {"schema": 1, "latest": "week_02",
                                           "runs": [{"name": "week_00", "label": "Week 0", "layer": "public",
@@ -101,6 +121,19 @@ def archive(tmp_path: Path) -> Path:
     write(root, "week_02/manifest.json", {"run": "week_02", "orgs": [{"org": "team-a", "status": "pulled"}]})
     write(root, "week_02/progress.txt", "## submissions\n- [✓] team-a\n")
     write(root, "week_02/failures.md", "# Failures\n\nnone\n")
+    # the pending run: an index, two pending files, and a status file with entries for one of them on two models
+    write(root, "leaderboard/pending.json", {"schema": 1, "run": PENDING_RUN})
+    write(root, "leaderboard/week_03/pending/team-a.json", pending_file("team-a", "Team A"))
+    write(root, "leaderboard/week_03/pending/team-b.json", pending_file("team-b", "Team B Secret"))
+    write(root, "week_03/status.json", {
+        "elicit/m__one": status_entry("completed", kind="elicit", after=[]),
+        "submission-team-a/m__one": status_entry("completed"),
+        "submission-team-a/m__two": status_entry("in_progress", error="a secret traceback"),
+        "submission-team-b/m__one": status_entry("error", error="another secret traceback")})
+    write(root, "week_03/manifest.json", {"run": "week_03", "orgs": [{"org": "team-a", "status": "pulled"},
+                                                                     {"org": "team-b", "status": "pulled"}]})
+    write(root, "week_03/progress.txt", "## submissions\n- [ ] team-a\n- [✗] team-b\n")
+    write(root, "week_03/failures.md", "# Failures\n\nteam-b\n")
     return root
 
 

tests/test_app.py

@@ -10,7 +10,7 @@ from fastapi.testclient import TestClient
 from huggingface_hub.errors import HfHubHTTPError
 
 import app as leaderboard_api
-from conftest import RUN_BLOCKS, settings
+from conftest import PENDING_RUN, RUN_BLOCKS, settings
 
 
 def read(archive: Path, path: str):
@@ -29,10 +29,12 @@ def test_the_fixture_archive_holds_two_runs_with_a_site_board(archive: Path) ->
 
 
 def test_runs_gives_the_index_verbatim(client: TestClient, archive: Path) -> None:
+    """The index's fields are served as written, with the pending run added under `pending`."""
     response = client.get("/runs")
     assert response.status_code == 200
-    assert response.json() == read(archive, "leaderboard/runs.json")
-    assert response.json()["latest"] == "week_02"
+    assert {key: value for key, value in response.json().items() if key != "pending"} == read(
+        archive, "leaderboard/runs.json")
+    assert response.json()["latest"] == "week_02" and "pending" in response.json()
 
 
 def test_runs_without_an_index_is_no_board(empty_client: TestClient) -> None:
@@ -62,7 +64,7 @@ def test_board_gives_a_runs_site_board_verbatim(client: TestClient, archive: Pat
 def test_board_is_not_found_for_an_unknown_malformed_or_unindexed_run(client: TestClient) -> None:
     """An unknown run, a name that is not a run name, a run with an internal board but no site board that the index
     does not list, and an indexed run without a site board each answer 404."""
-    for run in ("nope", "Week-01", "week_03", "week_00"):
+    for run in ("nope", "Week-01", "week_03", "week_04", "week_00"):
         response = client.get(f"/board/{run}")
         assert response.status_code == 404 and response.json() == {"error": "not_found"}, run
 
@@ -106,9 +108,9 @@ def test_me_gives_an_organizer_every_file_of_the_run(client: TestClient, archive
 
 
 def test_me_answers_404_for_an_unknown_run_and_401_before_it(client: TestClient) -> None:
-    """An unknown run, a name that is not a run name, and a run the index does not list each answer 404; a missing
-    or rejected token answers 401 before the run is looked at."""
-    for run in ("nope", "Week-01", "week_03"):
+    """An unknown run, a name that is not a run name, and a run that is neither in the index nor pending each
+    answer 404; a missing or rejected token answers 401 before the run is looked at."""
+    for run in ("nope", "Week-01", "week_04"):
         response = client.get("/me", params={"run": run}, headers=bearer("participant-token"))
         assert response.status_code == 404 and response.json() == {"error": "not_found"}, run
     assert client.get("/me", params={"run": "nope"}).status_code == 401
@@ -151,3 +153,73 @@ def test_an_unreadable_archive_is_503_everywhere(archive: Path, userinfo_url: st
                     client.get("/me", headers=bearer("participant-token"))):
         assert request.status_code == 503 and request.json() == {"error": "archive_unavailable"}
     assert client.get("/me").status_code == 401
+
+
+# ---- the pending run ----------------------------------------------------------------------------------------
+
+
+def test_runs_names_the_pending_run(client: TestClient, archive: Path, userinfo_url: str) -> None:
+    """`/runs` carries the pending run's block; it is null with the index cleared, with a pending index naming a
+    run the index lists, and with a malformed pending index."""
+    response = client.get("/runs")
+    assert response.status_code == 200
+    assert response.json()["pending"] == PENDING_RUN
+    assert {key: value for key, value in response.json().items() if key != "pending"} == read(archive, "leaderboard/runs.json")
+    pending = archive / "leaderboard" / "pending.json"
+    for cleared in ({"schema": 1, "run": None}, {"schema": 1, "run": {**PENDING_RUN, "name": "week_02"}},
+                    {"schema": 1, "run": {**PENDING_RUN, "name": "Week 3"}}, {"schema": 1, "run": {**PENDING_RUN, "models": "m/one"}},
+                    {"schema": 1}):
+        pending.write_text(json.dumps(cleared), encoding="utf-8")
+        assert client.get("/runs").json()["pending"] is None, cleared
+        assert client.get("/me", params={"run": "week_03"}, headers=bearer("participant-token")).status_code == 404
+    pending.unlink()
+    assert client.get("/runs").json()["pending"] is None
+
+
+def test_me_gives_a_participant_their_pending_files_with_the_evaluation_per_model(client: TestClient,
+                                                                                 archive: Path) -> None:
+    response = client.get("/me", params={"run": "week_03"}, headers=bearer("participant-token"))
+    assert response.status_code == 200
+    payload = response.json()
+    assert list(payload) == ["role", "pending", "run", "teams", "missing"]
+    assert (payload["role"], payload["pending"], payload["run"]) == ("participant", True, PENDING_RUN)
+    assert payload["missing"] == ["team-z"] and len(payload["teams"]) == 1
+    team = payload["teams"][0]
+    assert team["evaluation"] == {"m/one": "completed", "m/two": "in_progress", "m/three": "not_started"}
+    assert {key: value for key, value in team.items() if key != "evaluation"} == read(
+        archive, "leaderboard/week_03/pending/team-a.json")
+    text = response.text
+    for forbidden in ("team-b", "Team B Secret", "error", "worker", "heartbeat", "traceback", "after", "updated_at"):
+        assert forbidden not in text, forbidden
+    other = client.get("/me", params={"run": "week_03"}, headers=bearer("other-token"))
+    assert other.status_code == 200 and other.json()["teams"] == [] and other.json()["missing"] == ["team-q"]
+    (archive / "week_03" / "status.json").unlink()
+    without = client.get("/me", params={"run": "week_03"}, headers=bearer("participant-token")).json()
+    assert without["teams"][0]["evaluation"] == {model: "not_started" for model in PENDING_RUN["models"]}
+
+
+def test_me_gives_an_organizer_every_pending_file(client: TestClient, archive: Path) -> None:
+    response = client.get("/me", params={"run": "week_03"}, headers=bearer("organizer-token"))
+    assert response.status_code == 200
+    payload = response.json()
+    assert list(payload) == ["role", "pending", "run", "board", "teams", "pull", "progress", "failures"]
+    assert (payload["role"], payload["pending"], payload["run"], payload["board"]) == ("organizer", True,
+                                                                                       PENDING_RUN, None)
+    assert set(payload["teams"]) == {"team-a", "team-b"}
+    assert payload["teams"]["team-a"]["evaluation"] == {"m/one": "completed", "m/two": "in_progress",
+                                                        "m/three": "not_started"}
+    assert payload["teams"]["team-b"]["evaluation"] == {"m/one": "error", "m/two": "not_started",
+                                                        "m/three": "not_started"}
+    assert payload["teams"]["team-b"]["team"] == "Team B Secret"
+    assert payload["pull"] == read(archive, "week_03/manifest.json")
+    assert payload["progress"].startswith("## submissions") and payload["failures"].startswith("# Failures")
+    assert "traceback" not in response.text
+
+
+def test_the_pending_run_has_no_board_and_is_not_the_default(client: TestClient) -> None:
+    assert client.get("/board/week_03").status_code == 404
+    latest = client.get("/me", headers=bearer("participant-token")).json()
+    assert latest["run"]["name"] == "week_02" and "pending" not in latest
+    assert client.get("/healthz").json() == {"run": "week_02", "date": "2026-10-09"}
+    assert client.get("/me", params={"run": "week_03"}).status_code == 401
+    assert client.get("/me", params={"run": "week_03"}, headers=bearer("bad-token")).status_code == 401