# Prequential cutoffs for the live tier

## Status

Implemented. `TaskCard.cutoff_schedule` accepts monotone ISO timestamps, the
validator rejects non-monotone schedules, and the scorer evaluates scheduled
tasks cumulatively at each cutoff before emitting one backward-compatible
aggregate `TaskScore`.

## Why

The v1 scoring collapses every prediction for a `live` task into one
aggregate. That makes a model's position indistinguishable from an
average-over-time; readers cannot tell whether the model was strong early
and drifted, or strong late and is still climbing. Impermanent's
prequential protocol makes rank drift visible by bucketing each evaluation
at a rolling cutoff and reporting the rank per cutoff window.

FUTURE-TS already has richer as-of semantics than Impermanent
(`available_at`, `first_published_at`, `last_updated_at`,
`source_release_id`). Rolling cutoffs are the evaluation-time surface that
operationalises those semantics.

## Contract

A task card can optionally declare a cutoff schedule:

```json
"cutoff_schedule": [
  "2026-05-01T00:00:00Z",
  "2026-05-15T00:00:00Z",
  "2026-06-01T00:00:00Z"
]
```

Each entry is a wall-clock moment at which the task is scored using only
actuals whose `available_at <= cutoff`. Predictions are unchanged; only
which actuals count toward scoring at each cutoff changes. The schedule
MUST be monotone non-decreasing.

Internally the scorer computes one per-cutoff `TaskScore` with the same shape
as today plus a `cutoff` field populated. The public `score_submission` API
still returns a single `BenchmarkReport`: scheduled tasks are aggregated into
one task-level score with `secondary_metrics.prequential_cutoff_count` set.
This preserves existing report consumers while making the prequential window
count explicit.

## Scoring semantics

For a task with cutoffs `c_0 < c_1 < ... < c_n`:

- At cutoff `c_i`, a prediction `p` contributes iff the matching actual's
  `available_at <= c_i`. Predictions whose actuals land later are excluded
  from the `c_i` window but may enter `c_{i+1}`.
- Each cutoff produces an internal per-task TaskScore with the existing
  raw/skill/CI fields and an added `cutoff` field matching the schedule entry.
- The task's aggregate score across cutoffs is the arithmetic mean of the
  normalized per-cutoff skills. Cohort-level rank averaging remains a
  leaderboard concern because ranks require multiple submissions.
- Bootstrap CIs are computed per cutoff; aggregate CI is the envelope of
  the per-cutoff CIs, not a fresh bootstrap — so rank movement between
  cutoffs is visible rather than smoothed out.

## Backward compatibility

Tasks without a `cutoff_schedule` (i.e. almost every task today) are
scored exactly as before: one evaluation window ending at `evaluation_as_of`
or the wall clock. Adding `cutoff_schedule` to an existing task is a
breaking benchmark change and MUST bump the task's version hash in the
benchmark manifest.

## Reporting

The report format accepts an optional `cutoff` field on `TaskScore` for
diagnostic per-slice reports, but the default `score_submission` output emits
the aggregate task score only. Mean aggregates per tier and per track remain
the headline numbers; downstream dashboards that need rank drift can compute
cohort ranks over the same cutoff schedule from archived reports.

## Open questions

- Should cutoff boundaries align with source update cadences (daily /
  weekly / monthly) automatically, or should task authors declare them
  explicitly? Current leaning: declared explicitly, so drift windows are
  stable even if a source's cadence changes.
- What happens when a submission is re-scored at a new cutoff that
  postdates its `frozen_at`? Answer: allowed — freezing is per-submission,
  not per-cutoff. The integrity guarantee is "no future-label contamination
  at prediction time," not "no re-scoring after submission."