# Annotation format — `proact-studio-v3`

All fifteen released files share exactly one shape. There are no task-specific or
track-specific keys: if a field exists in one file it exists in all of them, with
the same type. A loader written against one file reads all of them.

The only difference between splits is **which fields carry values**:

| Field | `*_dev` | `*_test` |
|---|---|---|
| `videos.*.samples` | the segment annotations | `{}` |
| `clips.*.sample_ids` | present | **absent** |
| `qa_items.*.answer_choices` | present, with `letter` | present, with `letter` |
| `qa_items.*.answer` / `correct_letter` | present | **absent** |
| `canary` | present (dev only) | absent |

## Top level

```jsonc
{
  "schema_version": "proact-studio-v3",
  "task": "state_tracking",   // "information_capture" | "state_tracking" | "location_tracking"
  "kind": "canonical",
  "rev": 0,
  "split": "test",            // "test" | "dev"
  "ground_truth_released": false,
  "videos": { … },            // the annotations, indexed by source video
  "clips": { … }              // the evaluation units, indexed by clip
}
```

**Check `ground_truth_released` before you score anything.** On the test split it
is `false`, `videos.*.samples` is `{}`, and `sample_ids` is absent — by design. A
loader that iterates the samples tree without checking will report zero segments
and score every model at 0.0 without erroring.

The `task` field and the paper's short labels correspond as
**`information_capture` → IC**, **`state_tracking` → ST**,
**`location_tracking` → LT**.

## `videos.<video_uid>`

```jsonc
{
  "video_uid": "3dd00666-a34d-4b45-bb4c-7a4c2342e475",
  "video_path": null,         // always null; video is not distributed
  "samples": { … }            // {} on the test split
}
```

`video_uid` is the **upstream** id: an Ego4D video UID, a FineBio id such as
`P01_01_02`, or a BioVL-QR name such as `purifydna_1`.

## `videos.<video_uid>.samples.<sample_id>` — a segment

One annotated thing-worth-speaking-about, in one video. **Dev only.**

```jsonc
{
  "sample_id": "proact_st_3b538dd6-a02d-5500-8b41-cdf5ec005677",
  "task": "state_tracking",
  "object": "kettle",
  "note": "unattended: yes",
  "times":       { "start_sec": 23.569444, "end_sec": null },
  "clip":        { "clip_uid": "proact_clip_…",
                   "local_start_sec": 23.569444,
                   "local_end_sec": null }
}
```

| Field | Meaning |
|---|---|
| `object` | the ground-truth object identity. This is the string the LLM judge compares a model's free-text mention against. There is no ground-truth *message* text. |
| `note` | free-text annotator note. Task-dependent and **not** part of the scored reference — e.g. ST uses it for `unattended: yes/no`. |
| `times` | **source-video** seconds. |
| `clip.local_*` | the same instants relative to `clips[clip_uid].abs_start_sec`. |

### `end_sec: null` is an open interval, not missing data

The state or location was still current when the clip ended. The segment is
genuinely open, and the intended reading is "still true at the clip boundary".

There are **318** open segments in the Daily track and **159** in Science; Science
LT alone is 144 of 371. A loader that treats `null` as a parse error, or that drops
such segments, discards a large fraction of the ground truth.

The scoring rule is in `eval_config.json`: clamp the end to
`clips[clip_uid].duration_sec`, then drop the segment if `end <= start`.

Whenever `times.end_sec` is `null`, `clip.local_end_sec` is `null` too.

## `clips.<clip_uid>` — an evaluation unit

A clip is what a model is actually shown. Models are evaluated per clip, never on
a whole source video.

```jsonc
{
  "clip_uid": "proact_clip_618ac742-847f-51da-9275-6a551bde597c",
  "video_uid": "3dd00666-a34d-4b45-bb4c-7a4c2342e475",
  "clip_path": null,              // always null; video is not distributed
  "abs_start_sec": 793.413382,    // cut window in the SOURCE video
  "abs_end_sec":   973.413382,
  "duration_sec":  180.0,
  "sample_ids": [ "proact_vc_…", … ],   // ABSENT on the test split
  "qa_items": { … }
}
```

To reconstruct the clip, cut the source video from `abs_start_sec` to
`abs_end_sec`. The clip-local times on every sample are then correct with no
further offset.

`duration_sec` is present and non-null on all 400 clips, in every split. It is
load-bearing: open segments are resolved against it, so a missing duration
silently deletes them.

### Why `sample_ids` is withheld on test

Its **length** is the number of events to report in that clip, and an empty list
identifies a **declared negative** — a clip where nothing is worth speaking about,
the correct output is silence, and any prediction is a false positive. Both are
answers, so neither ships. On dev, `sample_ids` is present and every id resolves
in `videos.*.samples`.

## `clips.<clip_uid>.qa_items.<qa_id>` — the memory probe

```jsonc
{
  "qa_id": "proact_qa_00bb8716-48f2-43a4-979b-0842ae465bdb",
  "question": "What warning was written on the floor sign I saw?",
  "answer_choices": [
    { "letter": "A", "text": "Watch Your Step" },
    { "letter": "B", "text": "Caution Wet Floor" },
    { "letter": "C", "text": "Cleaning in Progress" },
    { "letter": "D", "text": "Caution Wet Paint" }
  ],

  // dev only:
  "answer": "Caution Wet Floor",
  "correct_letter": "B",
  "notes": ""
}
```

Every QA item in both tracks is 4-way multiple choice — all 1,500 of them.

### Present the choices in the order given. Do not reorder them.

The released order **is** the scored order: the `letter` in each choice is the
letter the scorer expects. Correct answers are spread evenly over `A`/`B`/`C`/`D`.

- **Read `letter`; never recompute it.**
- **Submit letters, not choice text.** A submission is `qa_id → letter`.

`answer` is the correct option's text, duplicated for convenience. `notes` is an
annotator field, usually empty, and is not scored.

Five clips have empty `qa_items` (four Daily, one Science).

## Worked example — load and iterate

```python
import json

gt = json.load(open("json/main_dev/state_tracking.json"))
assert gt["ground_truth_released"], "test split carries no annotations"

# index samples by id, since they live under their video
samples = {sid: s
           for v in gt["videos"].values()
           for sid, s in v["samples"].items()}

for clip_uid, clip in gt["clips"].items():
    segments = [samples[sid] for sid in clip["sample_ids"]]

    if not segments:
        pass  # declared negative: the model should stay silent

    for s in segments:
        start = s["clip"]["local_start_sec"]
        end   = s["clip"]["local_end_sec"]
        if end is None:
            end = clip["duration_sec"]        # open interval -> clip boundary
        if end <= start:
            continue                          # zero-length; the matcher drops these
        # s["object"] is the reference the judge scores a mention against

    for qa in clip["qa_items"].values():
        prompt = "\n".join(f'{c["letter"]}. {c["text"]}' for c in qa["answer_choices"])
        gold = qa["correct_letter"]            # dev only
```

On the test split, drop the segment half of that loop and keep the QA half
without `gold`.

## What is deliberately absent

Construction metadata was removed before release and is not recoverable from
these files: annotator accounts and per-edit history, review and acceptance
blocks, free-text object descriptions, generated proactive message templates, and
the QA provenance layer. 5,628 personal identifiers were removed; zero remain.

This means the released files record **what the ground truth is**, not **who
produced it or when**. If you need inter-annotator agreement figures, they are
reported in the paper rather than derivable from this release.