# Submitting a method

## What your method may see

**The film's footage, and nothing else.** No rubric, no reference stills, no
metadata, no chains. Multimodal methods additionally get one fixed sentence,
identical for every film:

> Pick a hero frame from this movie. A hero frame is a single still image taken
> from within a movie that would work as its cover, thumbnail, or promotional
> entry point.

Available as `heroframe.QUERY`. Use it verbatim.

Frames must come from the shared 1 fps track. Selecting off a denser grid of
your own turns the comparison into a decoding-density comparison.

## Output format

One JSON object per line, one line per film:

```jsonl
{"movie_id": "0001_American_Beauty", "frames": [{"rank": 1, "frame_idx": 2477}, {"rank": 2, "frame_idx": 1893}]}
```

| Field | Required | Meaning |
|---|---|---|
| `movie_id` | yes | as in the benchmark |
| `frames[].frame_idx` | yes | index into that film's track |
| `frames[].rank` | yes | your own ordering, 1 = best. `S@k` measures how well you rank your own output |
| `frames[].score` | no | your internal score, carried through for analysis |

At most 5 frames per film. You choose how many. Scoring averages across your
frames rather than taking the best, so a fifth mediocre frame can lower your
score — submit the ones you would actually stand behind.

## Before you submit

**Verify your frame track.** `python scripts/02_verify_track.py --track ./track`
should report all films verified. A pool that differs from ours produces a
number that is not comparable, and nothing downstream will warn you.

**Score random as a control.** On the full corpus it should land at 0.501. If
your pipeline gives something materially different, the problem is in the
pipeline rather than in your method.

**Do not modify the prompt.** Scoring refuses to run if it has drifted. If you
edited it deliberately to study the metric, say so and report the result as
your own measurement rather than a benchmark score.

**Name the internal model.** If your method calls an LLM or VLM internally,
put the model in the method name and report the published configuration. This
is not bureaucracy: substituting CueKFS's internal model moved it across the
random baseline, because a stage silently degraded into its fallback path
without raising anything.

## Opening the pull request

Add a row to `LEADERBOARD.md` and attach the result JSON from
`scripts/04_evaluate.py`. Include:

1. **Method name**, with the internal model if there is one.
2. **`S` and the 95% CI**, from the result JSON.
3. **Reader used.** Should be `Qwen3.6-27B`; if not, say so — frame-level
   scores are not comparable across readers.
4. **Number of films and units.** Full corpus is 204 films; a subset is fine,
   but say which.
5. **Link to your code**, or the selections file.
6. **Verification output** from step 2.

## Reporting a partial run

Scoring a subset is a legitimate thing to do — the full corpus is about 20,000
reader calls per method. Report which films, and compare against the same
subset rather than against the full-corpus numbers:

```bash
python scripts/04_evaluate.py --selections mine.jsonl --track ./track \
    --name mine --movies 0001_American_Beauty 0003_CASABLANCA 0008_Fargo
```

Per-film scores for every official row are in `eval/baselines.jsonl`, so you can
reconstruct any subset's reference numbers without re-running them.

## What a strong result looks like

The gap to close is from 0.586 to 0.722 — 0.136 of S, or 0.818 of an insertion
position. Two things about that gap, from the analysis:

It is **not photographic quality**. Brightness, contrast, sharpness,
colourfulness and edge density all correlate at |ρ| ≤ 0.09 with a frame's
score, and a selector optimising exposure and focus scores below random.

It is **only partly faces**. Face size is the one strongly correlated
attribute (ρ = 0.485), but it is a threshold rather than a dial and it tops out
at 0.557. Human publicity stills score 0.165 higher with faces one eighth the
size.