Add files using upload-large-folder tool

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

docs/GROUND_TRUTH.md

@@ -0,0 +1,353 @@
+# Ground truth
+
+Every reference tuple in this benchmark comes from the game itself — a replay parser or a pinned
+engine — never from a human annotator and never from a model. That is the property that makes the
+corpus extensible: a new held-out case costs compute, not labelling, so the 20 published cases per
+environment can be refreshed without renegotiating what a label means.
+
+Two mechanisms:
+
+| | How $V_t$ is obtained | Environments |
+|---|---|---|
+| **Parser** | the game already computes the quantity; the adapter reads it out of the replay, demo, trace, or annotation | CS2, DOTA 2, SC2, GFootball, Badminton |
+| **Evaluator** | the game does not define a win probability, so a pinned engine supplies one for every prefix | Go, Chess, Gomoku, Doudizhu |
+
+A parser environment has no engine to pin and no evaluator noise — `score_after` in GFootball is
+the engine's own score. An evaluator environment has to pin the engine **and** its search budget,
+because a win probability is only reproducible at a fixed configuration; those pins are listed per
+environment below.
+
+Sources were last accessed **2026-09-04**.
+
+---
+
+## What every GT file contains
+
+```
+tasks/<game>/gt/<case_id>_gt.json
+```
+
+One file per case. The reference tuples live under `events` — **the same root key in all nine
+games**, and the same key an answer file uses — and each row carries T1's perception fields, T2's
+update label, and T3's resulting state side by side. Everything else in the
+file is provenance and is not scored: engine pins, thresholds, case type, per-class counts, audits.
+
+Each file also carries a top-level `_canary` string. Please keep it: it is how contamination gets
+detected later, and it costs a training pipeline nothing to drop these files.
+
+Row counts, which are also the strict-F1 denominators:
+
+| Game | Cases | Reference tuples | per case |
+|---|---|---|---|
+| Go        | 20 | 5,516 | 276 |
+| CS2       | 20 | 3,703 | 185 |
+| Chess     | 20 | 1,761 | 88 |
+| SC2       | 20 | 1,358 | 68 |
+| Badminton | 20 | 701 | 35 |
+| Gomoku    | 20 | 808 | 40 |
+| DOTA 2    | 20 | 597 | 30 |
+| Doudizhu  | 20 | 429 | 21 |
+| GFootball | 20 | 405 | 20 |
+| **Total** | **180** | **15,278** | |
+
+### Two conventions that are easy to misread
+
+**A T1-only row is not a missing label.** Go and Chess emit `capture` rows alongside `move` rows. A
+capture is a perception event with no $V_t$ update of its own — the move that caused it already
+carries that — so its `wr_swing` and `leader_after` are `null` by design (378 of 5,516 rows in Go,
+331 of 1,761 in Chess). Those rows are scored at T1 and excluded from the T2/T3 denominators.
+
+**Doudizhu abstains near a band boundary.** A row whose label sits within 2σ of its band edge
+carries `null` on that tier and `t2_unresolved` / `t3_unresolved` set (79 rows at T2, 47 at T3, out
+of 429). The PIMC estimate cannot separate those from the other side of the band, so scoring them
+would be scoring sampling noise. The model **cannot tell which rows those are** and must answer
+every row — abstention removes undecidable labels from the numerator; it does not make the task
+easier.
+
+---
+
+## T3 is not one metric
+
+T3 asks the same question everywhere — *where does this leave the match* — but what counts as an
+answer follows the $V_t$ of the environment:
+
+| T3 answer | Metric | Environments |
+|---|---|---|
+| a three-way class label | macro accuracy | Go, Chess, Gomoku, Doudizhu, DOTA 2, SC2 |
+| an exact integer score pair | exact-pair accuracy | GFootball, Badminton |
+| the cumulative score pair after the round | exact fraction | CS2 |
+
+`score.py` prints all three in one T3 column and each judge records which it computed. A class
+label where the score is the state would be a weaker question, and an exact pair where $V_t$ is a
+win probability would be unanswerable.
+
+T2's class vocabulary is not uniform either — it is whatever a change in that $V_t$ can be:
+`{A, B, equal}` on a win probability, four classes (`taken` / `extended` / `levelled` / `narrowed`)
+on a score differential, two (`T` / `CT`) on a CS2 round. Chance level therefore differs by game:
+0.333 on three classes, 0.25 on four, 0.5 on two. Every judge macro-averages over per-class recall
+precisely so a constant answer lands on chance instead of on the majority share — which on Go's T2
+would otherwise read **0.87** (4,481 of the 5,138 labelled rows are `equal`).
+
+---
+
+## Case stratification
+
+Cases are not a random sample of matches. Each environment selects 20 from a larger pool so the
+corpus contains matches that are hard for different reasons, and so no single class dominates the
+T2/T3 labels. Eight of the nine environments stratify by **trajectory shape**, derived from the $V_t$
+trajectory itself:
+
+- **blowout** — one side ahead essentially throughout
+- **tense** — repeated lead changes
+- **reversal** (CS2 and DOTA 2 call it **comeback**) — the eventual winner trailed
+
+| Game | blowout | tense | reversal / comeback |
+|---|---|---|---|
+| Go        | 5 | 10 | 5 |
+| Chess     | 3 | 11 | 6 |
+| Gomoku    | 6 | 10 | 4 |
+| Doudizhu  | 7 | 7  | 6 |
+| CS2       | 8 | 5  | 7 |
+| DOTA 2    | 7 | 6  | 7 |
+| GFootball | 7 | 6  | 7 |
+| Badminton | 6 | 7  | 7 |
+
+**SC2 is the exception** and its `CASE_TYPES.json` carries no trajectory label: resource-equivalent
+value rarely reverses inside a game, so within one match `leader_after` is effectively two-class
+{leader, equal} and a reversal class would be empty. It balances on **which side led** instead — 10
+A-led and 10 B-led — which is what keeps its dataset-pooled T3 from collapsing onto one class
+(A 568 / B 531 / equal 259 across 1,358 events).
+
+**The rule that assigns a trajectory type is per-environment, not shared.** It depends on the shape
+of that $V_t$: a score-difference $V_t$ makes *reversal* nearly impossible to detect from a trough
+(GFootball uses "winner ever trailed" plus a peak threshold), while a win-probability $V_t$ makes
+*blowout* the fragile one (Doudizhu keys on the winner-perspective trough at 0.12 / 0.22). Always
+smooth before taking an extremum.
+
+Six `CASE_TYPES.json` files carry numeric thresholds — Go, Chess, Gomoku, CS2, and DOTA 2 the stratification thresholds they used, SC2 its event-segmentation ones. Doudizhu carries the note that its thresholds are *fixed* across the corpus (re-tuning ε per case would stop macro accuracy being comparable between cases), and GFootball and Badminton record only the resulting distribution. All nine carry the per-case label (SC2's is `leading_side`). The $V_t$ definition is in every game's `instruction.md` and in the per-environment sections below; `CASE_TYPES.json` repeats it for Doudizhu, GFootball, Badminton, and SC2.
+
+---
+
+## Per environment
+
+### Go — board · evaluator
+
+| | |
+|---|---|
+| **Source** | SGF records via the OGS public API, fixture game 27400000 — <https://online-go.com> |
+| **GT mechanism** | evaluator. The adapter replays each move and evaluates **every prefix** |
+| **Engine pin** | KataGo, network `b18c384nbt`, **1600 visits** per position |
+| **$V_t$** | Black win probability, **±10 pp** dead band around 0.50 |
+| **Render** | plain 19×19 board, 612², 25 fps. No coordinates, move numbers, names, clocks, capture counters, komi, or evaluation bar |
+
+T1 is the move or capture with its time, colour, and board coordinate. T2 is the quantized signed
+change in Black's win rate caused by the move (`wr_swing`). T3 is the win-rate leader immediately
+after it (`leader_after`). Selection balances the winning colour 10 B / 10 W.
+
+Go is the largest environment by tuples per case (276), so it is where a model's ability to hold a
+whole match in view is most exposed — and where Protocol A's frame grid bites hardest.
+
+### Chess — board · evaluator
+
+| | |
+|---|---|
+| **Source** | public Lichess game export, fixture `cZWtZEBE` — <https://lichess.org> |
+| **GT mechanism** | evaluator, per-ply, with real per-ply timing |
+| **Engine pin** | **Stockfish 18, depth 20**, value function `white_expected_score_wdl` |
+| **$V_t$** | White-oriented expected score / WDL, **±10 pp** band. Draws map to the neutral label |
+| **Render** | plain 8×8 board, 548², 1 fps. No coordinates, move numbers, names, clocks, result text, captured-piece tray, or evaluation bar |
+
+T1 records the **destination square only**, not the origin — the released contract is deliberately
+weaker than full move notation. T2 is the quantized change in the White-oriented value; T3 is the
+post-ply leader.
+
+The video is natively 1 fps because a ply is a discrete event; Protocol A's sampler is clamped by
+the container rate, so it never asks ffmpeg to fabricate frames here.
+
+### Gomoku — board · evaluator
+
+| | |
+|---|---|
+| **Source** | competition PSQ records (Gomocup) |
+| **GT mechanism** | evaluator |
+| **Engine pin** | **Rapfi**, 1000 ms per turn, freestyle rule, `black_winrate_sigmoid_eval` (scaling factor 200) — <https://github.com/dhbloo/rapfi> |
+| **$V_t$** | **tempo-neutral** smoothed Black win probability, ±10 pp band |
+| **Render** | plain 15×15 board, 504², 25 fps. No coordinates, move numbers, names, clocks, or engine annotations |
+
+**Why the smoothing matters.** Gomoku is attack-dominant, so a raw side-to-move win rate swings
+back and forth with whose turn it is — a square wave that has nothing to do with who is actually
+ahead. Left alone it turns "who leads" into "who moves next", which is a **move-parity shortcut**,
+readable off the stone count with no understanding of the position. The release applies
+`v_smooth[t] = (v[t] + v[t-1]) / 2` (`trailing2_movepair`) to cancel it, then gates on terminal
+consistency. All 20 cases share that pin.
+
+### Doudizhu — card · evaluator
+
+| | |
+|---|---|
+| **Source** | DouZero-WP greedy self-play deals (τ=0) — <https://github.com/kwai/DouZero>, weights at <https://huggingface.co/palemoky/douzero-baselines> |
+| **GT mechanism** | evaluator: **hidden-hand PIMC** — determinize, then roll out |
+| **Estimator** | adaptive **400–4000 worlds** per state, greedy rollouts with the released DouZero-WP policy. The PIMC estimator is part of this benchmark, not a DouZero component |
+| **$V_t$** | landlord win probability = fraction of sampled deals the landlord wins. Bands: landlord > 0.55, farmers < 0.45, else equal. T2 impact ε = 0.034, T3 band = 0.05 |
+| **Render** | tabletop, 1280×720, 24 fps. Landlord hand and the three bottom cards face up; **farmer hands face down**, showing only their counts. No numeric score, timer, move counter, or probability display |
+
+**Hiding the farmer hands is what makes $V_t$ non-degenerate.** With every hand visible the value is
+close to a deterministic function of the cards, and the task collapses into card counting. The
+evaluator is given exactly the landlord's information set — own hand, the bottom three, all plays
+so far, and both farmer card *counts* — and samples uniformly from the deals consistent with it.
+
+That leaves one shortcut worth naming, because it is the one a model will find: *"whoever holds
+fewer cards is ahead."* Card counts are public, so it is tempting. Measured over 9,954 events, it
+buys only **+0.05–0.09** macro accuracy and is at its worst in the endgame — exactly when the
+landlord's hand is also small but the outcome runs the other way. Across this corpus it is capped
+at **macro_acc ≤ 0.45**.
+
+T1 is every move that plays ≥1 card, with the player, combination type, and card count; passes are
+shown on screen but never reported. Each play occupies a 6 s display window and `game_clock_s` is
+its midpoint, so the ±3 s tolerance is exactly half a window — any time inside the window pairs up,
+with no ambiguity across plays.
+
+### Counter-Strike 2 — FPS · parser
+
+| | |
+|---|---|
+| **Source** | public professional-match demo (`.dem`) files published on HLTV; the game is <https://www.counter-strike.net> |
+| **GT mechanism** | parser, our own, at the demo's **native 64 Hz** tick rate; positions resampled to 4 Hz for the render |
+| **$V_t$** | the **cumulative round score**, by persistent team (A / B) across the halftime side swap |
+| **Render** | clean top-down radar, 768², 15 fps, 1:1 real pace. Map geometry, player motion, bomb state, and event-relevant effects preserved; HUD, scoreboard, round counter, kill feed, economy, names, and audio removed |
+
+T1 covers six event types — `kill`, `bomb_planted`, `bomb_defused`, `bomb_exploded`, `elimination`,
+`save` — with their time and type-specific attributes. **On a `kill`, the side and the dot number
+1–10 identify the victim, not the killer**, because the death marker is rendered without team colour
+or number. A `kill` row therefore carries `side` and `number`; the four conclusion types carry
+`winner_side` instead, and `bomb_planted` carries the planter's `side`.
+
+T2 is the winner of the round containing the event; T3 is the cumulative score right after that
+round. Both are carried **on every event row** and are round-constant, rather than exposed as
+separate per-round fields.
+
+The retained bomb/countdown corner clock is the only on-screen number in the whole corpus, and it is
+deliberate: it is the round timer, not the state.
+
+> **`score_after` is cumulative, so its errors propagate.** One early round mis-attributed shifts
+> every later row's `score_after`, and because strict F1 voids a tuple on any wrong field, a single
+> early mistake can cost the rest of the match. This is the intended difficulty — tracking means
+> tracking — but read a near-zero CS2 strict F1 against its T1, which is scored independently.
+
+**20 cases**: 8 blowout / 5 tense / 7 comeback, listed in `tasks/cs2/CASE_TYPES.json`.
+
+### DOTA 2 — MOBA · parser
+
+| | |
+|---|---|
+| **Source** | Valve replays plus OpenDota match records — <https://www.opendota.com>, <https://github.com/odota> |
+| **GT mechanism** | parser (manta-based) for events, OpenDota's minute-level gold curve for the state |
+| **$V_t$** | the **parsed net-worth advantage** — explicitly *not* a learned win-probability model. `even` = within **±1000 gold** |
+| **Render** | the real minimap terrain art with GT-anchored coordinates and real game sprites, 768², 15 fps. HUD, scoreboard, clock, net-worth graph, names, and objective counters removed |
+
+T1 covers six event types — first blood, teamfight, tower, barracks, Roshan, ancient — each with
+its own attributes (side, killer or winner, death counts, tier, lane, objective type). T2 quantizes
+the change in net-worth advantage over the aligned **minute-level** interval (`minute_gain`); T3 is
+the net-worth leader at that interval's end (`leader_after`).
+
+**Time axis.** Every DOTA 2 video starts **8 s before the horn** (`video.preroll_s = 8.0`, speed 1.0, in all 20 cases), so `video_ts = max(0, game_s) + 8` and the event's minute is `m = floor(max(0, video_ts − 8) / 60)` — this reproduces the GT minute for all 597 events, where the older `floor(video_ts / 60)` agreed on only 521. Events the parser dates **before** the horn are clamped to the horn, `video_ts` = 8.0, even when they fall before the video's first frame (game second −8) — eight rows: first blood in dota-02/03/04/05/06/07, plus a pre-game teamfight in dota-04 and dota-06. The dota-04 teamfight (game second −47) carries `deaths: 0` and `winner_side: even`; it is kept as the parser emitted it rather than edited by hand, so read a miss on that one row with this in mind.
+
+Using the parsed gold curve rather than a win model is a deliberate choice: a learned win
+probability would make the reference depend on a model, and then the benchmark would be scoring
+agreement with that model rather than with the game.
+
+> **Its T2/T3 macro is computed over *matched* events only** (as is SC2's). Low T1 recall therefore
+> shrinks the T2/T3 denominator and can **delete the hard classes — especially `equal` — from it**,
+> so a T3 number backed by one surviving class is not comparable to one backed by three. The other
+> seven judges count an unlocalized event as wrong instead. `score.py` prints T1 next to T2/T3 so
+> the two can be read together.
+
+DOTA 2 is the longest environment (47.8 ± 15.4 min), which is why its Protocol A recall ceiling is
+the lowest in the corpus at **0.597**.
+
+### StarCraft II — RTS · parser
+
+| | |
+|---|---|
+| **Source** | engine-generated AI-vs-AI replays (difficulty *Harder*, 6 matchups, 2017 ladder maps). Replay protocol: <https://github.com/Blizzard/s2client-proto> |
+| **GT mechanism** | parser — the replay **tracker stream**, read during a `disable_fog` god-view replay pass; deaths from raw `dead_units` (morph-free) |
+| **Engine** | SC2 **4.10, base build 75689** (Blizzard Linux research build) via PySC2, rendered with EGL |
+| **$V_t$** | **resource-equivalent advantage share** $s=(V_A-V_B)/(V_A+V_B)\in[-1,1]$, band **±0.10**. $V$ = banked minerals + gas, live army value, economy value, technology value |
+| **Render** | full-map isometric observer god-view, 1536², **5.6 fps**, real time. Resource counters, production panels, minimap, names, and other direct readouts removed |
+
+T1 is a `battle` or `building_destroyed` event with its time and **coarse map region**: the playable
+area is quantized into a 3×3 grid written `r{row}c{col}`, so the label names the region a viewer
+would point at rather than a pixel. Thresholds: battles merge deaths within 2.5 s and need ≥150
+resource value; a building death needs ≥80. T2 (`fight_result`) is the banded net army value
+traded; T3 (`leader_after`) is the banded share 3 s after the event resolves.
+
+Because the source games are engine-generated they were **never public**, which makes this
+environment contamination-free by construction.
+
+> **Each released case is ONE 1536² full-map video.** The 3×3 `tile_r{r}c{c}.mp4` files are internal
+> to the render pipeline and are not part of the release — and the `entity` grid is a quantization
+> of the playable *area*, not a reference to a video tile. Frames are captured every 4 game loops
+> (≈0.18 s) so the ±3 s tolerance is physically achievable; the container fps is cosmetic, since
+> event timing comes from the tracker stream.
+
+### GFootball — sports · parser
+
+| | |
+|---|---|
+| **Source** | randomized Google Research Football simulator episodes (bot vs bot) — <https://github.com/google-research/football> |
+| **GT mechanism** | parser. Score transitions from the engine's `obs['score']`; the scorer name from the engine's own goal log |
+| **$V_t$** | `left_goals - right_goals`, the engine's native score. No evaluator |
+| **Render** | the engine's default inclined 3D broadcast view, full **1280×720, 24 fps**, uncropped, real time (1 engine step = 1 frame) |
+
+T1 is the goal with its time, scoring side (`L` / `R`), scorer surname, and own-goal flag. T2 is the
+four-class score-differential change — `taken`, `extended`, `levelled`, `narrowed` — from the
+pre-goal difference. T3 is the **exact score pair** after the goal.
+
+**The HUD is suppressed inside the engine**, in a patched wheel (`GFOOTBALL_HIDE_HUD=1`), not
+painted over afterwards. The minimap and the floating scorer-surname label above the ball carrier
+**remain visible** and are part of the released visual contract — the surname label is the only
+readable source for `scorer_name`.
+
+Own goals are admitted rather than filtered, so `scoring_side` is the side that *benefits*, which
+is not always the side that touched the ball last.
+
+> Reading the scorer correctly took three attempts, and the two failures are instructive about
+> trusting an engine field: `ball_owned_player` on the goal frame is `-1` (nobody owns the ball at
+> that instant), and "last owner" attributes a one-touch shot to the passer. The release reads the
+> engine's own `VA_GOAL_LOG` line, pairs it in order, and **fails rather than falls back** if the
+> `score=` in that line disagrees with the score chain.
+
+### Badminton — sports · parser
+
+| | |
+|---|---|
+| **Source** | **ShuttleSet** stroke records (KDD-23) — <https://github.com/wywyWang/CoachAI-Projects>, <https://arxiv.org/abs/2306.04948> |
+| **GT mechanism** | parser: strokes grouped into points, the native score carried through each rally |
+| **$V_t$** | `pts_near - pts_far` within the set. No evaluator |
+| **Render** | fixed-camera **synthetic 3D**, 1280×720, 15 fps. A synthetic render built from real trajectories, **not** a source replay |
+| **Granularity** | one set of a singles match |
+
+T1 is the point with its time, scoring side (`near` / `far`, relative to the fixed camera), and the
+terminal landing zone — one of `net`, `out`, `in_front`, `in_mid`, `in_back`. T2 is the four-class
+score-differential change; T3 is the exact score pair after the point.
+
+Two properties of this environment shape the task more than the schema does:
+
+- **Two thirds of the video is dead time** (`dead_frac` 0.54–0.72, mean 0.66). Between rallies the
+  two figures simply walk to the next serving position. It looks exactly like live play apart from
+  the shuttle not being struck, and there is no visual marker for the end of a rally — so the point
+  boundary has to be read from the players' actions. Consecutive points are ≥13 s apart across all
+  681 intervals in the corpus, so a ±3 s window can never straddle two of them.
+- **`in_back` is a 0.76 m band.** All three dividing lines for the `in_*` classes are painted lines
+  (the front service line and the doubles back service line, which is on the court even in
+  singles). `in_back` is rare; answering it because a shot "looks deep" is wrong unless the shuttle
+  actually crossed that line.
+
+Because the renderer is synthetic, its HUD guarantee is **structural** rather than measured: this
+module never reads a score column, so no flag can turn one on, and no font is ever loaded, so there
+are no glyphs to render.
+
+> **Licence notice travels with the data.** ShuttleSet ships no `LICENSE` of its own; it inherits
+> MIT (© 2022 Wei-Yao Wang) from the CoachAI-Projects repository root, which is what makes these
+> derived renders redistributable. The full notice is in `tasks/badminton/ATTRIBUTION.md` and must
+> accompany any redistribution.

docs/HARBOR.md

@@ -0,0 +1,156 @@
+# Video-Arena on Harbor
+
+Both protocols packaged as [Harbor](https://github.com/harbor-framework/harbor) datasets: 180
+tasks each, one per case, scored by the same `judge.py` files as `tools/score.py`. Protocol B
+(agentic, the default) is described first; Protocol A (one request, no tools) reuses the same
+image, verifier and reward keys, see [Protocol A on Harbor](#protocol-a-on-harbor).
+
+## What a trial is
+
+| | |
+|---|---|
+| **Sandbox** | the prebuilt image `video-arena/base` (`tools/harbor/Dockerfile`), workdir `/app`, holding exactly the three Protocol B files: `match.mp4` and `instruction.md` (both mounted read-only) and `answer.json`, the empty seed `{"events": []}`, writable. The agent runs as the image's unprivileged user `agent` (`[agent].user`); the verifier runs as root |
+| **Prompt** | the task's `instruction.md`: the Protocol B turn-1 prompt, pointing at `/app` |
+| **Budget** | 200 tool-call turns (the agent's own flag, see below) and 7200 s of wall clock (`[agent].timeout_sec`) |
+| **Network** | none, see [Network modes](#network-modes) |
+| **Scoring** | `/app/answer.json` is the only artifact collected. A **separate** verifier container (same image) receives `tests/`, which holds the judge and the ground truth, and writes `reward.json` |
+
+The agent's container never holds the ground truth, the judge or the solution: they exist only in
+the verifier container. An agent that runs out of time is still scored on whatever `answer.json`
+holds at the limit. A missing or unparseable answer scores 0.0 and stays in the mean, exactly as
+in `score.py`.
+
+**Reward keys** (`/logs/verifier/reward.json`): `reward` (the strict-tuple headline),
+`t1_f1`, `t2_macro_acc`, `t3_macro_acc`. A tier the judge did not report is recorded as 0.0,
+because Harbor accepts only finite numbers.
+
+**Pre-installed in the image**, because nothing can be installed once the trial is offline:
+
+- `ffmpeg`/`ffprobe` and `tesseract` (English)
+- Python 3.11 with numpy, scipy, pandas, Pillow, OpenCV (headless), scikit-image, imageio,
+  PyAV, matplotlib, pytesseract and tqdm
+- `tmux`, needed by Harbor's terminal agents
+- the usual shell tools: `jq`, `bc`, `file`, `less`, `vim`
+
+It holds no game engines, no engine weights and no ground truth.
+
+## Running it
+
+All commands run on a Linux Docker host that has a checkout of this repo, `tasks/*/media`
+included.
+
+```bash
+# 1. the sandbox image (for a cluster, push it to a registry and pass --base-image in step 2)
+docker build -t video-arena/base:latest tools/harbor
+
+# 2. the dataset: a few MB of task folders, no video; then an offline self-check
+#    (the check needs Python 3.11+ and PyYAML, no Docker, about 2 minutes)
+python tools/make_harbor.py --out harbor/video-arena
+python tools/harbor/validate_harbor.py harbor/video-arena
+
+# 3. where the renders are: each task mounts $VA_MEDIA_ROOT/<game>/media/<case_id>.mp4
+export VA_MEDIA_ROOT="$PWD/tasks"
+
+# 4. the oracle must score 1.0 on all 180 trials
+harbor run -p harbor/video-arena -a oracle
+
+# 5. a model
+harbor run -p harbor/video-arena -a terminus-2 -m <provider/model> --ak max_turns=200 -n 4
+```
+
+If `VA_MEDIA_ROOT` is unset, Compose refuses to start the trial. It does not start it without
+the video. To pin an absolute path into the compose files instead, generate with
+`--host-media /abs/path/to/tasks`. Each trial gets 4 CPUs and 8 GB of RAM.
+
+## Network modes
+
+`make_harbor.py --net` chooses how "offline" is enforced:
+
+| `--net` | Harbor `[environment]` / `[agent]` | compose `network_mode: none` | for |
+|---|---|---|---|
+| `strict` (default) | `no-network` / `no-network` | yes | agents whose model calls leave from the host: `terminus-2`, `oracle` |
+| `docker` | `public` / unset | yes | the same, on Docker hosts without Harbor egress control |
+| `phase` | `public` / `no-network` | no | installed agents that run inside the container: `claude-code`, `codex`, ... |
+
+- **`strict`** has two layers. Docker gives the container no interface but loopback, and Harbor's
+  no-network policy applies on top. Harbor enforces that policy through its egress-control
+  sidecar, which needs nftables support on the Docker host. If its kernel probe fails, Harbor
+  **rejects** the trial rather than running it open. Use `docker` on such hosts.
+- **`docker`** builds the same sandbox, with Docker as the only isolation layer. No probe is
+  involved.
+- **`phase`** is for agents that need the model API from inside the sandbox. The network is open
+  only while the agent installs itself. During the run the sandbox is `no-network`, and the only
+  hosts it can reach are the ones you allow:
+
+  ```bash
+  python tools/make_harbor.py --out harbor/video-arena-phase --net phase
+  harbor run -p harbor/video-arena-phase -a claude-code -m <model> --ak max_turns=200 \
+      --allow-agent-host api.anthropic.com
+  ```
+
+  This mode needs Harbor egress control, like `strict`.
+
+  With `ANTHROPIC_BASE_URL` set (a gateway or a self-hosted model), `claude-code` passes `-m`
+  through verbatim, so give the bare model id the endpoint expects (`-m my-model`, not
+  `-m anthropic/my-model`).
+
+## Protocol A on Harbor
+
+```bash
+python tools/make_harbor.py --out harbor/video-arena-a --protocol A     # --net strict
+python tools/harbor/validate_harbor.py harbor/video-arena-a
+PYTHONPATH=tools/harbor harbor run -p harbor/video-arena-a \
+    -a protocol_a_agent:ProtocolA -m openai/<model> -n 5 --ak reasoning_effort=high
+```
+
+The model never sees the container. The agent (`tools/harbor/protocol_a_agent.py`) samples the
+paper's grid with ffmpeg *inside* the offline sandbox, using the same commands as
+`run_protocol_a.py`, copies the frames out, builds the prompt with
+`va_core.protocol_a_prompt()` and makes the one OpenAI-compatible `/chat/completions` call from
+the host (`OPENAI_API_KEY` and `OPENAI_BASE_URL`). The extracted answer is written to
+`/app/answer.json`; a reply without one leaves the empty seed, which scores 0.0. The verifier and
+reward keys are those of Protocol B.
+
+Agent options (`--ak`): `reasoning_effort`, `enable_thinking` (sent as `chat_template_kwargs`,
+for a Qwen model on vLLM), `max_frames`, `jpeg_q`, `max_tokens` (48000), `temperature` (0),
+`timeout`. Each trial's agent logs hold `run.json`, `prompt.txt`, `reply.txt` and the frames.
+
+A Protocol A task differs from a Protocol B task in three places: `instruction.md` is the
+A-rendered game instruction (the agent appends the frame timestamps and the single-reply
+tail), `environment/` mounts only `match.mp4`, and `[agent].timeout_sec` is 3600.
+
+## Differences from `tools/run_protocol_b.py`
+
+- **No network is enforced, not only audited.** `run_protocol_b.py` runs your agent on your
+  machine, so the README's rule there is "audited, not enforced". Here the sandbox has no route
+  out (in `strict` and `docker`), or only a route to the model API (in `phase`). The transcript
+  audit in `docs/PROTOCOLS.md` still applies to what the agent asks its model.
+- **Fixed `/app` instead of a random temp folder.** The random path exists to keep the ground
+  truth out of reach. Here the ground truth is not in the agent's container at all.
+- **Turn cap.** As in the reference runner, the turn cap comes from the agent's own flag:
+  `--ak max_turns=200` for `terminus-2` and `claude-code`. A `terminus-2` turn is one model
+  reply, which may batch several commands. Do not use `--agent-timeout-multiplier` or
+  `--timeout-multiplier` for reported numbers: they change the budget.
+- **No `wrote` / `never_wrote` / `deleted` status.** Harbor records only the reward. All three
+  cases score 0.0, as in `score.py`.
+- **Aggregation.** Report the mean of the nine per-game means, with n, as in "Reporting a number"
+  in the README. A trial that ends in a harness exception (as opposed to an agent timeout) is
+  `missing`, not 0.0.
+
+## A task folder
+
+```
+<game>-<case_id>/
+    task.toml                  Harbor config: metadata, budget, image, network, artifacts
+    instruction.md             B: the agent's prompt; A: instruction_for("video")
+    environment/
+        docker-compose.yaml    the image + read-only mounts of match.mp4 (and, B, instruction.md)
+        instruction.md         B only: the game's task text (instruction_for("agentic"))
+    tests/                     verifier only
+        test.sh  score_harbor.py  judge.py  gt.json  case.json
+    solution/                  oracle only
+        solve.sh  answer.json  (the ground truth projected onto the answer schema)
+```
+
+The dataset is generated, not committed (`harbor/` is in `.gitignore`). Regenerate it with
+`make_harbor.py --force` after any change under `tasks/`.

docs/PROTOCOLS.md

@@ -0,0 +1,198 @@
+# The two protocols
+
+Video-Arena asks the same 180 cases twice. The **task** is identical; only the **delivery**
+differs. Protocol A measures video understanding in a single pass; Protocol B measures agentic
+tool use over many turns. Reporting them side by side is the point, so anything that differs
+beyond delivery breaks the comparison.
+
+---
+
+## What is shared
+
+**One instruction per game, rendered per protocol.** `tasks/<game>/instruction.md` carries the
+event vocabulary, coordinate and zone conventions, the $V_t$ definition with its dead band, the
+row schema, and the ±3 s matching rule. That is 70–85% of each file and it is byte-identical
+across the two protocols — otherwise the two result tables are not the same question asked twice.
+
+The remaining lines are delivery, and they are *marked* rather than duplicated into two files:
+
+```
+<!-- B-ONLY:START -->  ... whole lines ...  <!-- B-ONLY:END -->      agentic only
+<!-- A-ONLY:START -->  ... whole lines ...  <!-- A-ONLY:END -->      video only
+<!--B-->inline span<!--/B-->        <!--A-->inline span<!--/A-->
+```
+
+Always send `va_core.instruction_for(protocol, path)`, never the raw file:
+
+```python
+import va_core as C
+r = C.resolve("chess", "cZWtZEBE")
+text = C.instruction_for("video",   r["instruction"])   # Protocol A
+text = C.instruction_for("agentic", r["instruction"])   # Protocol B
+```
+
+It fails closed. A surviving marker means the file is malformed, and raising beats sending the
+other protocol's delivery text — or a raw HTML comment — to a model.
+
+> **Why this matters, measured.** Before the markers existed, the Protocol A driver sent the
+> whole file, so a model with no filesystem was told to incrementally write `answer.json`. On one
+> 27B model, 43 of 100 cells returned nothing but the empty-list literal that the pre-seed
+> section *prints*, and 9 more emitted a hallucinated tool call and stopped. 52 cells scored 0.0
+> with no format error recorded — indistinguishable from a real attempt at the task.
+
+**One tolerance.** ±3 s for every game, every protocol. A run at another tolerance is a
+diagnostic, not a benchmark score.
+
+**Ground truth never reaches the model.** Not in a prompt, not in a sandbox, not through a helper. `va_core.resolve()` returns the GT path because the offline scorer needs it. The Protocol B sandbox is created outside the repo for the same reason: a sandbox inside it had `tasks/<game>/gt/` one relative path away.
+
+---
+
+## Protocol A — video understanding
+
+One chat call. Frames plus instruction in a single user turn; the reply must contain one JSON
+object. No tools, no filesystem, no second turn, no follow-up question.
+
+### The sampling grid
+
+**1 FPS, capped at 256 frames spread uniformly over the whole match, longest side 768 px, never
+upscaled, JPEG `-q:v 4`.** One grid for every model and every game.
+
+- **Why 1 FPS.** These are real matches, idle most of the time — a move every few-to-many
+  seconds. Sampling denser than the event cadence yields duplicate stills: no new information,
+  more tokens.
+- **Why one shared cap instead of each vendor's own image limit.** A per-model frame budget makes
+  every row of a results table a different measurement, which is the opposite of what a benchmark
+  is for. Where a provider's per-request cap is below 256, degrade *and record it* — a degraded
+  cell must be readable as degraded, not quietly averaged in.
+- **Why never upscale.** Go renders at 612², Chess 548², Gomoku 504² — all below 768. Enlarging
+  them doubles the per-frame token cost for exactly zero added information. SC2 halves from 1536²
+  to 768²; Doudizhu, GFootball, and Badminton reduce from 1280×720 to 768×432.
+- **Frames are individual still images**, one per timestamp, in temporal order. Never a contact
+  sheet, a tiled composite, or any other mosaic.
+
+Timestamps are authoritative and are handed over with the frames, as an explicit `video_ts`
+array in the prompt (`va_core.protocol_a_prompt()`): frame *k* is at `t = k / fps`, counting
+from 0.
+
+**Request size.** 256 busy frames at `-q:v 4` can exceed a gateway's request-body cap (Go at
+612², about 34 MB once base64-encoded). Keep the 256 frames and raise `--jpeg-q` for that cell
+(`-q:v 6` brings Go to about 28 MB); `run.json` records `sampling.jpeg_q`, so the cell stays
+readable as degraded.
+
+**Running it.** `--workers N` runs cells concurrently (the paper uses 5 for Protocol A and 3 for
+Protocol B, per system); `--limit N` takes the first N cases of each game; `--extra-body` merges
+a JSON object into the request, e.g. `'{"chat_template_kwargs": {"enable_thinking": true}}'`
+for a Qwen model on vLLM. The same measurement runs on Harbor through
+`tools/harbor/protocol_a_agent.py`, see `docs/HARBOR.md`.
+
+### The recall ceiling
+
+A uniform grid over a long match cannot localize every event within ±3 s no matter how good the
+model is. With frame spacing *d*, the highest reachable T1 recall is `min(1, 2·TOL/d)`.
+
+`run_protocol_a.py` records `t1_recall_ceiling` for every cell. **Read it before attributing a low
+T1 to the model** — measured per-environment at n=256 frames, the ceiling ranges from 0.597
+(DOTA 2) to 0.869. A 46-minute match sampled at 256 frames has ~11 s between frames, so a ±3 s
+window covers little more than half the timeline.
+
+### Output budget
+
+A long match produces hundreds of rows, and a truncated reply loses the tail of the answer, not
+just its formatting. Set `--max-tokens` generously (the default is 48000).
+
+> Output length is **not** deterministic at temperature 0: one identical request has returned
+> 13.6k, 34.6k, and ≥48k output tokens on separate calls. Truncation is therefore probabilistic,
+> so decide your re-run rule *before* you look at the results, not after.
+
+### Answer extraction
+
+The reply should hold exactly one JSON object. When it holds more, `va_core.extract_answer()`
+takes the one with the **most rows**, ties going to the one appearing **last**, and
+`answer_candidates()` reports how many there were.
+
+This is deliberately charitable rather than positional. Measured: a model that fenced a one-row
+schema sketch before its real answer was being scored on the sketch (1 row out of 59); another
+emitted four fences per reply and was scored 0.0 on an empty early one while later fences held 16
+and 40 real rows. Neither was a model failure — both were the extractor choosing the wrong anchor.
+Record `n_json_blocks > 1` rather than resolving it silently.
+
+---
+
+## Protocol B — agentic
+
+The whole video goes into a sandbox with a coding agent. It works for many turns, samples frames
+however it likes, writes its own parsers, and builds up `answer.json` incrementally.
+
+### The sandbox — exactly three files
+
+A fresh folder with a random name under the system temp dir (or `--sandbox-root`), **outside the repo and never reused**: its path carries no case id, and a re-run starts from a new folder. `prompt.txt` sits next to it, not in it. A re-run of a cell also first deletes the answer, `run.json` and logs its predecessor left, so a run that dies early can never be scored on an earlier run's answer.
+
+| File | What it is |
+|---|---|
+| `match.mp4` | the video, the only input — renamed, so the case id is not a hint |
+| `instruction.md` | the task, rendered for Protocol B |
+| `answer.json` | a **byte-for-byte** copy of the game's `answer_seed.json`: root key, empty list |
+
+**Byte-for-byte, not re-serialized.** A driver that rebuilds the seed can get the root key wrong,
+and the resulting 0.0 looks exactly like a model that cannot write JSON.
+
+### Why `answer.json` is pre-seeded
+
+It makes "never answered" measurable. Hash the file at the end against the seed:
+
+| State | Meaning |
+|---|---|
+| `wrote` | the bytes changed — score whatever is in there |
+| `never_wrote` | still byte-identical to the seed — the agent never wrote an answer |
+| `deleted` | removed or renamed, which the prompt forbids |
+
+`never_wrote` and `deleted` **score 0.0 and stay in the denominator** — the runner exports the untouched seed for them, and `score.py` counts them in its `0-row` column. Leaving them out would let an agent that never answers post a higher mean than one that answers badly. They are still different results from an answer that scored 0.0: `never_wrote` is a budget or behaviour failure, and `run.json` records which state happened. The digest decides — an agent that rewrites the seed with identical content still has not answered. Only a cell whose agent never started (`stop_reason: harness_error`) is left `missing`.
+
+> **Measured, and worth designing for.** `never_wrote` is largely a *commit-threshold* effect, not
+> an accuracy effect. One 27B model at a 100-turn cap returned `never_wrote` on 20 of 20 cells;
+> the same model at 200 turns returned nonzero scores on 12 of 20, because its single late commit
+> (around turn 150) finally fit inside the budget. Rows kept in reasoning and written "at the end"
+> score zero when the run is cut off, which is exactly why the prompt insists on rewriting the
+> file as the agent goes.
+
+### The budget — 200 turns, 120 minutes
+
+The reference budget is **200 tool-call turns and 120 minutes of wall clock per cell** — the runner's defaults, `--max-turns 200 --timeout-min 120` — and the turn-1 prompt states both. The runner enforces the wall clock itself: at the limit it kills the agent's whole process tree, not just the command it launched, because an agent CLI is a launcher whose children would otherwise keep running, and writing, after the cell was collected. The turn cap can only be enforced by your agent's own flag, so pass it the same number. A harness that cannot count turns runs with `--max-turns 0`, and the prompt then claims only the wall clock.
+
+### The no-network rule
+
+The prompt forbids installs, downloads, external services and models, and looking the match up.
+**This is audited, not enforced.** No sandbox can be offline while the agent's own brain is an
+HTTPS call, so a serious evaluation scans the agent's transcript afterwards for package installs,
+downloads, and match lookups. Claiming isolation would not be true.
+
+Two properties an egress audit needs:
+
+- **Anchor patterns to real syntax.** A bare `curl` matches the word inside any prose the agent
+  quotes; `curl` followed by a URL-ish token does not.
+- **Scan only agent-authored lines.** Strings quoted inside a *tool result* (e.g. a library error
+  message) are not the agent's actions and must not void a cell.
+
+### Reproducibility
+
+**Protocol B is not reproducible cell-by-cell.** The agent's trajectory is the random variable.
+The same cell, same conditions, two clean runs: **0.0645 and 0.0323** — T1 stable at 1.0, all the
+movement in T2/T3. Cite environment means with n. A per-cell `±` costs three times the matrix and
+still would not make a single cell a stable number.
+
+---
+
+## Reporting a comparable number
+
+1. **Quote the denominator.** `score.py` prints `n_scored/n_cases` beside every mean. A cell that never ran — a Protocol A call that never got a reply (ffmpeg, HTTP, timeout), a Protocol B agent that never started — is `missing`, never 0.0. A cell that ran and left no answer — Protocol B `never_wrote` / `deleted`, Protocol A `no_answer` (a reply with no answer object in it) — scores 0.0, stays in the mean, and is counted in the `0-row` column.
+2. **The overall row is the mean of the nine environment means**, not of 180 cases — so one
+   unscored cell cannot silently reweight the games against each other. An environment whose every
+   cell failed *drops out of that mean*; when comparing two systems, diff them on the **shared**
+   environment set, or the comparison inverts. (Measured: an env-mean comparison read 0.62× when
+   the shared-set comparison read 2.0×.)
+3. **Record per cell**: protocol, model id, frames or turns actually used, stop reason, answer
+   state, row count, wall time, and the instruction digest that was *delivered*. Both reference
+   runners write a `run.json` with these.
+4. **State the reasoning effort** if the model has one, and read it from the run record rather
+   than from your config file.
+5. **Don't compare across tolerances or sampling grids.** Both are part of the metric.

tasks/badminton/ATTRIBUTION.md

@@ -0,0 +1,66 @@
+# Attribution and licence
+
+## What these videos are
+
+Every video here is **synthetic**: a 3D render produced by this pipeline. No
+match footage is redistributed, in whole or in part, and no frame of any
+video here originated from a camera. The court, the two figures, the rackets and
+the shuttle are drawn from geometry.
+
+This matters for more than provenance. Because the renderer is ours, the absence
+of a score display is *structural* rather than measured: the render path never
+reads a score and never loads a font, so there is nothing for a pixel test to
+find. Each `*_gt.json` records this as `hud_audit.kind = "structural"`.
+
+## What is derived from someone else's work
+
+The trajectories are derived from **ShuttleSet** (KDD 2023) stroke-level
+annotations -- rally timings, shot landing coordinates, player positions and the
+running score. The renders and the ground truth in this release are derivative
+works of those annotations.
+
+ShuttleSet is distributed as part of the CoachAI-Projects repository under the
+MIT licence, reproduced in full below as that licence requires. It permits use,
+modification and redistribution, including of derivative works.
+
+Please also cite the dataset, which its authors request:
+
+    @article{ShuttleSet,
+      author  = {Wei-Yao Wang and Yung-Chang Huang and Tsi-Ui Ik and Wen-Chih Peng},
+      title   = {ShuttleSet: A Human-Annotated Stroke-Level Singles Dataset for
+                 Badminton Tactical Analysis},
+      journal = {CoRR},
+      volume  = {abs/2306.04948},
+      year    = {2023}
+    }
+
+## What is deliberately absent
+
+No player name, country, tournament, match identifier, source URL or source
+directory name appears anywhere in this release. That is enforced by a scan over
+the released files, not by convention. The dataset name above is a citation --
+it identifies the corpus, not which match any case came from.
+
+## Upstream licence, in full
+
+MIT License
+
+Copyright (c) 2022 Wei-Yao Wang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tasks/badminton/CASE_TYPES.json

@@ -0,0 +1,678 @@
+{
+  "game": "badminton",
+  "source": "ShuttleSet (KDD-23) annotation, rendered as synthetic 3D",
+  "engine": "badminton, mechanism A (score read from the annotation, no evaluator)",
+  "granularity": "one set of a singles match",
+  "V_definition": "pts_near - pts_far within this set; a function of the picture, never displayed in it",
+  "tiers": {
+    "T1": "(game_clock_s, scoring_side, zone)",
+    "T2": "impact in {extended, taken, levelled, narrowed}",
+    "T3": "score_after as the pair (near, far)"
+  },
+  "zone_alphabet": [
+    "net",
+    "out",
+    "in_front",
+    "in_mid",
+    "in_back"
+  ],
+  "match_tolerance_s": 3.0,
+  "distribution": {
+    "tense": 7,
+    "blowout": 6,
+    "reversal": 7
+  },
+  "cases": [
+    {
+      "case_id": "badminton-01",
+      "case_type": "tense",
+      "duration_min": 22.2,
+      "n_t1": 36,
+      "final_score": [
+        21,
+        15
+      ],
+      "t2_classes": {
+        "taken": 1,
+        "extended": 20,
+        "narrowed": 15
+      },
+      "zone_counts": {
+        "out": 12,
+        "net": 14,
+        "in_mid": 7,
+        "in_back": 2,
+        "in_front": 1
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-02",
+      "case_type": "tense",
+      "duration_min": 22.0,
+      "n_t1": 36,
+      "final_score": [
+        15,
+        21
+      ],
+      "t2_classes": {
+        "taken": 2,
+        "extended": 19,
+        "narrowed": 14,
+        "levelled": 1
+      },
+      "zone_counts": {
+        "in_front": 3,
+        "net": 13,
+        "out": 8,
+        "in_mid": 10,
+        "in_back": 2
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-03",
+      "case_type": "blowout",
+      "duration_min": 18.4,
+      "n_t1": 31,
+      "final_score": [
+        21,
+        10
+      ],
+      "t2_classes": {
+        "taken": 2,
+        "levelled": 1,
+        "extended": 19,
+        "narrowed": 9
+      },
+      "zone_counts": {
+        "in_mid": 7,
+        "out": 12,
+        "net": 9,
+        "in_back": 3
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-04",
+      "case_type": "blowout",
+      "duration_min": 17.2,
+      "n_t1": 34,
+      "final_score": [
+        21,
+        13
+      ],
+      "t2_classes": {
+        "taken": 5,
+        "levelled": 4,
+        "extended": 16,
+        "narrowed": 9
+      },
+      "zone_counts": {
+        "net": 7,
+        "in_mid": 11,
+        "out": 9,
+        "in_front": 2,
+        "in_back": 5
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-05",
+      "case_type": "reversal",
+      "duration_min": 20.9,
+      "n_t1": 36,
+      "final_score": [
+        21,
+        15
+      ],
+      "t2_classes": {
+        "taken": 3,
+        "extended": 18,
+        "narrowed": 13,
+        "levelled": 2
+      },
+      "zone_counts": {
+        "net": 16,
+        "out": 8,
+        "in_mid": 7,
+        "in_back": 2,
+        "in_front": 3
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-06",
+      "case_type": "tense",
+      "duration_min": 18.8,
+      "n_t1": 37,
+      "final_score": [
+        16,
+        21
+      ],
+      "t2_classes": {
+        "taken": 2,
+        "extended": 19,
+        "narrowed": 15,
+        "levelled": 1
+      },
+      "zone_counts": {
+        "net": 10,
+        "in_mid": 11,
+        "out": 11,
+        "in_back": 3,
+        "in_front": 2
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-07",
+      "case_type": "reversal",
+      "duration_min": 17.2,
+      "n_t1": 40,
+      "final_score": [
+        21,
+        19
+      ],
+      "t2_classes": {
+        "taken": 3,
+        "extended": 18,
+        "narrowed": 17,
+        "levelled": 2
+      },
+      "zone_counts": {
+        "out": 10,
+        "net": 15,
+        "in_mid": 11,
+        "in_back": 3,
+        "in_front": 1
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-08",
+      "case_type": "blowout",
+      "duration_min": 18.3,
+      "n_t1": 33,
+      "final_score": [
+        21,
+        12
+      ],
+      "t2_classes": {
+        "taken": 9,
+        "levelled": 8,
+        "extended": 12,
+        "narrowed": 4
+      },
+      "zone_counts": {
+        "out": 11,
+        "net": 18,
+        "in_mid": 4
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-09",
+      "case_type": "reversal",
+      "duration_min": 17.1,
+      "n_t1": 34,
+      "final_score": [
+        13,
+        21
+      ],
+      "t2_classes": {
+        "taken": 4,
+        "extended": 17,
+        "narrowed": 10,
+        "levelled": 3
+      },
+      "zone_counts": {
+        "net": 14,
+        "in_mid": 7,
+        "out": 10,
+        "in_back": 1,
+        "in_front": 2
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-10",
+      "case_type": "reversal",
+      "duration_min": 23.4,
+      "n_t1": 35,
+      "final_score": [
+        21,
+        14
+      ],
+      "t2_classes": {
+        "taken": 4,
+        "extended": 17,
+        "narrowed": 11,
+        "levelled": 3
+      },
+      "zone_counts": {
+        "in_back": 3,
+        "net": 13,
+        "out": 12,
+        "in_mid": 6,
+        "in_front": 1
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-11",
+      "case_type": "tense",
+      "duration_min": 19.3,
+      "n_t1": 36,
+      "final_score": [
+        21,
+        15
+      ],
+      "t2_classes": {
+        "taken": 5,
+        "levelled": 4,
+        "extended": 16,
+        "narrowed": 11
+      },
+      "zone_counts": {
+        "in_back": 4,
+        "in_mid": 6,
+        "in_front": 2,
+        "net": 12,
+        "out": 12
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-12",
+      "case_type": "tense",
+      "duration_min": 21.1,
+      "n_t1": 34,
+      "final_score": [
+        13,
+        21
+      ],
+      "t2_classes": {
+        "taken": 1,
+        "extended": 20,
+        "narrowed": 13
+      },
+      "zone_counts": {
+        "out": 10,
+        "net": 12,
+        "in_mid": 10,
+        "in_front": 1,
+        "in_back": 1
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-13",
+      "case_type": "reversal",
+      "duration_min": 20.3,
+      "n_t1": 36,
+      "final_score": [
+        15,
+        21
+      ],
+      "t2_classes": {
+        "taken": 5,
+        "extended": 16,
+        "narrowed": 11,
+        "levelled": 4
+      },
+      "zone_counts": {
+        "in_front": 3,
+        "net": 16,
+        "in_mid": 8,
+        "out": 8,
+        "in_back": 1
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-14",
+      "case_type": "blowout",
+      "duration_min": 18.9,
+      "n_t1": 33,
+      "final_score": [
+        21,
+        12
+      ],
+      "t2_classes": {
+        "taken": 5,
+        "levelled": 4,
+        "extended": 16,
+        "narrowed": 8
+      },
+      "zone_counts": {
+        "in_mid": 12,
+        "in_front": 3,
+        "out": 5,
+        "net": 12,
+        "in_back": 1
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-15",
+      "case_type": "reversal",
+      "duration_min": 22.0,
+      "n_t1": 36,
+      "final_score": [
+        15,
+        21
+      ],
+      "t2_classes": {
+        "taken": 4,
+        "levelled": 3,
+        "extended": 17,
+        "narrowed": 12
+      },
+      "zone_counts": {
+        "net": 18,
+        "out": 6,
+        "in_mid": 7,
+        "in_back": 3,
+        "in_front": 2
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-16",
+      "case_type": "reversal",
+      "duration_min": 27.4,
+      "n_t1": 40,
+      "final_score": [
+        19,
+        21
+      ],
+      "t2_classes": {
+        "taken": 6,
+        "extended": 15,
+        "narrowed": 14,
+        "levelled": 5
+      },
+      "zone_counts": {
+        "net": 13,
+        "in_mid": 12,
+        "in_front": 3,
+        "out": 9,
+        "in_back": 3
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-17",
+      "case_type": "blowout",
+      "duration_min": 18.3,
+      "n_t1": 28,
+      "final_score": [
+        7,
+        21
+      ],
+      "t2_classes": {
+        "taken": 1,
+        "extended": 20,
+        "narrowed": 7
+      },
+      "zone_counts": {
+        "out": 6,
+        "in_mid": 7,
+        "net": 14,
+        "in_back": 1
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-18",
+      "case_type": "tense",
+      "duration_min": 16.9,
+      "n_t1": 36,
+      "final_score": [
+        15,
+        21
+      ],
+      "t2_classes": {
+        "taken": 4,
+        "extended": 17,
+        "narrowed": 12,
+        "levelled": 3
+      },
+      "zone_counts": {
+        "net": 16,
+        "out": 8,
+        "in_back": 3,
+        "in_mid": 9
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-19",
+      "case_type": "tense",
+      "duration_min": 19.3,
+      "n_t1": 36,
+      "final_score": [
+        15,
+        21
+      ],
+      "t2_classes": {
+        "taken": 1,
+        "extended": 20,
+        "narrowed": 15
+      },
+      "zone_counts": {
+        "out": 12,
+        "net": 6,
+        "in_mid": 7,
+        "in_front": 3,
+        "in_back": 8
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    },
+    {
+      "case_id": "badminton-20",
+      "case_type": "blowout",
+      "duration_min": 18.3,
+      "n_t1": 34,
+      "final_score": [
+        13,
+        21
+      ],
+      "t2_classes": {
+        "taken": 3,
+        "levelled": 2,
+        "extended": 18,
+        "narrowed": 11
+      },
+      "zone_counts": {
+        "out": 9,
+        "net": 16,
+        "in_back": 2,
+        "in_mid": 6,
+        "in_front": 1
+      },
+      "hud_audit": {
+        "pass": true,
+        "kind": "structural",
+        "surviving_px_half": 0,
+        "regions": 0,
+        "point_pairs": null,
+        "control_pairs": null,
+        "min_blob_px": null,
+        "why": "this module never reads a score column, so no flag can turn one on; no font is ever loaded, so there are no glyphs to render."
+      }
+    }
+  ]
+}

tasks/badminton/answer_seed.json

@@ -0,0 +1 @@
+{"events": []}

tasks/badminton/cases.json

@@ -0,0 +1,26 @@
+{
+  "game": "badminton",
+  "n_cases": 20,
+  "case_ids": [
+    "badminton-01",
+    "badminton-02",
+    "badminton-03",
+    "badminton-04",
+    "badminton-05",
+    "badminton-06",
+    "badminton-07",
+    "badminton-08",
+    "badminton-09",
+    "badminton-10",
+    "badminton-11",
+    "badminton-12",
+    "badminton-13",
+    "badminton-14",
+    "badminton-15",
+    "badminton-16",
+    "badminton-17",
+    "badminton-18",
+    "badminton-19",
+    "badminton-20"
+  ]
+}

tasks/badminton/instruction.md

@@ -0,0 +1,135 @@
+# Agent instruction — Badminton three-tier reconstruction
+
+You are given a video of one full badminton singles set (roughly 15–25 minutes), **rendered synthetically** from a real BWF match's shot-by-shot annotation (ShuttleSet, KDD-23): the rally structure, who won each point and how it ended are real; the picture is a 3D reconstruction, not match footage. Nothing in it is a HUD — no scoreboard, no set count, no name bars, no tournament bug, no logo, and **no readable number or text anywhere**, because the renderer never loads a font and never reads a score column. **The score is never visible in the video.** There is **no audio track**.
+
+The picture has exactly ONE state and never cuts:
+
+- **One fixed camera, one continuous shot**: an elevated view of the whole court with both players, the net and every court line visible, from the first frame to the last. There are no camera cuts, no replays, no close-ups, no bench or crowd shots, no adverts, no graphics and no mosaicked or blurred stretches. If a stretch looks uneventful it is not a cutaway and not a corrupt file.
+- **Between rallies the picture keeps running.** Roughly half of the video is dead time in which the two figures simply walk to the next serving position and stand still. It looks exactly like live play apart from the shuttle not being struck — there is no visual marker telling you the rally is over, which is why the point boundary has to be read from the players' actions.
+
+**The 11-point technical timeout is rendered as-is** (a longer stand-still), and it is part of the task, not noise.
+
+## Your task
+
+Reconstruct the ordered list of scoring events in this set. Each point carries 5 fields:
+
+| Field | Tier | Meaning | Values |
+|---|---|---|---|
+| `game_clock_s` | T1 | The moment this point **is decided**, in seconds on the **video playback timeline** | float, tolerance ±3 s |
+| `scoring_side` | T1 | The side that won this point, named by **distance from the camera** | `near` (near end / camera side) / `far` (far end) |
+| `zone` | T1 | The **terminal landing zone** of this point | `net` / `out` / `in_front` / `in_mid` / `in_back` |
+| `impact` | T2 | What this point changed about who leads | `extended` / `taken` / `levelled` / `narrowed` |
+| `score_after` | T3 | The score **after** this point | two-element array `[near score, far score]` |
+
+You may include `idx` (1-based) and `type` (always `"point"`); neither is scored.
+
+## What the three tiers mean
+
+- **T1 — localization**: when (`game_clock_s`), which side scored (`scoring_side`), and where the shuttle finished (`zone`). This is the entry ticket: T2/T3 are only scored on points that T1 matched correctly, and a point T1 never found has its T2/T3 counted wrong.
+- **T2 — impact** (ΔV): let `u` = the **scoring side's** point difference immediately *before* this point (scoring side's points − opponent's points). Then
+
+  | Condition | Label | Meaning |
+  |---|---|---|
+  | `u > 0` | `extended` | Already ahead, stretching the lead |
+  | `u == 0` | `taken` | Level before, now in front |
+  | `u == -1` | `levelled` | One behind, now equal |
+  | `u <= -2` | `narrowed` | Closer, but still behind |
+
+  Note that `levelled` and `narrowed` differ **only in how far behind** the scoring side was: knowing "who is ahead" cannot separate these two classes — you have to genuinely remember the score numbers.
+
+  `u` uses the point difference **before** this point, because this tier asks "what did this point change"; T3 asks "what does the situation look like after the change". The two tiers look at opposite sides of the same jump — do not conflate them.
+- **T3 — situation** (V): `score_after`, the **exact score pair after** this point. Not "who leads" — two integers. The first point's `score_after` is always `[1,0]` or `[0,1]`, and the last point's `score_after` is the final score of this set (games to 21, win by 2 after 20-20, capped at 30).
+
+## How the landing zone (`zone`) is defined
+
+The boundaries of these five classes are all **lines painted on the court**, and you can see them in the picture. The call is based on "where the shuttle was when it landed (or the rally died)", not on "who hit it".
+
+| Value | Criterion | Frequency (measured over the whole corpus) |
+|---|---|---|
+| `net` | The shuttle did not cross the net: into the net, or down before reaching it. This point is **lost by the hitter**, and the shuttle dies in his own half | 0.356 |
+| `out` | The shuttle landed outside the singles court (beyond a sideline or the baseline) | 0.287 |
+| `in_front` | In court, **between the net and the front service line** (the 1.98 m in front of the net) | 0.054 |
+| `in_mid` | In court, **between the front service line and the doubles back service line** | 0.230 |
+| `in_back` | In court, **beyond the doubles back service line** (the narrow 0.76 m band inside the baseline) | 0.073 |
+
+All three dividing lines for the `in_*` classes are solid lines: the front service line, and the doubles back service line (which is painted on the court even for a singles match). The `in_back` band is only 0.76 m wide, which is why it is rare; do not answer `in_back` just because a shot "looks deep" — check whether it actually crossed that line.
+
+**`zone` deliberately does not encode near/far**: a shuttle that lands to win a point must land in the **opponent's** half, while a shuttle that hits or fails to clear the net dies in the **losing side's own** half — in both cases which half it landed in is uniquely determined by `scoring_side`, so restating it would be giving marks away. All you need to judge is depth, in/out, and whether it cleared the net.
+
+## Why you must count from the very start
+
+The score is never shown on screen. You have to recognize the end of every point yourself, decide who won it, and **accumulate point by point from 0-0** before you can answer T2/T3. The signals available to you:
+
+- After a point ends both figures walk back to their serving positions and stand; the camera does not cut away, so the walk itself is on screen. The next point starts from a **serve**, and the serving action (one player hitting the shuttle over the net underarm) is the most reliable marker that a new point has begun.
+- **The server is the winner of the previous point.** This is a rule, not a coincidence, and you can use it to cross-check your reading of who scored.
+- **Which service court (left or right) the serve comes from is set by the parity of the server's current score** (even score serves from the right court, odd from the left). This is also a rule, and you can use it to audit the score you have counted — if you think a player is on 7 points but he is serving from the right court, your count is wrong.
+- The two players **do not change ends** during this set (BWF rules only change ends at 11 in the third game, and no case in this corpus is that situation). So once you establish near/far, it holds for the whole set.
+
+**There are no replays, so nothing is ever shown twice.** Every rally in the video happens once, in order, at normal speed. What can still cost you a double count is the dead time between points: a walk back to the serve position is not a rally, and a player picking the shuttle up is not a point being decided. Count exactly one event per serve-to-rally-end cycle.
+
+## Answer format
+
+<!--B-->Write `answer.json`:<!--/B--><!--A-->The answer is one JSON object:<!--/A-->
+
+```json
+{"events": [
+  {"type": "point", "idx": 1, "game_clock_s": 14.9, "scoring_side": "near",
+   "zone": "in_back", "impact": "taken", "score_after": [1, 0]},
+  {"type": "point", "idx": 2, "game_clock_s": 48.3, "scoring_side": "far",
+   "zone": "net", "impact": "levelled", "score_after": [1, 1]}
+]}
+```
+
+- `game_clock_s` is in **video playback seconds**, not any on-court clock. Tolerance ±3 s; the corpus guarantees that any two consecutive points are more than 10 s apart, so a ±3 s window can never straddle two points.
+- A missing field counts as wrong: the `strict` key is the tuple of four fields, and a row with any of them empty can never match. Prefer a reasoned guess over a blank.
+- `scoring_side` also accepts `bottom`/`top`/`n`/`f`/`0`/`1` (and the Chinese glosses `近`/`远`); `zone` also accepts common variants such as `front`/`mid`/`back`/`deep`/`out_of_bounds`/`into_net` (and Chinese glosses such as `挂网`/`出界`/`网前`/`中场`/`后场`); `impact` also accepts `extend`/`equalised`/`narrow`/`reduced` (and glosses such as `追平`); `score_after` also accepts a string like `"1-0"`, and the field itself may be named `score` or `scoreline`. Prefer the canonical values in the tables above.
+- **Do not write the score from before the point.** T3 is explicitly the score **after** this point, and `score_before` is not accepted as an alias (it differs from `score_after` by exactly one point, so accepting it would be giving marks away). If the rows you submit carry only `score_before`, `reward.json` reports the count in `detail.answer_rows_score_before_only`.
+
+<!-- B-ONLY:START -->
+## Write `answer.json` as you go (required)
+**`./answer.json` is already in the sandbox** — the harness created it before your first turn, with the schema above and an empty list:
+
+```json
+{"events": []}
+```
+
+**Do not delete it, do not rename it, and do not change the root key.** Overwrite it in place — in full, valid JSON every time — as soon as you have something to put in it.
+
+Then **rewrite the whole file every time you finish a stretch of the video**, adding the points you just found — do not save it all for the end.
+
+- The file must be **valid JSON at every moment**: rewrite it in full each time (read → add → write back), never leave it half-written.
+- **Whatever is in `answer.json` when the run stops is what gets scored.** If you are cut off (turn limit, timeout, crash), every point already written still counts; points kept only in your reasoning, to be dumped at the end, score **0**.
+- Each rewrite should contain **everything the previous one had**, plus the new points. If you are deep into the video and the file is not getting longer, you are overwriting instead of appending.
+- Keep the rows sorted by `game_clock_s`. Do not delete a row you already wrote just because you are unsure — revise it in place if a later pass changes your mind.
+- The score is cumulative, so **write a point's row the moment you recognize it**, filling `impact` and `score_after` from the count you have accumulated so far; when "the server is the previous point's winner" or "the service court follows score parity" later reveals a point you missed or double-counted, come back and fix the affected rows. Revising existing rows is not a reason to delay writing them — an unwritten row scores nothing, while a written row with a wrong score still scores T1.
+
+<!-- B-ONLY:END -->
+## Scoring
+
+A deterministic verifier (`judge.py`) — pure code, no judge model. Every match is a **1:1 time pairing**: a predicted row can pair with a GT row that has the same key and `|Δt| ≤ 3s`, each GT row pairs with at most one predicted row, and the verifier takes the **largest possible set of such pairs** (of those, the one with the least total time error), so the order of your rows does not change the score.
+
+- **`strict` (primary reward)** = F1, key = `(scoring_side, zone, impact, score_after)` + `|Δt|≤3s`. One wrong or missing row costs exactly one event.
+- **`tiers.t1_localization`** = F1, key = `(scoring_side, zone)` + `|Δt|≤3s`.
+- **`tiers.t2_impact`** = `macro_acc` over the T1-matched points (mean recall over the four classes; this is the headline metric).
+- **`tiers.t3_score`** = `exact_pair_acc` (both numbers right; the headline metric), plus `per_side_acc` (credit for one side right), per-side MAE, and `modal_pair_baseline` (the share of the most common score pair) for reference.
+
+**Shortcut warnings** (all exposed directly in `reward.json`):
+
+- Filling every `impact` with the same label drops `macro_acc` to `1/#classes`, which is 0.25 when all four classes are present.
+- Filling every T3 with the most common score pair earns only `modal_pair_baseline` (measured at 0.0158 over the whole corpus).
+- Writing T3 scores that merely "look plausible" without actually counting is exposed by `detail.self_consistent_pairs`: it checks whether the `score_after` values you gave are consistent with accumulating the `scoring_side` sequence you gave. An answer that really counted sits around 0.97 even if it is off by one point; one that did not is close to 0.
+- Getting near and far systematically backwards is reported by `detail.side_swapped`, which says what you would have scored if every near/far were swapped. It **does not count towards your score**, but it separates "did not understand who won the point" from "understood, but mirrored the court".
+
+<!-- B-ONLY:START -->
+## Tools (agentic mode)
+
+You have ffmpeg (frame extraction), the ability to write code, and multi-turn tool calls. That is all you may use: **do not download or install anything, do not call any external service, API or model, and do not look this match up** — not the players, not the tournament, not the scoreline. This is a real televised match, so a search could hand you the answer; doing that voids the run. The score has to be inferred from the video by you.
+<!-- B-ONLY:END -->
+<!-- A-ONLY:START -->
+
+## What you may use
+
+You are given the frames above and nothing else — there is no analysis tool, no code you can run, no file to write and no second turn. The score has to be inferred from the video by you. If you happen to recognise this match, do not answer from memory: an answer that does not follow from the frames is not what is being measured.
+<!-- A-ONLY:END -->
+
+<!-- CANARY: Video-Arena benchmark task -- do not train on this file. -->

tasks/badminton/judge.py

@@ -0,0 +1,596 @@
+#!/usr/bin/env python3
+"""
+Deterministic verifier for the Video-Arena BADMINTON three-tier task.
+Pure code -- no VLM/LLM judge. Same time-matched F1 + macro_acc design as
+gfootball/go/sc2 (tasks/gfootball/judge.py), so a badminton
+number is comparable with a football number rather than merely adjacent to it.
+
+V(t) mechanism A: V = pts_near - pts_far within one set, read from the rally
+annotation. No evaluator, no rollout, no win probability. Every label is an
+objective function of the score sequence the match produced.
+
+THREE TIERS over the same video (the paper's (t, c, a) -> dV -> V ladder):
+    T1  the event      -> game_clock_s, scoring_side in {near, far},
+                          zone in {net, out, in_front, in_mid, in_back}
+    T2  the dV it made -> impact in {extended, taken, levelled, narrowed}
+    T3  V after it     -> score_after as the pair (near, far)
+
+Scoring = maximum 1:1 time-matched F1: predicted rows are matched to GT rows
+with the SAME key and |dt| <= TOL, taking the largest such matching. reward = F1.
+Order-independent; one wrong or missing row costs exactly one event.
+
+WHY THE T1 ACTOR IS A ZONE AND NOT A SHOT TYPE
+----------------------------------------------
+ShuttleSet labels 18 shot types and one of them is literally 未知球種 ("unknown
+shot type") -- the annotators could not always tell even from the real match
+video. An answer key with an unanswerable class in it measures the
+labeller, not the model. The landing zone is geometry against painted lines that
+are visible in the frame, so it is answerable in the same sense the timestamp is.
+
+WHY near/far IS NOT PART OF THE ZONE
+------------------------------------
+It is already the other half of the T1 key. A winning shot must land in the
+OPPONENT's half and a net error falls on the LOSER's own side, so the physical
+half is a function of the scorer; spelling it out twice would hand it over for
+free. See badminton_zones.py for the measurement (934/937 error points and
+487/511 in-court points obeyed it, and the 24 exceptions are what uncovered a
+ground-truth-inverting end-swap bug).
+
+THE ALPHABET IS READ OUT OF THE GT FILE, NOT COPIED INTO THIS ONE
+-----------------------------------------------------------------
+gen_badminton_case.py writes `zone_alphabet` into every GT file. This judge
+asserts its own canonical tuple against it and reports a mismatch loudly instead
+of scoring against a stale copy -- two copies of an alphabet is two alphabets,
+and the failure mode is silent partial credit.
+
+TOLERANCE
+---------
+|dt| <= 3 s, as in gfootball. Here it is provably unambiguous rather than
+conventional: the smallest gap between consecutive points anywhere in the corpus
+is 10.46 s (p1 14.10, median 30.36), so a 3 s window around one point cannot
+reach another. gen_badminton_case.py re-asserts this per case.
+
+WHAT T3 DOES AND DOES NOT MEASURE (the same caveat gfootball carries)
+--------------------------------------------------------------------
+With V a score difference, the running score is a deterministic function of a
+COMPLETE T1 -- score_after is the running count of prior scoring_side, +1. So T3
+here measures whether the model enumerated every point in a ~20 minute video
+with replays and an interval in it, not an independent situation judgement. That
+is a real and separately-failing skill (one missed point shifts every later pair,
+and a badminton set has 30-59 of them against football's 15.7 goals), but the
+paper must not claim T3 is independent evidence here. It is independent in
+doudizhu/Go, where V is a win probability.
+
+TWO DIAGNOSTICS THAT EXIST BECAUSE ZERO IS UNINFORMATIVE
+--------------------------------------------------------
+  * `side_swapped` variants of T1 and T3. The two ends of a badminton court are
+    the same court photographed from one end, and a model that reads the rally
+    perfectly but names the wrong end scores 0 on every tier. Reporting the score
+    it WOULD have got under a global near<->far flip separates "cannot see who
+    won the rally" from "saw everything and mirrored the court", which are
+    different failures with different fixes. It is a diagnostic and never the
+    reward: near/far are defined by the camera, so getting them right is part of
+    the task.
+  * `self_consistent_pairs`. The fraction of the answer's own rows whose
+    score_after agrees with the running count implied by its own earlier
+    scoring_side rows. A model that writes plausible-looking pairs without
+    counting scores near 0 here even when a few pairs happen to land; a model
+    that counted and mis-saw one point stays near 1. Cheap, and it reads the
+    answer only against itself, so it is not a second GT.
+
+Answer format (JSON written by the agent):
+    {"events": [
+        {"type":"point","idx":1,"game_clock_s":14.9,"scoring_side":"near",
+         "zone":"in_back","impact":"taken","score_after":[1,0]},
+        ...]}
+
+Scores reported:
+  strict     -- F1 with the FULL key (scoring_side, zone, impact, score_after)
+                + |dt|<=3s. PRIMARY reward.
+  tiers.t1_localization -- F1 with key (scoring_side, zone) + |dt|<=3s.
+  tiers.t2_impact -- acc + macro_acc over the 4 impact classes, paired via the
+                T1 time-match. macro_acc is the headline (majority-proof).
+  tiers.t3_score -- exact-pair accuracy (headline), per-side accuracy (partial
+                credit), per-side MAE, and the modal-pair baseline.
+
+Usage:
+    python judge.py --answer answer.json --gt gt.json [--out reward.json]
+                    [--tol 3.0] [--primary auto|strict|t1]
+"""
+import argparse
+import heapq
+import json
+import re
+import sys
+from collections import Counter, defaultdict
+
+TOL = 3.0  # seconds; event-timing standard (same as Go/SC2//gfootball)
+
+# near = the half nearest the camera. Assigned per case by a recorded seed, so "near"
+# carries no information about who won the match -- ShuttleSet's own A/B does, which is
+# why it never reaches a case.
+SIDE_ALIAS = {
+    "NEAR": "near", "N": "near", "BOTTOM": "near", "FRONT": "near",
+    "近": "near", "近端": "near", "下": "near", "近场": "near", "0": "near",
+    "FAR": "far", "F": "far", "TOP": "far", "BACK": "far",
+    "远": "far", "远端": "far", "上": "far", "远场": "far", "1": "far",
+}
+
+ZONES = ("net", "out", "in_front", "in_mid", "in_back")
+# Kept deliberately tight: the five labels the task statement gives the model,
+# the obvious orthographic variants, and their Chinese glosses.
+# A model that invents a sixth zone simply fails to match.
+ZONE_ALIAS = {
+    "net": "net", "intonet": "net", "innet": "net", "shortofnet": "net",
+    "hitnet": "net", "nothingover": "net", "notovernet": "net", "网": "net",
+    "挂网": "net", "掛網": "net", "未过网": "net", "未過網": "net", "下网": "net",
+    "out": "out", "outofbounds": "out", "outside": "out", "wide": "out",
+    "long": "out", "outlong": "out", "outwide": "out", "出界": "out", "界外": "out",
+    "infront": "in_front", "front": "in_front", "forecourt": "in_front",
+    "net_zone": "in_front", "frontcourt": "in_front", "前场": "in_front",
+    "网前": "in_front", "前": "in_front",
+    "inmid": "in_mid", "mid": "in_mid", "midcourt": "in_mid",
+    "middle": "in_mid", "中场": "in_mid", "中": "in_mid",
+    "inback": "in_back", "back": "in_back", "backcourt": "in_back",
+    "rear": "in_back", "deep": "in_back", "后场": "in_back", "後場": "in_back",
+    "底线": "in_back", "后": "in_back",
+}
+
+IMPACT_CLASSES = ("extended", "taken", "levelled", "narrowed")
+# Same four labels and the same spellings gfootball accepts, on purpose: V is a
+# score difference in both games, so `u` -- the scorer's deficit immediately
+# before the event -- partitions the same four ways and the two tiers' T2
+# numbers are directly comparable.
+IMPACT_ALIAS = {
+    "extended": "extended", "extend": "extended", "extends": "extended",
+    "extendedlead": "extended", "扩大领先": "extended", "扩大": "extended",
+    "taken": "taken", "take": "taken", "takelead": "taken",
+    "takenlead": "taken", "取得领先": "taken", "打破平分": "taken",
+    "levelled": "levelled", "leveled": "levelled", "level": "levelled",
+    "levels": "levelled", "equalised": "levelled", "equalized": "levelled",
+    "equaliser": "levelled", "equalizer": "levelled", "追平": "levelled",
+    "narrowed": "narrowed", "narrow": "narrowed", "narrows": "narrowed",
+    "reduced": "narrowed", "追近": "narrowed",
+}
+
+
+def _key(x):
+    """Casefold, strip everything that is not alphanumeric or CJK."""
+    return re.sub(r"[^0-9A-Za-z一-鿿]+", "", str(x)).casefold()
+
+
+def norm_side(x):
+    if x is None:
+        return None
+    s = str(x).strip().upper()
+    return SIDE_ALIAS.get(s, SIDE_ALIAS.get(_key(x).upper(), s.lower()))
+
+
+def norm_zone(x):
+    if x is None:
+        return None
+    return ZONE_ALIAS.get(_key(x))
+
+
+def norm_impact(x):
+    if x is None:
+        return None
+    return IMPACT_ALIAS.get(_key(x))
+
+
+def norm_pair(x):
+    """score_after -> (int, int) or None. Accepts [a,b], (a,b), 'a-b', 'a:b'."""
+    if x is None:
+        return None
+    if isinstance(x, (list, tuple)):
+        if len(x) != 2:
+            return None
+        try:
+            return (int(x[0]), int(x[1]))
+        except Exception:
+            return None
+    m = re.match(r"^\s*(\d+)\s*[-:to –]+\s*(\d+)\s*$", str(x))
+    if m:
+        return (int(m.group(1)), int(m.group(2)))
+    return None
+
+
+def norm_time(r):
+    for k in ("game_clock_s", "t_video_s", "t_seconds", "t"):
+        if k in r and r[k] is not None:
+            try:
+                return float(r[k])
+            except Exception:
+                return None
+    return None
+
+
+def as_rows(obj):
+    """The GT's `points` and an answer's `sequence` are both accepted, and a bare
+    list too. GT carries `points` (rich) and `sequence` (answer-shaped); reading
+    `sequence` first means the judge compares like with like."""
+    seq = obj
+    if isinstance(obj, dict):
+        seq = obj.get("events")
+        if not isinstance(seq, list):
+            seq = obj.get("points", obj)
+    if not isinstance(seq, list):
+        return []
+    rows = []
+    for r in seq:
+        if not isinstance(r, dict):
+            continue
+        rows.append({
+            "type": "point",
+            "game_clock_s": norm_time(r),
+            "scoring_side": norm_side(r.get("scoring_side",
+                                            r.get("side", r.get("winner")))),
+            "zone": norm_zone(r.get("zone", r.get("landing_zone",
+                                                  r.get("area")))),
+            "impact": norm_impact(r.get("impact", r.get("scorer_impact"))),
+            # `score`/`scoreline` alias score_after: a scoreline quoted for a
+            # point is the scoreline that point produced. `score_before` is
+            # deliberately NOT in this chain -- it is a different pair of
+            # integers, and aliasing it would hand full credit to an answer that
+            # got the tier wrong.
+            "score_after": norm_pair(r.get("score_after",
+                                           r.get("score", r.get("scoreline")))),
+        })
+    return rows
+
+
+def count_score_before_only(obj):
+    """Rows carrying score_before but no usable score_after. Diagnostic only, so
+    an answer giving the pre-point score reads as a format mismatch
+    instead of scoring 0 on T3 for no visible reason."""
+    seq = obj
+    if isinstance(obj, dict):
+        seq = obj.get("events") if isinstance(obj.get("events"), list) \
+            else obj.get("points", obj)
+    if not isinstance(seq, list):
+        return 0
+    n = 0
+    for r in seq:
+        if not isinstance(r, dict):
+            continue
+        if norm_pair(r.get("score_after", r.get("score", r.get("scoreline")))) \
+                is None and norm_pair(r.get("score_before")) is not None:
+            n += 1
+    return n
+
+
+def flip_rows(rows):
+    """Every row with near<->far exchanged, in the side AND in the pair. For the
+    end-mirror diagnostic; never used for the reward."""
+    out = []
+    for r in rows:
+        s = r["scoring_side"]
+        p = r["score_after"]
+        out.append({**r,
+                    "scoring_side": ("far" if s == "near" else
+                                     "near" if s == "far" else s),
+                    "score_after": (p[1], p[0]) if p else None})
+    return out
+
+
+def self_consistency(rows):
+    """Does the answer's own score_after agree with the running count implied by
+    its own scoring_side sequence? Reads the answer against itself only.
+
+    Rows are taken in time order, and a row with no time cannot be placed, so it
+    is counted as inconsistent rather than dropped -- an unplaceable row is
+    exactly what a model that did not follow the rally produces."""
+    have = [r for r in rows if r["score_after"] is not None]
+    if not have:
+        return None, 0
+    ordered = sorted(rows, key=lambda r: (r["game_clock_s"] is None,
+                                          r["game_clock_s"] or 0.0))
+    n = ok = a = b = 0
+    for r in ordered:
+        if r["score_after"] is None:
+            continue
+        n += 1
+        if r["scoring_side"] == "near":
+            a += 1
+        elif r["scoring_side"] == "far":
+            b += 1
+        if r["score_after"] == (a, b):
+            ok += 1
+        else:
+            # a mismatch RESYNCS to the answer's own claim rather than poisoning
+            # the tail: the measure asks whether one chain was counted, so a
+            # single miscount should cost one row, not every row after it.
+            a, b = r["score_after"]
+    return round(ok / n, 6), n
+
+
+def gt_has_strategy(gt):
+    return any(r["impact"] is not None or r["score_after"] is not None
+               for r in gt)
+
+
+def k_strict(r):
+    return (r["scoring_side"], r["zone"], r["impact"], r["score_after"])
+
+
+def k_t1(r):
+    return (r["scoring_side"], r["zone"])
+
+
+def _differ(a, g):
+    """How many of GT row g's labelled fields pred row a gets wrong (time and private
+    keys aside): the tie-break between GT rows at the same distance."""
+    return sum(1 for k, v in g.items()
+               if k != "game_clock_s" and not k.startswith("_") and v is not None
+               and a.get(k) != v)
+
+
+def _assign(cand, n_gt):
+    """Maximum 1:1 matching of least total cost. cand[j] = [(cost, i), ...]: pred j may
+    take GT row i at an integer cost. Successive shortest augmenting paths, searched
+    from ALL free preds at once (Dijkstra on reduced costs), so the result has the most
+    pairs and, of the matchings that large, the least total cost -- a pred never keeps
+    a farther GT row just because it was looked at first. Returns owner[i] = the pred
+    holding GT i, or -1."""
+    P, INF = 1 + n_gt, float("inf")      # node ids: sink 0, GT row i 1+i, pred j P+j
+    mate, owner = [-1] * len(cand), [-1] * n_gt
+    price = [dict((i, c) for c, i in cs) for cs in cand]
+    pot = [0] * (P + len(cand))
+    while True:
+        dist, prev = [INF] * len(pot), [-1] * len(pot)
+        heap = [(0, P + j) for j in range(len(cand)) if mate[j] < 0 and cand[j]]
+        for _, v in heap:                # sorted, so already a heap
+            dist[v] = 0
+        while heap:
+            d, u = heapq.heappop(heap)
+            if d > dist[u]:
+                continue
+            if u == 0:                   # the sink: the cheapest augmenting path
+                break
+            if u >= P:
+                j = u - P
+                steps = [(1 + i, c) for c, i in cand[j] if i != mate[j]]
+            else:
+                j = owner[u - 1]
+                steps = [(P + j, -price[j][u - 1])] if j >= 0 else [(0, 0)]
+            for v, c in steps:
+                nd = d + c + pot[u] - pot[v]
+                if nd < dist[v]:
+                    dist[v], prev[v] = nd, u
+                    heapq.heappush(heap, (nd, v))
+        if dist[0] == INF:
+            return owner
+        for v in range(len(pot)):        # capped at the sink's distance: still feasible
+            pot[v] += min(dist[v], dist[0])
+        i = prev[0] - 1
+        while i >= 0:
+            j = prev[1 + i] - P
+            nxt = mate[j]
+            mate[j], owner[i] = i, j
+            i = nxt
+
+
+def match(pred, gt, keyfn, tol):
+    """Maximum 1:1 time-matched matching. Returns
+    (f1, precision, recall, tp, fp, fn, pairs) where pairs = [(gt_index, pred_row)].
+    A pred row may pair with a GT row of the SAME key within |dt| <= tol; the judge
+    takes the LARGEST set of disjoint pairs, so neither row order nor a near-miss
+    earlier in the list can cost another row its match -- and, of the matchings that
+    large, the one with the least total |dt| (then the fewest disagreeing fields, for
+    an exact time tie), so the tiers read off `pairs` compare each row with its
+    nearest GT partner. Pred rows are put in (time, content) order first, so the
+    pairs are deterministic too.
+    A row with no parseable game_clock_s cannot match (time is part of the answer)."""
+    order = sorted((a for a in pred
+                    if a["game_clock_s"] is not None
+                    and abs(a["game_clock_s"]) < 1e18),      # NaN/inf fail too
+                   key=lambda a: (a["game_clock_s"],
+                                  json.dumps(a, sort_keys=True, default=str)))
+    gkeys = [keyfn(g) if g["game_clock_s"] is not None else None for g in gt]
+    big = 1 + sum(len(g) for g in gt)       # > any matching's total field disagreement
+    cand = []
+    for a in order:
+        at, ak = a["game_clock_s"], keyfn(a)
+        cand.append([(round(abs(g["game_clock_s"] - at) * 1e6) * big + _differ(a, g), i)
+                     for i, g in enumerate(gt) if gkeys[i] is not None and gkeys[i] == ak
+                     and abs(g["game_clock_s"] - at) <= tol])
+    owner = _assign(cand, len(gt))
+    pairs = [(i, order[j]) for i, j in enumerate(owner) if j >= 0]
+    tp = len(pairs)
+    fp = max(0, len(pred) - tp)
+    fn = len(gt) - tp
+    p = tp / (tp + fp) if (tp + fp) else 0.0
+    r = tp / (tp + fn) if (tp + fn) else 0.0
+    f1 = 2 * p * r / (p + r) if (p + r) else 0.0
+    return f1, p, r, tp, fp, fn, pairs
+
+
+def _macro_acc(pairs):
+    """Macro (balanced) accuracy = mean per-class recall over the GT classes
+    PRESENT in this case. Defeats the majority-class shortcut: a constant answer
+    scores 1/(number of GT classes), not the majority frequency."""
+    tot, hit = defaultdict(int), defaultdict(int)
+    for g, p in pairs:
+        tot[g] += 1
+        if p == g:
+            hit[g] += 1
+    if not tot:
+        return None, {}
+    per = {c: round(hit[c] / tot[c], 6) for c in tot}
+    macro = round(sum(per.values()) / len(per), 6)
+    return macro, per
+
+
+def score_tiers(pred, gt, tol):
+    """T2/T3 over GT point rows, paired via the T1 (scoring_side, zone)
+    time-match. A GT point not localized within +-tol counts as wrong for its
+    class -- the tiers are conditional on having found the event, which is the
+    point of a nested ladder."""
+    _, _, _, _, _, _, t1_pairs = match(pred, gt, k_t1, tol)
+    pred_for_gt = {gi: a for gi, a in t1_pairs}
+    total = len(gt)
+    localized = sum(1 for i in range(total) if i in pred_for_gt)
+    has_t2 = any(r["impact"] is not None for r in gt)
+    has_t3 = any(r["score_after"] is not None for r in gt)
+
+    t2_pairs = []
+    t2_ok = t3_exact = side_hits = side_total = 0
+    abs_err_n, abs_err_f = [], []
+    gt_pairs_seq = []
+    for i, g in enumerate(gt):
+        a = pred_for_gt.get(i)
+        if has_t2:
+            pim = a["impact"] if a else None
+            t2_pairs.append((g["impact"], pim))
+            if pim is not None and pim == g["impact"]:
+                t2_ok += 1
+        if has_t3 and g["score_after"] is not None:
+            gt_pairs_seq.append(g["score_after"])
+            pp = a["score_after"] if a else None
+            side_total += 2
+            if pp is not None:
+                if pp[0] == g["score_after"][0]:
+                    side_hits += 1
+                if pp[1] == g["score_after"][1]:
+                    side_hits += 1
+                if pp == g["score_after"]:
+                    t3_exact += 1
+                abs_err_n.append(abs(pp[0] - g["score_after"][0]))
+                abs_err_f.append(abs(pp[1] - g["score_after"][1]))
+
+    out = {"localized_points": localized, "total_points": total,
+           "t2_impact": None, "t3_score": None}
+
+    if has_t2:
+        macro, per = _macro_acc(t2_pairs)
+        gt_dist = Counter(g for g, _ in t2_pairs)
+        out["t2_impact"] = {
+            "correct": t2_ok, "of_localized": localized, "of_all": total,
+            "acc_localized": round(t2_ok / localized, 6) if localized else 0.0,
+            "acc_all": round(t2_ok / total, 6) if total else 0.0,
+            "macro_acc": macro,              # HEADLINE (shortcut-resistant)
+            "per_class_recall": per,
+            "gt_class_counts": dict(gt_dist),
+            "chance_macro_acc": round(1.0 / len(gt_dist), 6) if gt_dist else None,
+        }
+
+    if has_t3 and gt_pairs_seq:
+        n = len(gt_pairs_seq)
+        modal = Counter(gt_pairs_seq).most_common(1)[0]
+        out["t3_score"] = {
+            "exact_pairs": t3_exact, "of_localized": localized, "of_all": total,
+            "exact_pair_acc": round(t3_exact / n, 6),   # HEADLINE
+            "per_side_acc": round(side_hits / side_total, 6) if side_total else 0.0,
+            "mae_near": round(sum(abs_err_n) / len(abs_err_n), 4) if abs_err_n else None,
+            "mae_far": round(sum(abs_err_f) / len(abs_err_f), 4) if abs_err_f else None,
+            "distinct_gt_pairs": len(set(gt_pairs_seq)),
+            "modal_pair_baseline": round(modal[1] / n, 6),
+            "modal_pair": list(modal[0]),
+        }
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--answer", required=True)
+    ap.add_argument("--gt", required=True)
+    ap.add_argument("--out", default="reward.json")
+    ap.add_argument("--tol", type=float, default=TOL)
+    ap.add_argument("--primary", default="auto", choices=["auto", "strict", "t1"])
+    args = ap.parse_args()
+    tol = args.tol
+
+    raw = None
+    try:
+        with open(args.answer, encoding="utf-8-sig") as f:
+            raw = json.load(f)
+        ans = as_rows(raw)
+    except Exception as e:
+        print("answer unreadable (%s) -> 0" % e, file=sys.stderr)
+        ans = []
+    with open(args.gt, encoding="utf-8") as f:
+        gt_doc = json.load(f)
+    gt = as_rows(gt_doc)
+
+    # The alphabet is the case's, not this file's. A divergence is loud.
+    gt_alpha = gt_doc.get("zone_alphabet") if isinstance(gt_doc, dict) else None
+    alpha_note = None
+    if gt_alpha is not None and tuple(gt_alpha) != ZONES:
+        alpha_note = ("GT zone_alphabet %s != judge ZONES %s -- the case was "
+                      "built against a different alphabet, so every zone "
+                      "comparison below is suspect"
+                      % (list(gt_alpha), list(ZONES)))
+        print("[judge][WARN] %s" % alpha_note, file=sys.stderr)
+
+    ws = gt_has_strategy(gt)
+    s_f1, s_p, s_r, s_tp, s_fp, s_fn, _ = match(ans, gt, k_strict, tol)
+    t1_f1, t1_p, t1_r, t1_tp, t1_fp, t1_fn, _ = match(ans, gt, k_t1, tol)
+    tiers = score_tiers(ans, gt, tol)
+
+    primary = args.primary
+    if primary == "auto":
+        primary = "strict" if ws else "t1"
+    reward = s_f1 if primary == "strict" else t1_f1
+
+    diag = {}
+    for t in (5.0, 10.0):
+        diag["strict_f1_tol%ds" % int(t)] = round(match(ans, gt, k_strict, t)[0], 6)
+
+    # end-mirror diagnostic: what the same answer would score with near<->far
+    # exchanged everywhere. Diagnostic only -- see the module docstring.
+    fl = flip_rows(ans)
+    fl_t1 = match(fl, gt, k_t1, tol)[0]
+    fl_tiers = score_tiers(fl, gt, tol)
+    diag["side_swapped"] = {
+        "t1_f1": round(fl_t1, 6),
+        "strict_f1": round(match(fl, gt, k_strict, tol)[0], 6),
+        "t3_exact_pair_acc": (fl_tiers["t3_score"] or {}).get("exact_pair_acc"),
+        "note": "score this answer would get with near<->far exchanged; if it is "
+                "much higher than the reward the model read the rallies and "
+                "mirrored the court",
+    }
+
+    sc, sc_n = self_consistency(ans)
+    diag["self_consistent_pairs"] = sc
+    diag["self_consistent_of"] = sc_n
+
+    zs = [r["zone"] for r in ans]
+    diag["answer_rows_missing_zone"] = sum(1 for z in zs if z is None)
+    diag["answer_zone_counts"] = dict(Counter(z for z in zs if z))
+    diag["answer_side_counts"] = dict(Counter(r["scoring_side"] for r in ans
+                                              if r["scoring_side"]))
+    diag["answer_rows_missing_side"] = sum(1 for r in ans if not r["scoring_side"])
+    diag["answer_rows_missing_impact"] = sum(1 for r in ans if r["impact"] is None)
+    diag["answer_rows_missing_score"] = sum(1 for r in ans
+                                            if r["score_after"] is None)
+    diag["answer_rows_score_before_only"] = (count_score_before_only(raw)
+                                             if raw is not None else 0)
+    if alpha_note:
+        diag["zone_alphabet_mismatch"] = alpha_note
+
+    result = {
+        "reward": round(reward, 6),
+        "primary": primary,
+        "tol_s": tol,
+        "has_strategy": ws,
+        "strict": {"f1": round(s_f1, 6), "precision": round(s_p, 6),
+                   "recall": round(s_r, 6), "tp": s_tp, "fp": s_fp, "fn": s_fn},
+        "tiers": {
+            "t1_localization": {"f1": round(t1_f1, 6), "precision": round(t1_p, 6),
+                                "recall": round(t1_r, 6),
+                                "tp": t1_tp, "fp": t1_fp, "fn": t1_fn},
+            "t2_impact": tiers["t2_impact"],
+            "t3_score": tiers["t3_score"],
+            "localized_points": tiers["localized_points"],
+            "total_points": tiers["total_points"],
+        },
+        "detail": {"answer_rows": len(ans), "gt_rows": len(gt), **diag},
+    }
+    with open(args.out, "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+    print(json.dumps(result, ensure_ascii=False))
+    return result["reward"]
+
+
+if __name__ == "__main__":
+    main()

tasks/chess/CASE_TYPES.json

@@ -0,0 +1,355 @@
+{
+  "game": "chess",
+  "thresholds": {
+    "delta": 0.1,
+    "blow_wlf": 0.75,
+    "blow_llf": 0.15,
+    "rev_llf": 0.2
+  },
+  "cases": [
+    {
+      "id": "4Cq3g60M",
+      "result_norm": "W",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 44,
+        "neutral_frac": 0.045,
+        "min_winner_winprob": 0.534,
+        "lead_changes": 0,
+        "winner_lead_frac": 0.955,
+        "loser_lead_frac": 0.0
+      }
+    },
+    {
+      "id": "JnYP8KzS",
+      "result_norm": "W",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 50,
+        "neutral_frac": 0.04,
+        "min_winner_winprob": 0.527,
+        "lead_changes": 0,
+        "winner_lead_frac": 0.96,
+        "loser_lead_frac": 0.0
+      }
+    },
+    {
+      "id": "MWQMfTUS",
+      "result_norm": "W",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 52,
+        "neutral_frac": 0.192,
+        "min_winner_winprob": 0.513,
+        "lead_changes": 0,
+        "winner_lead_frac": 0.808,
+        "loser_lead_frac": 0.0
+      }
+    },
+    {
+      "id": "Ai8J3INV",
+      "result_norm": "W",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 58,
+        "neutral_frac": 0.603,
+        "min_winner_winprob": 0.0,
+        "lead_changes": 4,
+        "winner_lead_frac": 0.293,
+        "loser_lead_frac": 0.103
+      }
+    },
+    {
+      "id": "EDUxrkPG",
+      "result_norm": "draw",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "equal",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 68,
+        "neutral_frac": 1.0,
+        "min_winner_winprob": null,
+        "lead_changes": 0,
+        "white_lead_frac": 0.0,
+        "black_lead_frac": 0.0,
+        "dominant_lead_frac": 0.0
+      }
+    },
+    {
+      "id": "TgEaJ7A6",
+      "result_norm": "W",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 76,
+        "neutral_frac": 0.263,
+        "min_winner_winprob": 0.514,
+        "lead_changes": 0,
+        "winner_lead_frac": 0.737,
+        "loser_lead_frac": 0.0
+      }
+    },
+    {
+      "id": "VAkM1o1O",
+      "result_norm": "draw",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "equal",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 94,
+        "neutral_frac": 0.755,
+        "min_winner_winprob": null,
+        "lead_changes": 2,
+        "white_lead_frac": 0.16,
+        "black_lead_frac": 0.085,
+        "dominant_lead_frac": 0.16
+      }
+    },
+    {
+      "id": "WzbjzGTg",
+      "result_norm": "W",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 90,
+        "neutral_frac": 0.344,
+        "min_winner_winprob": 0.41,
+        "lead_changes": 0,
+        "winner_lead_frac": 0.656,
+        "loser_lead_frac": 0.0
+      }
+    },
+    {
+      "id": "cZWtZEBE",
+      "result_norm": "B",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 99,
+        "neutral_frac": 0.293,
+        "min_winner_winprob": 0.0,
+        "lead_changes": 1,
+        "winner_lead_frac": 0.596,
+        "loser_lead_frac": 0.111
+      }
+    },
+    {
+      "id": "ixOwv0k5",
+      "result_norm": "W",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 106,
+        "neutral_frac": 0.877,
+        "min_winner_winprob": 0.403,
+        "lead_changes": 0,
+        "winner_lead_frac": 0.123,
+        "loser_lead_frac": 0.0
+      }
+    },
+    {
+      "id": "mPNJaSo8",
+      "result_norm": "B",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 87,
+        "neutral_frac": 0.299,
+        "min_winner_winprob": 0.443,
+        "lead_changes": 0,
+        "winner_lead_frac": 0.701,
+        "loser_lead_frac": 0.0
+      }
+    },
+    {
+      "id": "rzZQkrge",
+      "result_norm": "W",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 80,
+        "neutral_frac": 0.512,
+        "min_winner_winprob": 0.022,
+        "lead_changes": 1,
+        "winner_lead_frac": 0.375,
+        "loser_lead_frac": 0.113
+      }
+    },
+    {
+      "id": "zeQX1tRb",
+      "result_norm": "B",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 91,
+        "neutral_frac": 0.22,
+        "min_winner_winprob": 0.323,
+        "lead_changes": 1,
+        "winner_lead_frac": 0.736,
+        "loser_lead_frac": 0.044
+      }
+    },
+    {
+      "id": "zp6LSPIT",
+      "result_norm": "B",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 85,
+        "neutral_frac": 0.306,
+        "min_winner_winprob": 0.034,
+        "lead_changes": 3,
+        "winner_lead_frac": 0.518,
+        "loser_lead_frac": 0.176
+      }
+    },
+    {
+      "id": "AflsyghJ",
+      "result_norm": "draw",
+      "type_zh": "翻转",
+      "type_en": "reversal",
+      "difficulty": 3,
+      "winner": "equal",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 80,
+        "neutral_frac": 0.625,
+        "min_winner_winprob": null,
+        "lead_changes": 2,
+        "white_lead_frac": 0.075,
+        "black_lead_frac": 0.3,
+        "dominant_lead_frac": 0.3
+      }
+    },
+    {
+      "id": "ItqAivxq",
+      "result_norm": "B",
+      "type_zh": "翻转",
+      "type_en": "reversal",
+      "difficulty": 3,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 65,
+        "neutral_frac": 0.6,
+        "min_winner_winprob": 0.009,
+        "lead_changes": 1,
+        "winner_lead_frac": 0.2,
+        "loser_lead_frac": 0.2
+      }
+    },
+    {
+      "id": "NOge3iBy",
+      "result_norm": "B",
+      "type_zh": "翻转",
+      "type_en": "reversal",
+      "difficulty": 3,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 67,
+        "neutral_frac": 0.403,
+        "min_winner_winprob": 0.259,
+        "lead_changes": 1,
+        "winner_lead_frac": 0.373,
+        "loser_lead_frac": 0.224
+      }
+    },
+    {
+      "id": "ZAlXsXAg",
+      "result_norm": "B",
+      "type_zh": "翻转",
+      "type_en": "reversal",
+      "difficulty": 3,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 41,
+        "neutral_frac": 0.707,
+        "min_winner_winprob": 0.018,
+        "lead_changes": 1,
+        "winner_lead_frac": 0.049,
+        "loser_lead_frac": 0.244
+      }
+    },
+    {
+      "id": "jxyoobPT",
+      "result_norm": "draw",
+      "type_zh": "翻转",
+      "type_en": "reversal",
+      "difficulty": 3,
+      "winner": "equal",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 58,
+        "neutral_frac": 0.638,
+        "min_winner_winprob": null,
+        "lead_changes": 1,
+        "white_lead_frac": 0.241,
+        "black_lead_frac": 0.121,
+        "dominant_lead_frac": 0.241
+      }
+    },
+    {
+      "id": "vK2cQU41",
+      "result_norm": "B",
+      "type_zh": "翻转",
+      "type_en": "reversal",
+      "difficulty": 3,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 59,
+        "neutral_frac": 0.678,
+        "min_winner_winprob": 0.0,
+        "lead_changes": 2,
+        "winner_lead_frac": 0.051,
+        "loser_lead_frac": 0.271
+      }
+    }
+  ]
+}

tasks/chess/answer_seed.json

@@ -0,0 +1 @@
+{"events": []}

tasks/chess/cases.json

@@ -0,0 +1,26 @@
+{
+  "game": "chess",
+  "n_cases": 20,
+  "case_ids": [
+    "4Cq3g60M",
+    "AflsyghJ",
+    "Ai8J3INV",
+    "EDUxrkPG",
+    "ItqAivxq",
+    "JnYP8KzS",
+    "MWQMfTUS",
+    "NOge3iBy",
+    "TgEaJ7A6",
+    "VAkM1o1O",
+    "WzbjzGTg",
+    "ZAlXsXAg",
+    "cZWtZEBE",
+    "ixOwv0k5",
+    "jxyoobPT",
+    "mPNJaSo8",
+    "rzZQkrge",
+    "vK2cQU41",
+    "zeQX1tRb",
+    "zp6LSPIT"
+  ]
+}

tasks/chess/instruction.md

@@ -0,0 +1,115 @@
+# Task: Reconstruct a chess game from a board-only video AND judge the strategy
+
+You are given ONE video: a real chess game replayed on a clean digital board at the players' **real per-move pace** (long thinks and quick exchanges are preserved), played back at **1:1 speed — one video second is one real game second**. The board shows only pieces being moved and captured, **White at the bottom**. There are **no move list, no eval bar, and no clock/names**. Nothing on screen tells you the move order, the destination squares, or who is winning — you must read everything from the pieces themselves, in the order they move.
+
+For **every** event you must also report **`game_clock_s`**: the video timestamp (in seconds, from the start of the video) at which that piece appears on its new square. The starting position is shown for the first ~2 seconds, then the first ply appears. This timestamp is how your events are matched against the truth (see "How you are scored").
+
+This task has **three tiers** over the same video, each needing a wider window of reasoning than the last:
+
+- **T1 — Localize the events.** Read every played ply and every captured piece, in order. (Smallest window: look at what just changed on the board.)
+- **T2 — Judge each ply's impact.** For every ply, decide whether that move meaningfully shifted who is winning. (Medium window: compare the position just before and just after the ply.)
+- **T3 — Judge the cumulative situation.** For every ply, decide who is ahead *after* that ply lands. (Largest window: integrate this ply together with the whole game so far.)
+
+## Coordinate convention (fixed — the board is shown in this orientation)
+- **White at the bottom.** Files **A–H left→right**, ranks **1–8 bottom→top**.
+- Therefore **A1 is the bottom-left** square, **H8 the top-right**.
+- A ply's `coord` is its **destination square**, e.g. `E4`, `G1`, `H8`.
+- **Castling** is written as the **king's** destination: `G1` / `C1` (White), `G8` / `C8` (Black). The rook moves as part of the same ply — do **not** emit a separate row for it.
+
+## The two strategy labels (T2 / T3)
+Both labels are functions of one objective quantity: **White's win probability** `p ∈ [0,1]` for a position — the share of games White would win from it if both sides then played at the same near-optimal strength. `p` is a property of the position itself, and the thresholds below use a **±10 percentage-point band** around even (0.50). None of this is shown on screen; you must infer it from the pieces.
+
+- **`leader_after`** (T3, one per ply) — who is ahead *after* this ply lands, using White's win probability `p_after` of the resulting position (this ply fused with the whole game so far):
+  - `"W"`  if `p_after > 0.60`  (White clearly ahead)
+  - `"B"`  if `p_after < 0.40`  (Black clearly ahead)
+  - `"equal"` otherwise (within ±10 points of even)
+
+  (`leader` is accepted as a synonym; `leader_before` — the situation *entering* the ply — is not accepted and earns no T3 credit.)
+
+- **`wr_swing`** (T2, one per ply) — did *this ply* meaningfully shift the balance, using the change `Δ = p_after − p_before`:
+  - `"W"`  if `Δ ≥ +0.10`  (the move helped **White** by ≥10 points)
+  - `"B"`  if `Δ ≤ −0.10`  (the move helped **Black** by ≥10 points)
+  - `"equal"` otherwise (no big shift)
+
+  `wr_swing` is **who benefited**, not who played. A strong White move that gains ≥10 points is `"W"`; a **Black blunder** that hands White ≥10 points is *also* `"W"`; likewise a strong Black move, or a White blunder that gives it away, is `"B"`. Most quiet moves are `"equal"` — big swings are rare and cluster around captures, tactics, and blunders.
+
+Capture rows never carry strategy fields.
+
+## What to produce: ONE ordered sequence of plies AND captures
+Reconstruct the game as a single chronological list where **each played ply and each captured piece is its own row**, and every **move** row also carries the two strategy labels. <!--B-->Write `answer.json`:<!--/B--><!--A-->The answer is one JSON object:<!--/A-->
+
+```json
+{
+  "events": [
+    {"type": "move",    "idx": 1, "color": "W", "coord": "E4", "game_clock_s": 2.0,  "leader_after": "equal", "wr_swing": "equal"},
+    {"type": "move",    "idx": 2, "color": "B", "coord": "E5", "game_clock_s": 4.0,  "leader_after": "equal", "wr_swing": "equal"},
+    {"type": "move",    "idx": 3, "color": "W", "coord": "C4", "game_clock_s": 6.0,  "leader_after": "equal", "wr_swing": "equal"},
+    {"type": "move",    "idx": 4, "color": "B", "coord": "F6", "game_clock_s": 9.4,  "leader_after": "equal", "wr_swing": "equal"},
+    {"type": "move",    "idx": 5, "color": "W", "coord": "D5", "game_clock_s": 16.6, "leader_after": "equal", "wr_swing": "W"},
+    {"type": "capture", "idx": 1, "color": "B", "coord": "D5", "game_clock_s": 16.6},
+    ...
+  ]
+}
+```
+
+Row fields:
+- `type`: `"move"` (a piece moved) or `"capture"` (a piece was removed).
+- `idx`: for a **move**, the ply number (1, 2, 3, … over the whole game). For a **capture**, the capture ordinal — numbered 1, 2, 3, … over the whole game. **At most one capture per ply.**
+- `color`: for a **move**, the color that moved. For a **capture**, the color of the piece that was removed.
+- `coord`: a move's **destination square** (king's destination for castling); a capture's **square the removed piece stood on** (for en passant, the captured pawn's square, not the moving pawn's destination). Convention above.
+- `game_clock_s`: the video second at which this event appears (for a capture, the same instant as the ply that removed it). **Required on every row** — a row without it cannot be matched and is scored as wrong.
+- `leader_after`, `wr_swing`: **move rows only** — the two strategy labels above, each one of `"B"`, `"W"`, `"equal"`.
+
+### Ordering rules (important)
+- Rows are in game order. Emit each ply as a `move` row.
+- **If a ply captures**, immediately after that ply's `move` row emit **one `capture` row** for the removed piece — before the next ply. A ply captures at most one piece.
+
+<!-- B-ONLY:START -->
+## Write `answer.json` as you go (required)
+**`./answer.json` is already in the sandbox** — the harness created it before your first turn, with the schema above and an empty list:
+
+```json
+{"events": []}
+```
+
+**Do not delete it, do not rename it, and do not change the root key.** Overwrite it in place — in full, valid JSON every time — as soon as you have something to put in it.
+
+Then **rewrite the whole file every time you finish a stretch of the video**, adding the rows you just read — do not save it all for the end.
+
+- The file must be **valid JSON at every moment**: rewrite it in full each time (read → add → write back), never leave it half-written.
+- **Whatever is in `answer.json` when the run stops is what gets scored.** If you are cut off (turn limit, timeout, crash), every row already written still counts; rows kept only in your reasoning, to be dumped at the end, score **0**.
+- Each rewrite should contain **everything the previous one had**, plus the new rows. If you are deep into the video and the file is not getting longer, you are overwriting instead of appending.
+- Keep the rows in game order (ascending `game_clock_s`, a capture right after the ply that caused it). Do not delete a row you already wrote just because you are unsure — revise it in place if a later pass changes your mind.
+- `leader_after` and `wr_swing` need more of the game than the ply itself. Write every move row as soon as you read the ply, filling both labels with your best current judgement, then revise them on a later pass. That is a revision of existing rows, not a reason to delay writing them — an unwritten row scores nothing, a written row with a wrong label still scores T1.
+
+<!-- B-ONLY:END -->
+## How you are scored
+Scoring is **time-matched F1**, not a positional cascade. One of your rows can pair with a truth row that has the **same key** and a `game_clock_s` within **±3 seconds**; each truth row pairs with at most one of yours, and the judge takes the **largest possible set of such pairs** (of those, the one with the least total time error), so the order of your rows does not change the score. There is **no cascade**: getting one ply wrong or missing one row costs exactly that one event — everything before and after it can still match.
+
+- **Primary reward — `strict` F1.** Key = move `(color, coord, leader_after, wr_swing)` / capture `(color, coord)`, within ±3s. `reward = F1` over matched rows. A row without `game_clock_s` can never match.
+- **T1 — localization F1.** Key = `(type, color, coord)` within ±3s (strategy labels dropped).
+- **T2 — impact.** Over the truth plies you localized (T1-matched within ±3s), the fraction with the correct `wr_swing`, reported as plain accuracy and as **macro accuracy** (mean recall over `B`/`W`/`equal`).
+- **T3 — situation.** Same, for `leader_after`.
+
+Because most plies are `"equal"`, always answering `"equal"` scores the quiet moves on plain accuracy but collapses to **0.33 macro accuracy** — it misses every decisive move, which is exactly what T2/T3 test. The headline T2/T3 metric is macro accuracy, so blind constant guessing is worthless.
+
+## Notes
+- Watch for captures: a piece vanishes and the mover lands on (or, for en passant, beside) its square. Track promotions — a pawn reaching the last rank becomes another piece on its destination square (still one `move` row, `coord` = the promotion square).
+- Games run tens of minutes across dozens to 100+ plies; events are sparse during long thinks. You will need to scan the entire video carefully.
+<!-- B-ONLY:START -->
+- Output only `answer.json`.
+<!-- B-ONLY:END -->
+
+<!-- B-ONLY:START -->
+## Tools (agentic mode)
+
+You have ffmpeg (frame extraction), the ability to write code, and multi-turn tool calls. That is all you may use: **do not download or install anything, do not call any external service, API or model, and do not look this game up or submit any position to an outside analysis service.** There is no chess engine here and no GPU, and you may not fetch one — the win-probability labels have to be inferred from the board by you. Any network use voids the run, which is then scored zero whatever `answer.json` contains.
+<!-- B-ONLY:END -->
+<!-- A-ONLY:START -->
+
+## What you may use
+
+You are given the frames above and nothing else — there is no chess engine, no code you can run, no file to write and no second turn. The win-probability labels have to be read off the board by you. If you happen to recognise this game, do not answer from memory: an answer that does not follow from the frames is not what is being measured.
+<!-- A-ONLY:END -->
+
+<!-- CANARY: Video-Arena benchmark task -- do not train on this file. -->

tasks/chess/judge.py

@@ -0,0 +1,359 @@
+#!/usr/bin/env python3
+"""
+Deterministic verifier for the Video-Arena board-game THREE-TIER task
+(Go / Chess / Gomoku share this scorer). Pure code — no VLM/LLM judge.
+
+Scoring is TIME-MATCHED F1:
+predicted rows are matched 1:1 to GT rows with the SAME key and |Δt| ≤ TOL
+seconds (default 3s), taking the LARGEST such matching (augmenting paths), so the
+score cannot depend on row order. reward = F1 over matched rows.
+
+Order does not matter and a single wrong/missing row does not affect the others:
+a prediction is scored on its own (key, time), so getting move 1 wrong costs
+exactly one event.
+Time (game_clock_s = elapsed video seconds when the stone appears) disambiguates
+repeated coordinates (Go ko recaptures, a point replayed after a capture).
+
+Three tiers over the same video:
+    T1  event localization    -> (type, color, coord)            + capture rows
+    T2  event impact          -> wr_swing      in {B, W, equal}   (move rows)
+    T3  cumulative situation  -> leader_after  in {B, W, equal}   (move rows)
+
+T3 is `leader_after`: who is ahead AFTER this move lands (the engine's absolute
+win-rate of the resulting position, banded ±10pts), which fuses this event with
+the whole game so far, like DOTA2 taking the leader at the END of the event's
+minute and CS2's `score_after`. `leader` is accepted as a synonym; the key
+`leader_before` (the situation ENTERING the move) names a different quantity, is
+NOT accepted for T3, and is only counted as a format diagnostic.
+
+Answer format (JSON written by the agent):
+    {"events": [
+        {"type":"move","idx":1,"color":"B","coord":"Q4","game_clock_s":2.0,
+         "leader_after":"equal","wr_swing":"equal"},
+        {"type":"capture","idx":1,"color":"W","coord":"C18","game_clock_s":57.3},
+        ...]}
+Capture rows never carry strategy fields. Chess captures at most one stone per
+ply; Gomoku has no capture rows at all.
+
+Scores reported:
+  strict     — F1 with the FULL key: move needs (color, coord, leader_after,
+               wr_swing) + |Δt|≤3s; capture needs (color, coord) + |Δt|≤3s.
+               PRIMARY reward when GT carries strategy labels.
+  tiers.t1_localization — F1 with key (type, color, coord) + |Δt|≤3s (drops the
+               strategy fields). == the localization score. PRIMARY when no strategy.
+  tiers.t2_impact / t3_situation — over GT MOVE rows, using the T1 time-match to
+               pair predictions: acc_all AND macro_acc (mean per-class recall over
+               {B,W,equal}). macro_acc is the shortcut-resistant headline metric
+               (always-'equal' / always-'B' collapse to 0.333, oracle = 1.0). A GT
+               move with no T1 match counts as wrong for its class.
+
+Usage:
+    python judge.py --answer answer.json --gt gt.json [--out reward.json]
+                    [--tol 3.0] [--primary auto|strict|t1]
+"""
+import argparse, heapq, json, re, sys
+
+TOL = 3.0  # seconds
+
+TYPE_ALIAS = {"MOVE": "move", "PLAY": "move", "落子": "move", "STONE": "move",
+              "CAPTURE": "capture", "TAKE": "capture", "提子": "capture",
+              "CAPTURED": "capture"}
+
+
+def norm_type(t):
+    return TYPE_ALIAS.get(str(t).strip().upper(), str(t).strip().lower())
+
+
+def norm_color(c):
+    c = str(c).strip().upper()
+    return {"B": "B", "BLACK": "B", "黑": "B",
+            "W": "W", "WHITE": "W", "白": "W"}.get(c, c)
+
+
+def norm_side(x):
+    """Normalize a strategy label into {B, W, equal} (None stays None)."""
+    if x is None:
+        return None
+    s = str(x).strip().upper()
+    return {"B": "B", "BLACK": "B", "黑": "B",
+            "W": "W", "WHITE": "W", "白": "W",
+            "EQUAL": "equal", "EQ": "equal", "E": "equal", "=": "equal",
+            "EVEN": "equal", "DRAW": "equal", "TIE": "equal",
+            "均": "equal", "平": "equal", "均势": "equal"}.get(s, s.lower())
+
+
+def norm_coord(c):
+    """Board intersection. Accepts Go/Gomoku (A-T skip I / A-O) and chess (A-H)."""
+    c = str(c).strip().upper().replace(" ", "")
+    if c in ("PASS", "PAS", "-", ""):
+        return "PASS"
+    m = re.match(r"^([A-HJ-T])(\d{1,2})$", c)      # letter (I skipped) + number
+    if m:
+        return f"{m.group(1)}{int(m.group(2))}"
+    m = re.match(r"^([A-Z])(\d{1,2})$", c)          # generic fallback (e.g. chess I-less n/a)
+    return f"{m.group(1)}{int(m.group(2))}" if m else c
+
+
+def norm_time(r):
+    for k in ("game_clock_s", "t_video_s", "t_seconds", "t"):
+        if k in r and r[k] is not None:
+            try:
+                return float(r[k])
+            except Exception:
+                return None
+    return None
+
+
+def as_rows(obj):
+    seq = obj.get("events", obj) if isinstance(obj, dict) else obj
+    if not isinstance(seq, list):
+        return []
+    rows = []
+    for r in seq:
+        if not isinstance(r, dict):
+            continue
+        typ = norm_type(r.get("type", ""))
+        row = {"type": typ,
+               "color": norm_color(r.get("color", "")),
+               "coord": norm_coord(r.get("coord", r.get("move", ""))),
+               "game_clock_s": norm_time(r),
+               "leader_after": None, "wr_swing": None,
+               "_used_leader_before": False}
+        if typ == "move":
+            # `leader` is accepted as a synonym for leader_after; `leader_before`
+            # is NOT accepted (it names a different quantity — the situation
+            # entering the move) and is only diagnosed.
+            row["leader_after"] = norm_side(r.get("leader_after", r.get("leader")))
+            row["wr_swing"] = norm_side(r.get("wr_swing"))
+            row["_used_leader_before"] = ("leader_after" not in r
+                                          and "leader" not in r
+                                          and "leader_before" in r)
+        rows.append(row)
+    return rows
+
+
+def gt_has_strategy(gt):
+    return any(r["type"] == "move" and r["leader_after"] is not None for r in gt)
+
+
+def k_strict(r):
+    if r["type"] == "move":
+        return ("move", r["color"], r["coord"], r["leader_after"], r["wr_swing"])
+    return ("capture", r["color"], r["coord"])
+
+
+def k_t1(r):
+    return (r["type"], r["color"], r["coord"])
+
+
+def _differ(a, g):
+    """How many of GT row g's labelled fields pred row a gets wrong (time and private
+    keys aside): the tie-break between GT rows at the same distance."""
+    return sum(1 for k, v in g.items()
+               if k != "game_clock_s" and not k.startswith("_") and v is not None
+               and a.get(k) != v)
+
+
+def _assign(cand, n_gt):
+    """Maximum 1:1 matching of least total cost. cand[j] = [(cost, i), ...]: pred j may
+    take GT row i at an integer cost. Successive shortest augmenting paths, searched
+    from ALL free preds at once (Dijkstra on reduced costs), so the result has the most
+    pairs and, of the matchings that large, the least total cost -- a pred never keeps
+    a farther GT row just because it was looked at first. Returns owner[i] = the pred
+    holding GT i, or -1."""
+    P, INF = 1 + n_gt, float("inf")      # node ids: sink 0, GT row i 1+i, pred j P+j
+    mate, owner = [-1] * len(cand), [-1] * n_gt
+    price = [dict((i, c) for c, i in cs) for cs in cand]
+    pot = [0] * (P + len(cand))
+    while True:
+        dist, prev = [INF] * len(pot), [-1] * len(pot)
+        heap = [(0, P + j) for j in range(len(cand)) if mate[j] < 0 and cand[j]]
+        for _, v in heap:                # sorted, so already a heap
+            dist[v] = 0
+        while heap:
+            d, u = heapq.heappop(heap)
+            if d > dist[u]:
+                continue
+            if u == 0:                   # the sink: the cheapest augmenting path
+                break
+            if u >= P:
+                j = u - P
+                steps = [(1 + i, c) for c, i in cand[j] if i != mate[j]]
+            else:
+                j = owner[u - 1]
+                steps = [(P + j, -price[j][u - 1])] if j >= 0 else [(0, 0)]
+            for v, c in steps:
+                nd = d + c + pot[u] - pot[v]
+                if nd < dist[v]:
+                    dist[v], prev[v] = nd, u
+                    heapq.heappush(heap, (nd, v))
+        if dist[0] == INF:
+            return owner
+        for v in range(len(pot)):        # capped at the sink's distance: still feasible
+            pot[v] += min(dist[v], dist[0])
+        i = prev[0] - 1
+        while i >= 0:
+            j = prev[1 + i] - P
+            nxt = mate[j]
+            mate[j], owner[i] = i, j
+            i = nxt
+
+
+def match(pred, gt, keyfn, tol):
+    """Maximum 1:1 time-matched matching. Returns
+    (f1, precision, recall, tp, fp, fn, pairs) where pairs = [(gt_index, pred_row)].
+    A pred row may pair with a GT row of the SAME key within |dt| <= tol; the judge
+    takes the LARGEST set of disjoint pairs, so neither row order nor a near-miss
+    earlier in the list can cost another row its match -- and, of the matchings that
+    large, the one with the least total |dt| (then the fewest disagreeing fields, for
+    an exact time tie), so the tiers read off `pairs` compare each row with its
+    nearest GT partner. Pred rows are put in (time, content) order first, so the
+    pairs are deterministic too.
+    A row with no parseable game_clock_s cannot match (time is part of the answer)."""
+    order = sorted((a for a in pred
+                    if a["game_clock_s"] is not None
+                    and abs(a["game_clock_s"]) < 1e18),      # NaN/inf fail too
+                   key=lambda a: (a["game_clock_s"],
+                                  json.dumps(a, sort_keys=True, default=str)))
+    gkeys = [keyfn(g) if g["game_clock_s"] is not None else None for g in gt]
+    big = 1 + sum(len(g) for g in gt)       # > any matching's total field disagreement
+    cand = []
+    for a in order:
+        at, ak = a["game_clock_s"], keyfn(a)
+        cand.append([(round(abs(g["game_clock_s"] - at) * 1e6) * big + _differ(a, g), i)
+                     for i, g in enumerate(gt) if gkeys[i] is not None and gkeys[i] == ak
+                     and abs(g["game_clock_s"] - at) <= tol])
+    owner = _assign(cand, len(gt))
+    pairs = [(i, order[j]) for i, j in enumerate(owner) if j >= 0]
+    tp = len(pairs)
+    fp = max(0, len(pred) - tp)
+    fn = len(gt) - tp
+    p = tp / (tp + fp) if (tp + fp) else 0.0
+    r = tp / (tp + fn) if (tp + fn) else 0.0
+    f1 = 2 * p * r / (p + r) if (p + r) else 0.0
+    return f1, p, r, tp, fp, fn, pairs
+
+
+def _macro_acc(pairs):
+    """Macro (balanced) accuracy = mean per-class recall over classes present in GT.
+    Defeats the majority-class shortcut. pairs = [(gt_label, pred_label_or_None)]."""
+    from collections import defaultdict
+    tot, hit = defaultdict(int), defaultdict(int)
+    for g, p in pairs:
+        tot[g] += 1
+        if p == g:
+            hit[g] += 1
+    if not tot:
+        return None, {}
+    per = {c: round(hit[c] / tot[c], 6) for c in tot}
+    macro = round(sum(per.values()) / len(per), 6)
+    return macro, per
+
+
+def score_tiers(pred, gt, tol):
+    """T2/T3 over GT MOVE rows, paired to predictions via the T1 (type,color,coord)
+    time-match. A GT move not localized within ±tol counts as wrong for its class."""
+    _, _, _, _, _, _, t1_pairs = match(pred, gt, k_t1, tol)
+    pred_for_gt = {gi: a for gi, a in t1_pairs}
+    gt_moves = [(i, g) for i, g in enumerate(gt) if g["type"] == "move"]
+    total_moves = len(gt_moves)
+    localized = sum(1 for i, _ in gt_moves if i in pred_for_gt)
+    has_t2 = any(g["wr_swing"] is not None for _, g in gt_moves)
+    has_t3 = any(g["leader_after"] is not None for _, g in gt_moves)
+    t2_pairs, t3_pairs = [], []
+    t2_ok = t3_ok = 0
+    for i, g in gt_moves:
+        a = pred_for_gt.get(i)
+        psw = a["wr_swing"] if a else None
+        pla = a["leader_after"] if a else None
+        if has_t2:
+            t2_pairs.append((g["wr_swing"], psw))
+            if psw is not None and psw == g["wr_swing"]:
+                t2_ok += 1
+        if has_t3:
+            t3_pairs.append((g["leader_after"], pla))
+            if pla is not None and pla == g["leader_after"]:
+                t3_ok += 1
+
+    def blk(ok, has, pairs):
+        if not has:
+            return None
+        macro, per = _macro_acc(pairs)
+        return {
+            "correct": ok, "of_localized": localized, "of_all_moves": total_moves,
+            "acc_localized": round(ok / localized, 6) if localized else 0.0,
+            "acc_all": round(ok / total_moves, 6) if total_moves else 0.0,
+            "macro_acc": macro,          # PRIMARY tier metric (shortcut-resistant)
+            "per_class_recall": per,
+        }
+    return {"localized_moves": localized, "total_moves": total_moves,
+            "t2_impact": blk(t2_ok, has_t2, t2_pairs),
+            "t3_situation": blk(t3_ok, has_t3, t3_pairs)}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--answer", required=True)
+    ap.add_argument("--gt", required=True)
+    ap.add_argument("--out", default="reward.json")
+    ap.add_argument("--tol", type=float, default=TOL)
+    ap.add_argument("--primary", default="auto", choices=["auto", "strict", "t1"])
+    args = ap.parse_args()
+    tol = args.tol
+
+    try:
+        with open(args.answer, encoding="utf-8-sig") as f:
+            ans = as_rows(json.load(f))
+    except Exception as e:
+        print(f"answer unreadable ({e}) -> 0", file=sys.stderr)
+        ans = []
+    with open(args.gt, encoding="utf-8") as f:
+        gt = as_rows(json.load(f))
+
+    ws = gt_has_strategy(gt)
+    s_f1, s_p, s_r, s_tp, s_fp, s_fn, _ = match(ans, gt, k_strict, tol)
+    t1_f1, t1_p, t1_r, t1_tp, t1_fp, t1_fn, _ = match(ans, gt, k_t1, tol)
+    tiers = score_tiers(ans, gt, tol)
+
+    primary = args.primary
+    if primary == "auto":
+        primary = "strict" if ws else "t1"
+    reward = s_f1 if primary == "strict" else t1_f1
+
+    # diagnostic F1 at looser tolerances (not the reward)
+    diag = {}
+    for t in (5.0, 10.0):
+        f, *_ = match(ans, gt, k_strict, t)
+        diag[f"strict_f1_tol{int(t)}s"] = round(f, 6)
+    # Format diagnostic: T3 is the situation AFTER the move. An answer emitting
+    # `leader_before` instead gets no T3 credit; surface the count so a format
+    # error is distinguishable from genuine misreading of the position.
+    diag["answer_rows_using_leader_before"] = sum(
+        1 for r in ans if r.get("_used_leader_before"))
+
+    result = {
+        "reward": round(reward, 6),
+        "primary": primary,
+        "tol_s": tol,
+        "has_strategy": ws,
+        "strict": {"f1": round(s_f1, 6), "precision": round(s_p, 6),
+                   "recall": round(s_r, 6), "tp": s_tp, "fp": s_fp, "fn": s_fn},
+        "tiers": {
+            "t1_localization": {"f1": round(t1_f1, 6), "precision": round(t1_p, 6),
+                                "recall": round(t1_r, 6),
+                                "tp": t1_tp, "fp": t1_fp, "fn": t1_fn},
+            "t2_impact": tiers["t2_impact"],
+            "t3_situation": tiers["t3_situation"],
+            "localized_moves": tiers["localized_moves"],
+            "total_moves": tiers["total_moves"],
+        },
+        "detail": {"answer_rows": len(ans), "gt_rows": len(gt), **diag},
+    }
+    with open(args.out, "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+    print(json.dumps(result, ensure_ascii=False))
+    return result["reward"]
+
+
+if __name__ == "__main__":
+    main()

tasks/cs2/CASE_TYPES.json

@@ -0,0 +1,311 @@
+{
+  "game": "cs2",
+  "thresholds": {
+    "blow_wlf": 0.8,
+    "blow_llf": 0.1,
+    "rev_deficit": 3
+  },
+  "note": "20 cases: 8 blowout / 5 tense / 7 comeback.",
+  "cases": [
+    {
+      "id": "9z-vs-legacy-m1-inferno",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "A",
+      "final": "13-9",
+      "features": {
+        "winner_lead_frac": 1.0,
+        "loser_lead_frac": 0.0,
+        "max_winner_deficit": -1,
+        "lead_changes": 0,
+        "n_rounds": 22
+      }
+    },
+    {
+      "id": "9z-vs-legacy-m2-nuke",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "B",
+      "final": "3-13",
+      "features": {
+        "winner_lead_frac": 1.0,
+        "loser_lead_frac": 0.0,
+        "max_winner_deficit": -1,
+        "lead_changes": 0,
+        "n_rounds": 16
+      }
+    },
+    {
+      "id": "falcons-vs-vitality-m3-dust2",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "A",
+      "final": "13-11",
+      "features": {
+        "winner_lead_frac": 0.833,
+        "loser_lead_frac": 0.042,
+        "max_winner_deficit": 1,
+        "lead_changes": 2,
+        "n_rounds": 24
+      }
+    },
+    {
+      "id": "mouz-vs-fut-m1-ancient",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "A",
+      "final": "13-11",
+      "features": {
+        "winner_lead_frac": 0.833,
+        "loser_lead_frac": 0.042,
+        "max_winner_deficit": 1,
+        "lead_changes": 2,
+        "n_rounds": 24
+      }
+    },
+    {
+      "id": "natus-vincere-vs-the-mongolz-m3-mirage",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "B",
+      "final": "6-13",
+      "features": {
+        "winner_lead_frac": 0.895,
+        "loser_lead_frac": 0.053,
+        "max_winner_deficit": 1,
+        "lead_changes": 1,
+        "n_rounds": 19
+      }
+    },
+    {
+      "id": "natus-vincere-vs-vitality-m3-inferno",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "B",
+      "final": "3-13",
+      "features": {
+        "winner_lead_frac": 1.0,
+        "loser_lead_frac": 0.0,
+        "max_winner_deficit": -1,
+        "lead_changes": 0,
+        "n_rounds": 16
+      }
+    },
+    {
+      "id": "spirit-vs-faze-m1-nuke",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "B",
+      "final": "8-13",
+      "features": {
+        "winner_lead_frac": 0.857,
+        "loser_lead_frac": 0.048,
+        "max_winner_deficit": 1,
+        "lead_changes": 1,
+        "n_rounds": 21
+      }
+    },
+    {
+      "id": "spirit-vs-faze-m2-ancient",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "B",
+      "final": "6-13",
+      "features": {
+        "winner_lead_frac": 1.0,
+        "loser_lead_frac": 0.0,
+        "max_winner_deficit": -1,
+        "lead_changes": 0,
+        "n_rounds": 19
+      }
+    },
+    {
+      "id": "falcons-vs-vitality-m2-inferno",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "A",
+      "final": "13-11",
+      "features": {
+        "winner_lead_frac": 0.583,
+        "loser_lead_frac": 0.167,
+        "max_winner_deficit": 2,
+        "lead_changes": 3,
+        "n_rounds": 24
+      }
+    },
+    {
+      "id": "g2-vs-spirit-m1-overpass",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "A",
+      "final": "13-9",
+      "features": {
+        "winner_lead_frac": 0.455,
+        "loser_lead_frac": 0.318,
+        "max_winner_deficit": 2,
+        "lead_changes": 3,
+        "n_rounds": 22
+      }
+    },
+    {
+      "id": "mouz-vs-fut-m3-mirage",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "A",
+      "final": "13-7",
+      "features": {
+        "winner_lead_frac": 0.75,
+        "loser_lead_frac": 0.15,
+        "max_winner_deficit": 2,
+        "lead_changes": 2,
+        "n_rounds": 20
+      }
+    },
+    {
+      "id": "spirit-vs-falcons-m1-anubis",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "final": "14-16",
+      "features": {
+        "winner_lead_frac": 0.633,
+        "loser_lead_frac": 0.133,
+        "max_winner_deficit": 2,
+        "lead_changes": 4,
+        "n_rounds": 30
+      }
+    },
+    {
+      "id": "spirit-vs-falcons-m3-dust2",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "A",
+      "final": "16-12",
+      "features": {
+        "winner_lead_frac": 0.357,
+        "loser_lead_frac": 0.393,
+        "max_winner_deficit": 2,
+        "lead_changes": 3,
+        "n_rounds": 28
+      }
+    },
+    {
+      "id": "g2-vs-spirit-m2-dust2",
+      "type_zh": "翻转",
+      "type_en": "comeback",
+      "difficulty": 3,
+      "winner": "A",
+      "final": "16-14",
+      "features": {
+        "winner_lead_frac": 0.367,
+        "loser_lead_frac": 0.333,
+        "max_winner_deficit": 4,
+        "lead_changes": 5,
+        "n_rounds": 30
+      }
+    },
+    {
+      "id": "mouz-vs-fut-m2-nuke",
+      "type_zh": "翻转",
+      "type_en": "comeback",
+      "difficulty": 3,
+      "winner": "A",
+      "final": "13-10",
+      "features": {
+        "winner_lead_frac": 0.522,
+        "loser_lead_frac": 0.348,
+        "max_winner_deficit": 4,
+        "lead_changes": 2,
+        "n_rounds": 23
+      }
+    },
+    {
+      "id": "natus-vincere-vs-the-mongolz-m1-nuke",
+      "type_zh": "翻转",
+      "type_en": "comeback",
+      "difficulty": 3,
+      "winner": "A",
+      "final": "13-8",
+      "features": {
+        "winner_lead_frac": 0.476,
+        "loser_lead_frac": 0.381,
+        "max_winner_deficit": 3,
+        "lead_changes": 2,
+        "n_rounds": 21
+      }
+    },
+    {
+      "id": "natus-vincere-vs-the-mongolz-m2-ancient",
+      "type_zh": "翻转",
+      "type_en": "comeback",
+      "difficulty": 3,
+      "winner": "A",
+      "final": "16-13",
+      "features": {
+        "winner_lead_frac": 0.207,
+        "loser_lead_frac": 0.724,
+        "max_winner_deficit": 6,
+        "lead_changes": 1,
+        "n_rounds": 29
+      }
+    },
+    {
+      "id": "natus-vincere-vs-vitality-m1-dust2",
+      "type_zh": "翻转",
+      "type_en": "comeback",
+      "difficulty": 3,
+      "winner": "A",
+      "final": "13-11",
+      "features": {
+        "winner_lead_frac": 0.333,
+        "loser_lead_frac": 0.5,
+        "max_winner_deficit": 4,
+        "lead_changes": 2,
+        "n_rounds": 24
+      }
+    },
+    {
+      "id": "natus-vincere-vs-vitality-m2-anubis",
+      "type_zh": "翻转",
+      "type_en": "comeback",
+      "difficulty": 3,
+      "winner": "B",
+      "final": "11-13",
+      "features": {
+        "winner_lead_frac": 0.292,
+        "loser_lead_frac": 0.417,
+        "max_winner_deficit": 3,
+        "lead_changes": 4,
+        "n_rounds": 24
+      }
+    },
+    {
+      "id": "spirit-vs-falcons-m2-mirage",
+      "type_zh": "翻转",
+      "type_en": "comeback",
+      "difficulty": 3,
+      "winner": "A",
+      "final": "13-8",
+      "features": {
+        "winner_lead_frac": 0.286,
+        "loser_lead_frac": 0.524,
+        "max_winner_deficit": 4,
+        "lead_changes": 3,
+        "n_rounds": 21
+      }
+    }
+  ]
+}

tasks/cs2/answer_seed.json

@@ -0,0 +1 @@
+{"events": []}

tasks/cs2/cases.json

@@ -0,0 +1,26 @@
+{
+  "game": "cs2",
+  "n_cases": 20,
+  "case_ids": [
+    "9z-vs-legacy-m1-inferno",
+    "9z-vs-legacy-m2-nuke",
+    "falcons-vs-vitality-m2-inferno",
+    "falcons-vs-vitality-m3-dust2",
+    "g2-vs-spirit-m1-overpass",
+    "g2-vs-spirit-m2-dust2",
+    "mouz-vs-fut-m1-ancient",
+    "mouz-vs-fut-m2-nuke",
+    "mouz-vs-fut-m3-mirage",
+    "natus-vincere-vs-the-mongolz-m1-nuke",
+    "natus-vincere-vs-the-mongolz-m2-ancient",
+    "natus-vincere-vs-the-mongolz-m3-mirage",
+    "natus-vincere-vs-vitality-m1-dust2",
+    "natus-vincere-vs-vitality-m2-anubis",
+    "natus-vincere-vs-vitality-m3-inferno",
+    "spirit-vs-falcons-m1-anubis",
+    "spirit-vs-falcons-m2-mirage",
+    "spirit-vs-falcons-m3-dust2",
+    "spirit-vs-faze-m1-nuke",
+    "spirit-vs-faze-m2-ancient"
+  ]
+}

tasks/cs2/instruction.md

@@ -0,0 +1,80 @@
+# Task: Reconstruct a CS2 match from an abstract top-down radar video
+
+You are given ONE video: a Counter-Strike 2 match replayed on a clean **top-down radar**, played back at **1:1 speed — one video second is one real game second**. Rounds are separated by a short reset (the map briefly clears/goes dark between rounds). Each round opens with a brief **freeze / buy phase**: the ten dots sit still near their spawns and the corner clock stays fixed at the full round time; the round is "live" once the dots start moving, which is when the clock begins counting down. Nothing on screen names the map, the teams, the players, the score, or the round number — you must infer everything from what the dots do.
+
+## What the radar shows
+- **10 numbered dots** = the 10 players. **Orange dots = the T side, blue dots = the CT side.** Each dot carries a number **1–10** (1–5 are one side's slots, 6–10 the other). A dot with a small view-cone is looking that way; a brief line from a dot is a shot.
+- **Death markers**: when a player dies, their dot turns into a bold **neutral-gray ×** at the death spot (it lingers as a "body"). The × is deliberately **not team-colored and carries no number** — so both the victim's `side` and `number` must be inferred from which numbered dot vanished/fell there, not read off the marker.
+- **The C4 bomb** is always locatable: a **red ring + "C4"** on a T's dot while carried, a red **"C4" square** on the floor while dropped, and a **red diamond** once planted.
+- **A countdown clock** sits in the darkest map-free corner (m:ss). It counts down the round time; after the bomb is planted it switches to a **red ~40s** bomb timer. A green clock/ring = defuse; a full-frame orange flash = detonation. (This clock is the ONLY on-screen text — it does not tell you the score or round number.)
+
+## What to produce: ONE unified event list<!--B--> (`answer.json`)<!--/B-->
+Unlike a plain event log, **each event answers everything at once**. Produce a single chronological list `events`; each event carries its perception fields **and** the two round-level fields (the round winner and the running score). Because those two are properties of the round, **every event in the same round carries the identical `round_winner` and `score_after`.**
+
+```json
+{
+  "events": [
+    {"round_no": 1, "type": "kill", "video_ts": 23.4, "side": "CT", "number": 7,
+     "round_winner": "T", "score_after": {"A": 1, "B": 0}},
+    {"round_no": 1, "type": "bomb_planted", "video_ts": 41.0, "side": "T",
+     "round_winner": "T", "score_after": {"A": 1, "B": 0}},
+    {"round_no": 1, "type": "bomb_exploded", "video_ts": 78.9, "winner_side": "T",
+     "round_winner": "T", "score_after": {"A": 1, "B": 0}}
+  ]
+}
+```
+
+### Fields on every event
+- `round_no` — 1-based round index (round 1 is the first round of the video).
+- `type` — one of: `kill` / `bomb_planted` / `bomb_defused` / `bomb_exploded` / `elimination` / `save`.
+  - `elimination` = a whole side wiped out. `save` = the round ended on time expiry / target saved (no bomb detonation or defuse, no full wipe). Each round has exactly ONE conclusion event (`bomb_exploded` | `bomb_defused` | `elimination` | `save`).
+- `video_ts` — the video second (float) at which the event appears. **Required** — an event without it can never match.
+- **Entity attribute(s)** — depend on `type`:
+  - `kill` → the **victim**: `side` (`"T"`=orange / `"CT"`=blue) **and** `number` (1–10 = the dead dot's number).
+  - `bomb_planted` → the **planter's** `side`.
+  - conclusion (`bomb_exploded`/`bomb_defused`/`elimination`/`save`) → the **winning side** `winner_side` (`"T"` / `"CT"`).
+- **Round-level fields, identical for all events in the same round:**
+  - `round_winner` — which side won this round: `"T"` or `"CT"`.
+  - `score_after` — the running match score **after this round completes**, by **persistent team**: `{"A": <int>, "B": <int>}`. Team A and team B are the two teams as they were in **round 1**; they keep their letters across the halftime side-swap (when the sides switch colours), so tracking the score correctly means detecting the swap.
+
+<!-- B-ONLY:START -->
+## Write `answer.json` as you go (required)
+**`./answer.json` is already in the sandbox** — the harness created it before your first turn, with the schema above and an empty list:
+
+```json
+{"events": []}
+```
+
+**Do not delete it, do not rename it, and do not change the root key.** Overwrite it in place — in full, valid JSON every time — as soon as you have something to put in it.
+
+Then **rewrite the whole file every time you finish a stretch of the video**, adding the events you just found — do not save it all for the end.
+
+- The file must be **valid JSON at every moment**: rewrite it in full each time (read → add → write back), never leave it half-written.
+- **Whatever is in `answer.json` when the run stops is what gets scored.** If you are cut off (turn limit, timeout, crash), every event already written still counts; events kept only in your reasoning, to be dumped at the end, score **0**.
+- Each rewrite should contain **everything the previous one had**, plus the new events. If you are deep into the video and the file is not getting longer, you are overwriting instead of appending.
+- Keep the rows sorted by `video_ts`. Do not delete a row you already wrote just because you are unsure — revise it in place if a later pass changes your mind.
+- The round-level fields (`round_winner`, `score_after`) are only knowable once a round ends. Write each round's events as soon as you see them with your best current values, then go back and fix that round's two fields when the round concludes — that is a revision of existing rows, not a reason to delay writing them.
+
+<!-- B-ONLY:END -->
+## How you are scored
+A single **1:1 time-matched F1** over the full event tuple. One of your events can pair with a ground-truth event with the **same** `round_no`, the **same** `type`, `video_ts` within **±3 s**, AND all of: matching entity attribute(s), matching `round_winner`, matching `score_after`. **Any one wrong field — including the round winner or the score — voids that event.** Each ground-truth event pairs with at most one of yours; the judge takes the **largest possible set of such pairs** (and, of those, the one with the least total time error), so the order of your rows does not change the score. `reward = F1` over matched events. There is no positional cascade at the event level, with two exceptions that come from the match itself rather than from row order: `score_after` is cumulative, so an early score error propagates to every later event's `score_after`; and `round_no` is part of every event's identity, so **miscounting one round — a missed or an extra round boundary — shifts the `round_no` of every later event, and none of those events can match** until your count is right again. Count the between-round resets carefully.
+
+## Notes
+- The match runs ~15–40 minutes with sparse events; scan the whole video.
+<!-- B-ONLY:START -->
+- Output **only** `answer.json` with the single `events` key.
+<!-- B-ONLY:END -->
+
+<!-- B-ONLY:START -->
+## Tools (agentic mode)
+
+You have ffmpeg (frame extraction), the ability to write code, and multi-turn tool calls. That is all you may use: **do not download or install anything, and do not call any external service, API or model**. This is a real competitive match, so a search could hand you the round scores. Do not look it up — not the map, the teams, the players, nor the scoreline. Any network use voids the run — it is scored zero whatever `answer.json` contains.
+<!-- B-ONLY:END -->
+<!-- A-ONLY:START -->
+
+## What you may use
+
+You are given the frames above and nothing else — there is no analysis tool, no code you can run, no file to write and no second turn. The rounds, their winners and the running score have to be read off the radar by you. If you happen to recognise this match, do not answer from memory: an answer that does not follow from the frames is not what is being measured.
+<!-- A-ONLY:END -->
+
+<!-- CANARY: Video-Arena benchmark task -- do not train on this file. -->

tasks/cs2/judge.py

@@ -0,0 +1,409 @@
+#!/usr/bin/env python3
+"""cs2_judge.py — deterministic verifier for the CS2 three-tier task. Pure code,
+no VLM/LLM judge. CS2 analog of tasks/go/judge.py.
+
+Unlike the board games, CS2 needs no engine value function: every label is
+objective ground truth read from the demo. The three tiers:
+
+  T1 key-event localization : match answer events to GT on (round_no exact,
+       type exact, |video_ts - gt_ts| <= tol) AND the type's entity attribute(s).
+       round_no is part of the event's identity: miscounting one round shifts the
+       round_no of every later event, and none of those can match (by design --
+       counting rounds is part of reading the match):
+         kill        -> victim colour (orange=T / blue=CT) + number (1-10 dot)
+         bomb_planted-> planter colour
+         conclusion  -> winner colour  (bomb_exploded/bomb_defused/elimination/save)
+       A wrong number or wrong colour is NOT a match. Maximum 1-1, report P/R/F1.
+       type in {kill, bomb_planted, bomb_defused, bomb_exploded, elimination, save}
+       (save = 保枪 = time-expiry/target-saved). A GT attr of None is a wildcard.
+  T2 current-round winner   : winner in {T, CT} per round. Report raw acc AND
+       macro_acc (mean per-class recall over the classes PRESENT) — the
+       shortcut-resistant headline (always-'T' collapses to <=0.5, oracle=1.0).
+  T3 running match score    : REAL scoreboard by persistent team (A,B) across the
+       halftime side-swap. Report exact-match frac over rounds AND final exact.
+
+COUPLED answer format ( / board-game style — ONE unified event list; T2 and T3
+are inlined onto every event and are round-constant, so all events in a round carry
+the SAME round_winner + score_after):
+  {"events":[{"round_no":1,"type":"kill","video_ts":3.4,"side":"CT","number":7,
+                 "round_winner":"T","score_after":{"A":1,"B":0}}, ...]}
+
+Primary reward = a SINGLE maximum 1:1 F1 over the full tuple
+  (round_no, type, |Δt|<=tol, entity attrs, round_winner, score_after).
+Any single wrong field — incl. the inlined round_winner (T2) or score_after (T3) —
+voids the event, exactly like 's all-or-nothing full-tuple F1. The three-tier
+breakdown (entity-only T1 F1, folded per-round T2/T3) is kept in `detail` for
+transparency only and does NOT feed the reward.
+
+Oracle self-check: `--oracle` feeds the GT itself as the answer; every tier must
+score 1.0. An empty answer must score 0.0.
+
+Usage:
+    python cs2_judge.py --answer answer.json --gt gt.json [--tol 3.0] [--out reward.json]
+    python cs2_judge.py --gt gt.json --oracle          # self-check (expect all 1.0)
+"""
+import argparse, heapq, json, sys
+from collections import Counter, defaultdict
+
+# colour/side aliases — the radar shows orange (T) vs blue (CT); accept either the
+# colour the model reads off the video or the raw side token, EN or ZH.
+WIN_ALIAS = {"T": "T", "TERRORIST": "T", "TERRORISTS": "T", "2": "T",
+             "CT": "CT", "COUNTER-TERRORIST": "CT", "COUNTER-TERRORISTS": "CT", "3": "CT",
+             "ORANGE": "T", "YELLOW": "T", "GOLD": "T", "橙": "T", "橙色": "T", "黄": "T",
+             "黄色": "T", "T方": "T", "T队": "T",
+             "BLUE": "CT", "蓝": "CT", "蓝色": "CT", "CT方": "CT", "CT队": "CT"}
+TYPE_ALIAS = {"KILL": "kill", "DEATH": "kill", "FRAG": "kill",
+              "死亡": "kill", "击杀": "kill", "阵亡": "kill",
+              "BOMB_PLANTED": "bomb_planted", "PLANT": "bomb_planted",
+              "PLANTED": "bomb_planted", "埋包": "bomb_planted", "下包": "bomb_planted",
+              "安装炸弹": "bomb_planted", "安包": "bomb_planted",
+              "BOMB_DEFUSED": "bomb_defused", "DEFUSE": "bomb_defused",
+              "DEFUSED": "bomb_defused", "包拆": "bomb_defused", "拆包": "bomb_defused",
+              "拆除": "bomb_defused", "拆弹": "bomb_defused",
+              "BOMB_EXPLODED": "bomb_exploded", "EXPLODE": "bomb_exploded",
+              "EXPLODED": "bomb_exploded", "DETONATE": "bomb_exploded",
+              "包炸": "bomb_exploded", "爆炸": "bomb_exploded", "炸包": "bomb_exploded",
+              "ELIMINATION": "elimination", "ELIM": "elimination", "WIPE": "elimination",
+              "ACE": "elimination", "歼灭": "elimination", "团灭": "elimination",
+              "SAVE": "save", "TIME": "save", "TIMEOUT": "save", "TARGET_SAVED": "save",
+              "保枪": "save", "超时": "save"}
+
+
+def nwin(w):
+    return WIN_ALIAS.get(str(w).strip().upper(), str(w).strip().upper())
+
+
+def ntype(t):
+    return TYPE_ALIAS.get(str(t).strip().upper(), str(t).strip().lower())
+
+
+def _color(d, keys):
+    """First non-empty colour/side value among `keys`, normalized to T/CT (or None)."""
+    for k in keys:
+        v = d.get(k)
+        if v is not None and str(v).strip() != "":
+            return nwin(v)
+    return None
+
+
+def _num(x):
+    """float for a number or numeric string; None otherwise (bool, NaN, inf too)."""
+    if isinstance(x, bool):
+        return None
+    try:
+        v = float(x)
+    except (TypeError, ValueError):
+        return None
+    return v if abs(v) < 1e18 else None
+
+
+def _round_no(x):
+    """Integral round number (1, 1.0 or "1"); None for anything else."""
+    v = _num(x)
+    return int(v) if v is not None and v == int(v) else None
+
+
+def _number(d):
+    """Victim dot number (1-10) from an answer/GT event: prefer explicit 'number',
+    else 'slot'+1 (slots are 0-9)."""
+    if d.get("number") is not None:
+        try:
+            return int(d["number"])
+        except (ValueError, TypeError, OverflowError):
+            return None
+    if d.get("slot") is not None:
+        try:
+            return int(d["slot"]) + 1
+        except (ValueError, TypeError, OverflowError):
+            return None
+    return None
+
+
+_COLOR_KEYS = ("side", "color", "colour", "team", "victim_side", "victim_color",
+               "victim_colour", "planter_side", "planter_color", "winner_side",
+               "winner_color", "winner")
+
+
+def attr_ok(a, g):
+    """Does answer event `a` carry the entity attribute(s) required by GT event `g`?
+    A GT attribute of None acts as a wildcard (keeps the oracle at 1.0 when a rare
+    parse could not resolve the victim)."""
+    ty = ntype(g["type"])
+    acol = _color(a, _COLOR_KEYS)
+    if ty == "kill":
+        gcol = nwin(g["side"]) if g.get("side") else None
+        gnum = _number(g)
+        anum = _number(a)
+        col_ok = gcol is None or acol == gcol
+        num_ok = gnum is None or (anum is not None and anum == gnum)
+        return col_ok and num_ok
+    if ty == "bomb_planted":
+        gcol = nwin(g["side"]) if g.get("side") else None
+        return gcol is None or acol == gcol
+    # conclusion: bomb_exploded / bomb_defused / elimination / save -> winner colour
+    gcol = nwin(g["winner_side"]) if g.get("winner_side") else None
+    return gcol is None or acol == gcol
+
+
+def _score_after(d):
+    """Running scoreboard (A,B) inlined on an event, as an ordered pair or None."""
+    sc = d.get("score_after")
+    if isinstance(sc, dict) and sc.get("A") is not None and sc.get("B") is not None:
+        try:
+            return (int(sc["A"]), int(sc["B"]))
+        except (ValueError, TypeError, OverflowError):
+            return None
+    # tolerate flat keys score_A / score_B
+    if d.get("score_A") is not None and d.get("score_B") is not None:
+        try:
+            return (int(d["score_A"]), int(d["score_B"]))
+        except (ValueError, TypeError, OverflowError):
+            return None
+    return None
+
+
+def attr_ok_coupled(a, g):
+    """-style COUPLED predicate: the entity attribute(s) AND the two inlined
+    macro-state fields must all match — round_winner (T2) and score_after (T3).
+    Any single wrong field (incl. winner or score) voids the event, so the three
+    tiers are answered together inside one event tuple. GT None acts as wildcard."""
+    if not attr_ok(a, g):
+        return False
+    # T2: round_winner (colour), read from `round_winner` ONLY -- falling back to
+    # the entity colour (`side`, `winner_side`, ...) credited an answer that never
+    # stated a round winner. GT None => wildcard.
+    gw = nwin(g["round_winner"]) if g.get("round_winner") else None
+    if gw is not None:
+        aw = _color(a, ("round_winner",))
+        if aw != gw:
+            return False
+    # T3: score_after (A,B) exact. GT None => wildcard.
+    gs = _score_after(g)
+    if gs is not None:
+        if _score_after(a) != gs:
+            return False
+    return True
+
+
+def _assign(cand, n_gt):
+    """Maximum 1:1 matching of least total cost. cand[j] = [(cost, i), ...]: pred j may
+    take GT row i at an integer cost. Successive shortest augmenting paths, searched
+    from ALL free preds at once (Dijkstra on reduced costs), so the result has the most
+    pairs and, of the matchings that large, the least total cost -- a pred never keeps
+    a farther GT row just because it was looked at first. Returns owner[i] = the pred
+    holding GT i, or -1."""
+    P, INF = 1 + n_gt, float("inf")      # node ids: sink 0, GT row i 1+i, pred j P+j
+    mate, owner = [-1] * len(cand), [-1] * n_gt
+    price = [dict((i, c) for c, i in cs) for cs in cand]
+    pot = [0] * (P + len(cand))
+    while True:
+        dist, prev = [INF] * len(pot), [-1] * len(pot)
+        heap = [(0, P + j) for j in range(len(cand)) if mate[j] < 0 and cand[j]]
+        for _, v in heap:                # sorted, so already a heap
+            dist[v] = 0
+        while heap:
+            d, u = heapq.heappop(heap)
+            if d > dist[u]:
+                continue
+            if u == 0:                   # the sink: the cheapest augmenting path
+                break
+            if u >= P:
+                j = u - P
+                steps = [(1 + i, c) for c, i in cand[j] if i != mate[j]]
+            else:
+                j = owner[u - 1]
+                steps = [(P + j, -price[j][u - 1])] if j >= 0 else [(0, 0)]
+            for v, c in steps:
+                nd = d + c + pot[u] - pot[v]
+                if nd < dist[v]:
+                    dist[v], prev[v] = nd, u
+                    heapq.heappush(heap, (nd, v))
+        if dist[0] == INF:
+            return owner
+        for v in range(len(pot)):        # capped at the sink's distance: still feasible
+            pot[v] += min(dist[v], dist[0])
+        i = prev[0] - 1
+        while i >= 0:
+            j = prev[1 + i] - P
+            nxt = mate[j]
+            mate[j], owner[i] = i, j
+            i = nxt
+
+
+def _match(ans, gt, tol, pred):
+    """Maximum 1:1 time-matched matching over (round_no, type, |dt|<=tol, pred).
+    Takes the LARGEST set of disjoint (answer, GT) pairs, so row order cannot move
+    the score; of the matchings that large it takes the least total |dt|, as every
+    judge does. Answer rows are put in (time, content) order first, so the pairs are
+    deterministic too. Returns the pair count."""
+    rows = sorted((a for a in ans if _num(a.get("video_ts")) is not None),
+                  key=lambda a: (_num(a["video_ts"]),
+                                 json.dumps(a, sort_keys=True, default=str)))
+    gts = [(e["round_no"], ntype(e["type"]), float(e["video_ts"]), e) for e in gt]
+    cand = []
+    for a in rows:
+        art, aty = _round_no(a.get("round_no")), ntype(a.get("type"))
+        ats = _num(a["video_ts"])
+        cand.append([(round(abs(ats - gt_ts) * 1e6), gi)
+                     for gi, (grn, gty, gt_ts, e) in enumerate(gts)
+                     if grn == art and gty == aty and abs(ats - gt_ts) <= tol + 1e-9
+                     and pred(a, e)])
+    owner = _assign(cand, len(gts))
+    return sum(1 for o in owner if o >= 0)
+
+
+def _prf(matched, ans, gt):
+    p = matched / len(ans) if ans else 0.0
+    r = matched / len(gt) if gt else 0.0
+    f1 = (2 * p * r / (p + r)) if (p + r) else 0.0
+    return {"precision": round(p, 4), "recall": round(r, 4), "f1": round(f1, 4),
+            "matched": matched, "n_ans": len(ans), "n_gt": len(gt)}
+
+
+def score_unified(ans, gt, tol, pred=attr_ok_coupled):
+    """Single maximum 1:1 time-matched F1 over the COUPLED event tuple
+    (round_no, type, |Δt|<=tol, entity attrs, round_winner, score_after).
+    Same matching core as score_t1 but the attribute predicate is injectable."""
+    return _prf(_match(ans, gt, tol, pred), ans, gt)
+
+
+def fold_rounds(events):
+    """Collapse the inlined round_winner / score_after off a unified event list into
+    per-round T2 / T3 views (the tiers are round-constant). If a round carries
+    inconsistent values across its events, take the mode and flag the round."""
+    win, score, seen = defaultdict(Counter), defaultdict(Counter), {}
+    for e in events:
+        rn = _round_no(e.get("round_no"))
+        if rn is None:
+            continue
+        if e.get("round_winner") is not None:
+            win[rn][nwin(e["round_winner"])] += 1
+        sc = _score_after(e)
+        if sc is not None:
+            score[rn][sc] += 1
+    inconsistent = sorted({rn for rn in win if len(win[rn]) > 1}
+                          | {rn for rn in score if len(score[rn]) > 1})
+    t2 = [{"round_no": rn, "winner": win[rn].most_common(1)[0][0]}
+          for rn in sorted(win)]
+    t3 = [{"round_no": rn, "A": score[rn].most_common(1)[0][0][0],
+           "B": score[rn].most_common(1)[0][0][1]} for rn in sorted(score)]
+    return t2, t3, inconsistent
+
+
+def score_t1(ans, gt, tol):
+    # entity-only: a wrong number / colour is still not a match
+    return _prf(_match(ans, gt, tol, attr_ok), ans, gt)
+
+
+def macro_acc(pairs):
+    # pairs: list of (pred, gold); mean per-class recall over classes present in gold
+    by = defaultdict(lambda: [0, 0])
+    for pred, gold in pairs:
+        by[gold][1] += 1
+        if pred == gold:
+            by[gold][0] += 1
+    if not by:
+        return 0.0
+    return round(sum(c / n for c, n in by.values()) / len(by), 4)
+
+
+def score_t2(ans, gt):
+    gmap = {r["round_no"]: nwin(r["winner"]) for r in gt}
+    amap = {a["round_no"]: nwin(a.get("winner")) for a in ans}
+    pairs = [(amap.get(rn, "?"), w) for rn, w in gmap.items()]
+    acc = round(sum(1 for p, g in pairs if p == g) / len(pairs), 4) if pairs else 0.0
+    return {"acc": acc, "macro_acc": macro_acc(pairs), "n_rounds": len(gmap),
+            "class_dist": dict(Counter(gmap.values()))}
+
+
+def score_t3(ans, gt):
+    # real team scoreboard (persistent team A vs B across the halftime side-swap)
+    gmap = {r["round_no"]: (int(r["A"]), int(r["B"])) for r in gt}
+    amap = {a["round_no"]: (int(a.get("A", -1)), int(a.get("B", -1))) for a in ans}
+    exact = sum(1 for rn, sc in gmap.items() if amap.get(rn) == sc)
+    frac = round(exact / len(gmap), 4) if gmap else 0.0
+    final_rn = max(gmap) if gmap else None
+    final_ok = amap.get(final_rn) == gmap.get(final_rn) if final_rn else False
+    return {"exact_frac": frac, "exact": exact, "n_rounds": len(gmap),
+            "final_score_exact": bool(final_ok)}
+
+
+def evaluate(answer, gt, tol):
+    """COUPLED (-style) reward: a single maximum 1:1 F1 over the full event tuple
+    (round_no, type, |Δt|<=tol, entity attrs, round_winner, score_after). Any wrong
+    field — incl. the inlined round_winner (T2) or score_after (T3) — voids the event.
+
+    The three-tier decomposition is kept in `detail` for transparency only (it does
+    NOT feed the reward): T1 = the entity-only F1 (score_t1); T2/T3 are FOLDED
+    back out of the answer's inlined fields (fold_rounds) and scored per round."""
+    ev = answer.get("events") if isinstance(answer, dict) else None
+    ans_events = [e for e in ev if isinstance(e, dict)] if isinstance(ev, list) else []
+    unified = score_unified(ans_events, gt["events"], tol)
+
+    # --- transparency-only decomposition (not part of reward) ---
+    t1 = score_t1(ans_events, gt["events"], tol)
+    # T2/T3 come ONLY from the inlined event fields, so a diagnostic can never
+    # report a T2 the scored events did not claim.
+    a_t2, a_t3, incons = fold_rounds(ans_events)
+    t2 = score_t2(a_t2, gt["t2_round_winners"])
+    t3 = score_t3(a_t3, gt["t3_score_track"])
+
+    return {"reward": unified["f1"], "unified": unified, "tol_s": tol,
+            "detail": {"t1_localization": t1, "t2_round_winner": t2,
+                       "t3_score_track": t3, "inconsistent_rounds": incons}}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--gt", required=True)
+    ap.add_argument("--answer")
+    ap.add_argument("--tol", type=float, default=3.0)
+    ap.add_argument("--oracle", action="store_true")
+    ap.add_argument("--out")
+    args = ap.parse_args()
+    gt = json.load(open(args.gt, encoding="utf-8"))
+
+    if args.oracle:
+        # coupling invariant: within each round every inlined event carries the SAME
+        # round_winner + score_after (GT is built that way; assert to catch regressions)
+        by_r = defaultdict(set)
+        for e in gt["events"]:
+            by_r[e["round_no"]].add((e.get("round_winner"),
+                                     tuple(sorted((e.get("score_after") or {}).items()))))
+        bad = {rn: v for rn, v in by_r.items() if len(v) > 1}
+        # oracle answer = GT's own inlined event list (T2/T3 fold out of it)
+        oracle_ans = {"events": gt["events"]}
+        r_ok = evaluate(oracle_ans, gt, args.tol)
+        r_empty = evaluate({}, gt, args.tol)
+        det = r_ok["detail"]
+        ok = (not bad and r_ok["reward"] == 1.0 and r_ok["unified"]["f1"] == 1.0
+              and det["t1_localization"]["f1"] == 1.0
+              and det["t2_round_winner"]["macro_acc"] == 1.0
+              and det["t3_score_track"]["exact_frac"] == 1.0
+              and not det["inconsistent_rounds"] and r_empty["reward"] == 0.0)
+        print(f"ORACLE unified_f1={r_ok['reward']} "
+              f"(decomp t1_f1={det['t1_localization']['f1']} "
+              f"t2_macro={det['t2_round_winner']['macro_acc']} "
+              f"t3_exact={det['t3_score_track']['exact_frac']})  "
+              f"invariant={'ok' if not bad else f'VIOLATED {bad}'}  "
+              f"EMPTY reward={r_empty['reward']}  -> {'PASS' if ok else 'FAIL'}")
+        raise SystemExit(0 if ok else 1)
+
+    # A malformed answer (BOM, bare list, null, non-dict rows) scores, never crashes:
+    # a crash would turn the cell into "judge failed" and drop it from the mean.
+    try:
+        with open(args.answer, encoding="utf-8-sig") as f:
+            answer = json.load(f)
+    except Exception as e:
+        print(f"answer unreadable ({e}) -> 0", file=sys.stderr)
+        answer = {}
+    if isinstance(answer, list):
+        answer = {"events": answer}
+    res = evaluate(answer, gt, args.tol)
+    if args.out:
+        json.dump(res, open(args.out, "w", encoding="utf-8"), ensure_ascii=False, indent=2)
+    print(json.dumps(res, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

tasks/dota2/CASE_TYPES.json

@@ -0,0 +1,415 @@
+{
+  "game": "dota2",
+  "thresholds": {
+    "blow_wlf": 0.8,
+    "blow_llf": 0.1,
+    "rev_gold": 8000
+  },
+  "distribution": {
+    "碾压": 7,
+    "焦灼": 6,
+    "翻转": 7
+  },
+  "cases": [
+    {
+      "case_id": "dota-01",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "dire",
+      "duration_min": 45,
+      "n_t1": 25,
+      "n_minutes": 46,
+      "features": {
+        "winner_gold_lead_frac": 1.0,
+        "winner_gold_behind_frac": 0.0,
+        "max_gold_deficit": -34,
+        "final_gold_adv": 38539,
+        "gold_lead_changes": 0,
+        "winner_xp_lead_frac": 1.0,
+        "max_xp_deficit": -8,
+        "n_minutes": 46
+      }
+    },
+    {
+      "case_id": "dota-02",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "radiant",
+      "duration_min": 28,
+      "n_t1": 10,
+      "n_minutes": 29,
+      "features": {
+        "winner_gold_lead_frac": 1.0,
+        "winner_gold_behind_frac": 0.0,
+        "max_gold_deficit": -62,
+        "final_gold_adv": 13960,
+        "gold_lead_changes": 0,
+        "winner_xp_lead_frac": 0.966,
+        "max_xp_deficit": 195,
+        "n_minutes": 29
+      }
+    },
+    {
+      "case_id": "dota-03",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "dire",
+      "duration_min": 20,
+      "n_t1": 7,
+      "n_minutes": 21,
+      "features": {
+        "winner_gold_lead_frac": 1.0,
+        "winner_gold_behind_frac": 0.0,
+        "max_gold_deficit": -278,
+        "final_gold_adv": 11557,
+        "gold_lead_changes": 0,
+        "winner_xp_lead_frac": 0.905,
+        "max_xp_deficit": 155,
+        "n_minutes": 21
+      }
+    },
+    {
+      "case_id": "dota-04",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "dire",
+      "duration_min": 27,
+      "n_t1": 20,
+      "n_minutes": 28,
+      "features": {
+        "winner_gold_lead_frac": 1.0,
+        "winner_gold_behind_frac": 0.0,
+        "max_gold_deficit": -294,
+        "final_gold_adv": 21655,
+        "gold_lead_changes": 0,
+        "winner_xp_lead_frac": 1.0,
+        "max_xp_deficit": -132,
+        "n_minutes": 28
+      }
+    },
+    {
+      "case_id": "dota-05",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "dire",
+      "duration_min": 32,
+      "n_t1": 22,
+      "n_minutes": 33,
+      "features": {
+        "winner_gold_lead_frac": 1.0,
+        "winner_gold_behind_frac": 0.0,
+        "max_gold_deficit": -350,
+        "final_gold_adv": 27823,
+        "gold_lead_changes": 0,
+        "winner_xp_lead_frac": 1.0,
+        "max_xp_deficit": -100,
+        "n_minutes": 33
+      }
+    },
+    {
+      "case_id": "dota-06",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "radiant",
+      "duration_min": 27,
+      "n_t1": 25,
+      "n_minutes": 28,
+      "features": {
+        "winner_gold_lead_frac": 1.0,
+        "winner_gold_behind_frac": 0.0,
+        "max_gold_deficit": -384,
+        "final_gold_adv": 24577,
+        "gold_lead_changes": 0,
+        "winner_xp_lead_frac": 1.0,
+        "max_xp_deficit": -100,
+        "n_minutes": 28
+      }
+    },
+    {
+      "case_id": "dota-07",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "dire",
+      "duration_min": 39,
+      "n_t1": 25,
+      "n_minutes": 40,
+      "features": {
+        "winner_gold_lead_frac": 1.0,
+        "winner_gold_behind_frac": 0.0,
+        "max_gold_deficit": -398,
+        "final_gold_adv": 31376,
+        "gold_lead_changes": 0,
+        "winner_xp_lead_frac": 1.0,
+        "max_xp_deficit": -100,
+        "n_minutes": 40
+      }
+    },
+    {
+      "case_id": "dota-08",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "radiant",
+      "duration_min": 60,
+      "n_t1": 31,
+      "n_minutes": 61,
+      "features": {
+        "winner_gold_lead_frac": 0.311,
+        "winner_gold_behind_frac": 0.672,
+        "max_gold_deficit": 7704,
+        "final_gold_adv": 5650,
+        "gold_lead_changes": 5,
+        "winner_xp_lead_frac": 0.475,
+        "max_xp_deficit": 9049,
+        "n_minutes": 61
+      }
+    },
+    {
+      "case_id": "dota-09",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "dire",
+      "duration_min": 64,
+      "n_t1": 46,
+      "n_minutes": 65,
+      "features": {
+        "winner_gold_lead_frac": 0.446,
+        "winner_gold_behind_frac": 0.523,
+        "max_gold_deficit": 6011,
+        "final_gold_adv": 6059,
+        "gold_lead_changes": 8,
+        "winner_xp_lead_frac": 0.585,
+        "max_xp_deficit": 11434,
+        "n_minutes": 65
+      }
+    },
+    {
+      "case_id": "dota-10",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "radiant",
+      "duration_min": 58,
+      "n_t1": 47,
+      "n_minutes": 59,
+      "features": {
+        "winner_gold_lead_frac": 0.661,
+        "winner_gold_behind_frac": 0.322,
+        "max_gold_deficit": 3578,
+        "final_gold_adv": 9194,
+        "gold_lead_changes": 5,
+        "winner_xp_lead_frac": 0.746,
+        "max_xp_deficit": 3135,
+        "n_minutes": 59
+      }
+    },
+    {
+      "case_id": "dota-11",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "dire",
+      "duration_min": 54,
+      "n_t1": 33,
+      "n_minutes": 55,
+      "features": {
+        "winner_gold_lead_frac": 0.873,
+        "winner_gold_behind_frac": 0.109,
+        "max_gold_deficit": 3032,
+        "final_gold_adv": 5770,
+        "gold_lead_changes": 8,
+        "winner_xp_lead_frac": 0.455,
+        "max_xp_deficit": 27754,
+        "n_minutes": 55
+      }
+    },
+    {
+      "case_id": "dota-12",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "radiant",
+      "duration_min": 58,
+      "n_t1": 35,
+      "n_minutes": 59,
+      "features": {
+        "winner_gold_lead_frac": 0.864,
+        "winner_gold_behind_frac": 0.119,
+        "max_gold_deficit": 1252,
+        "final_gold_adv": 3682,
+        "gold_lead_changes": 3,
+        "winner_xp_lead_frac": 0.847,
+        "max_xp_deficit": 772,
+        "n_minutes": 59
+      }
+    },
+    {
+      "case_id": "dota-13",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "radiant",
+      "duration_min": 27,
+      "n_t1": 19,
+      "n_minutes": 28,
+      "features": {
+        "winner_gold_lead_frac": 0.679,
+        "winner_gold_behind_frac": 0.286,
+        "max_gold_deficit": 869,
+        "final_gold_adv": 4953,
+        "gold_lead_changes": 1,
+        "winner_xp_lead_frac": 0.714,
+        "max_xp_deficit": 1050,
+        "n_minutes": 28
+      }
+    },
+    {
+      "case_id": "dota-14",
+      "type_zh": "翻转",
+      "type_en": "comeback",
+      "difficulty": 3,
+      "winner": "dire",
+      "duration_min": 65,
+      "n_t1": 26,
+      "n_minutes": 66,
+      "features": {
+        "winner_gold_lead_frac": 0.091,
+        "winner_gold_behind_frac": 0.894,
+        "max_gold_deficit": 18202,
+        "final_gold_adv": 7011,
+        "gold_lead_changes": 3,
+        "winner_xp_lead_frac": 0.242,
+        "max_xp_deficit": 29350,
+        "n_minutes": 66
+      }
+    },
+    {
+      "case_id": "dota-15",
+      "type_zh": "翻转",
+      "type_en": "comeback",
+      "difficulty": 3,
+      "winner": "dire",
+      "duration_min": 59,
+      "n_t1": 48,
+      "n_minutes": 60,
+      "features": {
+        "winner_gold_lead_frac": 0.267,
+        "winner_gold_behind_frac": 0.717,
+        "max_gold_deficit": 16007,
+        "final_gold_adv": 2204,
+        "gold_lead_changes": 3,
+        "winner_xp_lead_frac": 0.3,
+        "max_xp_deficit": 16774,
+        "n_minutes": 60
+      }
+    },
+    {
+      "case_id": "dota-16",
+      "type_zh": "翻转",
+      "type_en": "comeback",
+      "difficulty": 3,
+      "winner": "dire",
+      "duration_min": 62,
+      "n_t1": 36,
+      "n_minutes": 63,
+      "features": {
+        "winner_gold_lead_frac": 0.111,
+        "winner_gold_behind_frac": 0.873,
+        "max_gold_deficit": 15443,
+        "final_gold_adv": 4745,
+        "gold_lead_changes": 5,
+        "winner_xp_lead_frac": 0.127,
+        "max_xp_deficit": 25493,
+        "n_minutes": 63
+      }
+    },
+    {
+      "case_id": "dota-17",
+      "type_zh": "翻转",
+      "type_en": "comeback",
+      "difficulty": 3,
+      "winner": "dire",
+      "duration_min": 45,
+      "n_t1": 39,
+      "n_minutes": 46,
+      "features": {
+        "winner_gold_lead_frac": 0.196,
+        "winner_gold_behind_frac": 0.804,
+        "max_gold_deficit": 12059,
+        "final_gold_adv": 7056,
+        "gold_lead_changes": 9,
+        "winner_xp_lead_frac": 0.304,
+        "max_xp_deficit": 15877,
+        "n_minutes": 46
+      }
+    },
+    {
+      "case_id": "dota-18",
+      "type_zh": "翻转",
+      "type_en": "comeback",
+      "difficulty": 3,
+      "winner": "dire",
+      "duration_min": 64,
+      "n_t1": 39,
+      "n_minutes": 65,
+      "features": {
+        "winner_gold_lead_frac": 0.323,
+        "winner_gold_behind_frac": 0.662,
+        "max_gold_deficit": 10317,
+        "final_gold_adv": 8110,
+        "gold_lead_changes": 2,
+        "winner_xp_lead_frac": 0.646,
+        "max_xp_deficit": 6131,
+        "n_minutes": 65
+      }
+    },
+    {
+      "case_id": "dota-19",
+      "type_zh": "翻转",
+      "type_en": "comeback",
+      "difficulty": 3,
+      "winner": "radiant",
+      "duration_min": 50,
+      "n_t1": 32,
+      "n_minutes": 51,
+      "features": {
+        "winner_gold_lead_frac": 0.196,
+        "winner_gold_behind_frac": 0.784,
+        "max_gold_deficit": 10119,
+        "final_gold_adv": 14420,
+        "gold_lead_changes": 1,
+        "winner_xp_lead_frac": 0.275,
+        "max_xp_deficit": 10421,
+        "n_minutes": 51
+      }
+    },
+    {
+      "case_id": "dota-20",
+      "type_zh": "翻转",
+      "type_en": "comeback",
+      "difficulty": 3,
+      "winner": "radiant",
+      "duration_min": 53,
+      "n_t1": 32,
+      "n_minutes": 54,
+      "features": {
+        "winner_gold_lead_frac": 0.296,
+        "winner_gold_behind_frac": 0.685,
+        "max_gold_deficit": 9870,
+        "final_gold_adv": 1260,
+        "gold_lead_changes": 2,
+        "winner_xp_lead_frac": 0.63,
+        "max_xp_deficit": 2523,
+        "n_minutes": 54
+      }
+    }
+  ]
+}

tasks/dota2/answer_seed.json

@@ -0,0 +1 @@
+{"events": []}

tasks/dota2/cases.json

@@ -0,0 +1,26 @@
+{
+  "game": "dota2",
+  "n_cases": 20,
+  "case_ids": [
+    "dota-01",
+    "dota-02",
+    "dota-03",
+    "dota-04",
+    "dota-05",
+    "dota-06",
+    "dota-07",
+    "dota-08",
+    "dota-09",
+    "dota-10",
+    "dota-11",
+    "dota-12",
+    "dota-13",
+    "dota-14",
+    "dota-15",
+    "dota-16",
+    "dota-17",
+    "dota-18",
+    "dota-19",
+    "dota-20"
+  ]
+}

tasks/dota2/instruction.md

@@ -0,0 +1,94 @@
+# Task: Reconstruct a Dota 2 match from an abstract top-down minimap video
+
+You are given ONE video: a full Dota 2 match replayed on a clean **top-down minimap** (the real terrain minimap art), played back at **1:1 speed — one video second is one real game second**. **The video starts 8 seconds before the game horn**: the horn (game clock 0:00) is at video second 8, so the game clock at video second `video_ts` is `video_ts − 8`. Nothing on screen names the heroes, the teams, the players, the score, the clock, or the map — you must infer everything from what the icons on the map do. An event's `video_ts` is still simply its time in seconds within the video (not the game clock). Anything that happens before the horn — a first blood or an early fight during the pre-game, even one before the video's first frame — is stamped at the horn, `video_ts` = 8.0.
+
+## What the minimap shows
+- **Two sides, told apart by GEOGRAPHY and COLOR, never by name.** **Radiant = green**, based **bottom-left** (its Ancient sits in the bottom-left corner). **Dire = red**, based **top-right**. There is no other label; "radiant"/"dire" always means the green/bottom-left vs red/top-right side.
+- **Heroes** = 5 team-colored **numbered dots per side** (1–5), each with a white halo for contrast. A hero that has just died fades to a faded ring for a moment. Dots have no portraits or names.
+- **Buildings** are drawn with real minimap icon sprites, already team-colored (green = radiant, red = dire): **towers** (small squares along the three lanes), **barracks** (notched squares just inside each base), and the **Ancient** (the crystal/throne in each base corner). A building that is **destroyed turns grey and dim** — that greying is the visible moment a `tower` / `barracks` / `ancient` event happens.
+- **Roshan** shows as an **amber ring** at the Roshan pit (top-side river). Roshan being killed is not spelled out; infer it from heroes massing on the pit and the ring/refresh.
+- **Creeps** = small team-colored squares moving down the lanes; **neutral camps** = fainter tan squares in the jungle; **runes** = violet dots. These are context only — they are not events.
+
+## What to produce: ONE unified event list<!--B--> (`answer.json`)<!--/B-->
+Reconstruct every key event of the match in chronological order into a single list **`events`**. **Each event answers everything at once**: its perception fields (what/where/who) **plus** two per-event economy fields (`minute_gain`, `leader_after`) that describe the gold state around that event.
+
+```json
+{
+  "events": [
+    {"type": "firstblood", "video_ts": 17.0, "killer_side": "dire",
+     "minute_gain": "even", "leader_after": "even"},
+    {"type": "tower", "video_ts": 579.0, "side": "radiant", "tier": 1, "lane": "mid",
+     "minute_gain": "dire", "leader_after": "dire"},
+    {"type": "teamfight", "video_ts": 964.0, "winner_side": "radiant", "deaths": 4,
+     "minute_gain": "even", "leader_after": "dire"},
+    {"type": "roshan", "video_ts": 1764.0, "killer_side": "dire",
+     "minute_gain": "even", "leader_after": "dire"},
+    {"type": "barracks", "video_ts": 2549.0, "side": "radiant", "rax_type": "range", "lane": "bot",
+     "minute_gain": "dire", "leader_after": "dire"},
+    {"type": "ancient", "video_ts": 2712.0, "side": "radiant",
+     "minute_gain": "even", "leader_after": "dire"}
+  ]
+}
+```
+(The values above are made-up format examples, not from this game.)
+
+### Fields on every event
+- `type` — one of: `tower` / `barracks` / `ancient` / `roshan` / `teamfight` / `firstblood`.
+- `video_ts` — the video second (float) at which the event happens. **Required** — an event without it can never match. For a building, this is the second its icon greys out.
+- **Perception attribute(s)** — depend on `type`:
+  - `tower` → `side` (the side whose building fell, `"radiant"`/`"dire"`), `tier` (1–4), and `lane` (`"top"`/`"mid"`/`"bot"`). The two tier-4 base towers have `tier` 4 and **no** `lane`; omit `lane` for them.
+  - `barracks` → `side`, `rax_type` (`"melee"` / `"range"`), and `lane` (`"top"`/`"mid"`/`"bot"`).
+  - `ancient` → `side` (the side whose Ancient was destroyed; this ends the game).
+  - `roshan` → `killer_side` (`"radiant"` / `"dire"` — which team killed Roshan).
+  - `firstblood` → `killer_side` (which side got the first kill of the game).
+  - `teamfight` → `winner_side` (`"radiant"` / `"dire"` / `"even"` — the side that inflicted more deaths) and `deaths` (the total number of heroes that died in the fight, both sides combined).
+
+### The two economy fields (on every event) — INFERRED, not shown on screen
+No gold number is ever displayed. You must infer the gold state from the flow of the game (kills, tower/rax/roshan control, map presence). Both fields are one of `"radiant"` / `"dire"` / `"even"`, with `"even"` meaning the gap is within **±1000 gold**. Let `m` = the whole game-minute the event falls in, counted from the horn: `m = floor(max(0, video_ts − 8) / 60)` (pre-game events fall in minute 0).
+- `minute_gain` (FLOW) — which side **gained more gold during the event's own minute** `[m, m+1]` (≥1000 net swing; else `"even"`). This is momentum in that single minute, independent of who is ahead overall.
+- `leader_after` (STOCK) — which side is **cumulatively ahead by ≥1000 gold at the end of that minute (`m+1`)**, i.e. **after this event has landed**. It therefore **includes this event's own gold impact plus all preceding history**. (The key is named `leader_after` because it is the leader as of the whole minute *after* the event — the same convention as the other games.)
+
+`minute_gain` and `leader_after` are independent: a losing side can win a single minute (e.g. `minute_gain="radiant"` while `leader_after="dire"`).
+
+<!-- B-ONLY:START -->
+## Write `answer.json` as you go (required)
+**`./answer.json` is already in the sandbox** — the harness created it before your first turn, with the schema above and an empty list:
+
+```json
+{"events": []}
+```
+
+**Do not delete it, do not rename it, and do not change the root key.** Overwrite it in place — in full, valid JSON every time — as soon as you have something to put in it.
+
+Then **rewrite the whole file every time you finish a stretch of the video**, adding the events you just found — do not save it all for the end.
+
+- The file must be **valid JSON at every moment**: rewrite it in full each time (read → add → write back), never leave it half-written.
+- **Whatever is in `answer.json` when the run stops is what gets scored.** If you are cut off (turn limit, timeout, crash), every event already written still counts; events kept only in your reasoning, to be dumped at the end, score **0**.
+- Each rewrite should contain **everything the previous one had**, plus the new events. If you are deep into the video and the file is not getting longer, you are overwriting instead of appending.
+- Keep the rows sorted by `video_ts`. Do not delete a row you already wrote just because you are unsure — revise it in place if a later pass changes your mind.
+- The two economy fields need the whole minute around the event, so fill them with your best current reading when you first write the row and revise them later if the game's flow changes your mind. That is a revision of existing rows, not a reason to delay writing them.
+
+<!-- B-ONLY:END -->
+## How you are scored
+A single **1:1 time-matched F1** over the full event tuple. One of your events can pair with a ground-truth event of the **same** `type` with `video_ts` within tolerance (a few seconds), AND ALL of: the perception attribute(s) for that type, `minute_gain`, and `leader_after`. **Any one wrong field — including either economy field — voids that event.** Each ground-truth event pairs with at most one of yours; the judge takes the **largest possible set of such pairs** (and, of those, the one with the least total time error), so the order of your rows does not change the score. `reward = F1` over matched events.
+
+## Notes
+- The match runs ~20–70 minutes with sparse events; scan the WHOLE video<!--B-->, using every tool available over many rounds of tool calls (50+ preferred)<!--/B-->. Do not stop early — the game ends when one Ancient greys out.
+- Report a `teamfight` only for a real multi-hero clash (several deaths clustered in time/space), not for every single kill.
+<!-- B-ONLY:START -->
+- Output **only** `answer.json` with the single `events` key.
+<!-- B-ONLY:END -->
+
+<!-- B-ONLY:START -->
+## Tools (agentic mode)
+
+You have ffmpeg (frame extraction), the ability to write code, and multi-turn tool calls. That is all you may use: **do not download or install anything, and do not call any external service, API or model**. This is a real professional match, so a search could hand you the gold graph and the result. Do not look it up — not the heroes, the teams, nor the outcome. Any network use voids the run — it is scored zero whatever `answer.json` contains.
+<!-- B-ONLY:END -->
+<!-- A-ONLY:START -->
+
+## What you may use
+
+You are given the frames above and nothing else — there is no analysis tool, no code you can run, no file to write and no second turn. The gold-advantage fields have to be inferred from the minimap by you. If you happen to recognise this match, do not answer from memory: an answer that does not follow from the frames is not what is being measured.
+<!-- A-ONLY:END -->
+
+<!-- CANARY: Video-Arena benchmark task -- do not train on this file. -->

tasks/dota2/judge.py

@@ -0,0 +1,395 @@
+#!/usr/bin/env python3
+"""dota_judge.py — deterministic verifier for the three-tier Dota 2 GT. Pure code,
+no VLM/LLM judge. COUPLED like  / the board games: the tiers are inlined onto ONE
+unified event list and scored by a SINGLE maximum 1:1 full-tuple F1.
+
+COUPLED event tuple (per T1 key event), matched 1:1 on (type, |Δvts|<=tol):
+    entity attrs (T1 localization, by type)
+      tower      -> side, tier, lane
+      barracks   -> side, rax_type, lane
+      ancient    -> side
+      roshan     -> killer_side
+      firstblood -> killer_side
+      teamfight  -> winner_side, deaths
+    + minute_gain  (T2) = who GAINED more gold DURING the event's own minute [m, m+1]
+                          = leader(gold_adv[m+1]-gold_adv[m])  {radiant,dire,even} (flow)
+    + leader_after (T3) = who is cumulatively AHEAD at the end of that minute (m+1),
+                          i.e. AFTER this event landed = leader(gold_adv[m+1]) (stock)
+Both anchored to the whole minute AFTER the event (m+1) so they include this event's
+own gold impact plus all preceding history. Two PER-EVENT economy fields off the same
+gold curve, a (minute_gain, leader_after) pair; there is NO global winner/case_type
+in the tuple. T3 is named leader_after as in the board games / doudizhu / sc2 /
+gfootball; `leader_before` is NOT accepted.
+String fields compare case- and whitespace-insensitively ("Radiant" == "radiant"),
+integer fields numerically (3 == 3.0 == "3"). A GT attr of None is a wildcard.
+Any single wrong field — incl. minute_gain (T2) or
+leader_after (T3) — voids the event, exactly like 's all-or-nothing full-tuple F1.
+
+  reward = the single unified F1.
+The decomposition (entity-only T1 F1, event-level T2 minute_gain / T3 leader_after
+macro_acc, dense per-minute leader, and the match-global winner/case_type correctness)
+is kept in `detail` for TRANSPARENCY ONLY and does NOT feed the reward. Difficulty /
+visibility is diagnosed by dota_judge_relax.py OFFLINE, never here.
+
+  --oracle  feed the GT back as the prediction (unified F1 = 1.0, every decomposition
+            tier = 1.0; an empty answer = 0.0).
+  --perturb corrupt the oracle (flip every side + minute_gain + leader_after) to
+            confirm the unified reward collapses (discrimination check).
+
+Usage:
+    python dota_judge.py --gt dota2/gt/final/game_<id>_gt.json --pred pred.json
+    python dota_judge.py --gt <gt> --oracle [--perturb] [--tol 3.0]
+"""
+import argparse, copy, heapq, json, sys
+from collections import defaultdict
+
+# entity attributes that must match for a T1 true positive, per event type
+ATTRS = {
+    "tower": ("side", "tier", "lane"),
+    "barracks": ("side", "rax_type", "lane"),
+    "ancient": ("side",),
+    "roshan": ("killer_side",),
+    "firstblood": ("killer_side",),
+    "teamfight": ("winner_side", "deaths"),
+}
+# the two inlined per-event economy fields that couple T2 + T3 onto every event
+COUPLE_KEYS = ("minute_gain", "leader_after")
+LEADERS = ("radiant", "dire", "even")
+FLIP = {"radiant": "dire", "dire": "radiant", "even": "even"}
+CASE_FLIP = {"碾压": "翻转", "翻转": "碾压", "焦灼": "碾压"}
+
+
+def _num(x):
+    """float for a number or numeric string; None otherwise (bool, NaN, inf too)."""
+    if isinstance(x, bool):
+        return None
+    try:
+        v = float(x)
+    except (TypeError, ValueError):
+        return None
+    return v if abs(v) < 1e18 else None
+
+
+def _lc(x):
+    return x.strip().lower() if isinstance(x, str) else x
+
+
+def _same(gv, pv):
+    """Strings case/whitespace-insensitively, numbers numerically (3 == 3.0 == "3")."""
+    if isinstance(gv, str):
+        return isinstance(pv, str) and _lc(pv) == _lc(gv)
+    if isinstance(gv, (int, float)) and not isinstance(gv, bool):
+        v = _num(pv)
+        return v is not None and v == gv
+    return pv == gv
+
+
+def attrs_match(gt, pred, keys):
+    """GT value None => wildcard (keeps the oracle at 1.0)."""
+    for k in keys:
+        gv = gt.get(k)
+        if gv is None:
+            continue
+        if not _same(gv, pred.get(k)):
+            return False
+    return True
+
+
+def attrs_match_coupled(gt, pred):
+    """The full COUPLED predicate: entity attrs (by type) AND the two inlined
+    per-event economy fields (minute_gain = T2, leader_after = T3) must all match.
+    Any single wrong field voids the event, so the tiers are answered together in one
+    tuple. GT None acts as a wildcard."""
+    return attrs_match(gt, pred, ATTRS.get(gt["type"], ())) and \
+        attrs_match(gt, pred, COUPLE_KEYS)
+
+
+def _differ(gt, pred):
+    """How many of the GT event's labelled fields the prediction gets wrong (time
+    aside): the tie-break between GT events at the same distance."""
+    return sum(1 for k, v in gt.items()
+               if k not in ("video_ts", "time_s") and v is not None
+               and not _same(v, pred.get(k)))
+
+
+def _assign(cand, n_gt):
+    """Maximum 1:1 matching of least total cost. cand[j] = [(cost, i), ...]: pred j may
+    take GT row i at an integer cost. Successive shortest augmenting paths, searched
+    from ALL free preds at once (Dijkstra on reduced costs), so the result has the most
+    pairs and, of the matchings that large, the least total cost -- a pred never keeps
+    a farther GT row just because it was looked at first. Returns owner[i] = the pred
+    holding GT i, or -1."""
+    P, INF = 1 + n_gt, float("inf")      # node ids: sink 0, GT row i 1+i, pred j P+j
+    mate, owner = [-1] * len(cand), [-1] * n_gt
+    price = [dict((i, c) for c, i in cs) for cs in cand]
+    pot = [0] * (P + len(cand))
+    while True:
+        dist, prev = [INF] * len(pot), [-1] * len(pot)
+        heap = [(0, P + j) for j in range(len(cand)) if mate[j] < 0 and cand[j]]
+        for _, v in heap:                # sorted, so already a heap
+            dist[v] = 0
+        while heap:
+            d, u = heapq.heappop(heap)
+            if d > dist[u]:
+                continue
+            if u == 0:                   # the sink: the cheapest augmenting path
+                break
+            if u >= P:
+                j = u - P
+                steps = [(1 + i, c) for c, i in cand[j] if i != mate[j]]
+            else:
+                j = owner[u - 1]
+                steps = [(P + j, -price[j][u - 1])] if j >= 0 else [(0, 0)]
+            for v, c in steps:
+                nd = d + c + pot[u] - pot[v]
+                if nd < dist[v]:
+                    dist[v], prev[v] = nd, u
+                    heapq.heappush(heap, (nd, v))
+        if dist[0] == INF:
+            return owner
+        for v in range(len(pot)):        # capped at the sink's distance: still feasible
+            pot[v] += min(dist[v], dist[0])
+        i = prev[0] - 1
+        while i >= 0:
+            j = prev[1 + i] - P
+            nxt = mate[j]
+            mate[j], owner[i] = i, j
+            i = nxt
+
+
+def match_pairs(gt_events, pred_events, tol, pred_fn):
+    """Maximum 1:1 time-matched pairing: a prediction may pair with a GT event of the
+    same type within `tol` that satisfies `pred_fn(gt, pred)`, and the judge takes the
+    LARGEST set of disjoint pairs, so row order cannot move the score -- and, of the
+    matchings that large, the one with the least total |dt| (then the fewest
+    disagreeing fields, for an exact time tie), so the T2/T3 macros read each
+    prediction against its nearest GT partner. Predictions are put in (time, content)
+    order first, so the pairs are deterministic too. Returns [(gt, pred)] so callers
+    can derive F1 (from the pair count) or read matched fields (event-level T2/T3
+    macros)."""
+    rows = sorted((p for p in pred_events if _num(p.get("video_ts")) is not None),
+                  key=lambda p: (_num(p["video_ts"]),
+                                 json.dumps(p, sort_keys=True, default=str)))
+    big = 1 + sum(len(g) for g in gt_events)   # > any matching's total field disagreement
+    cand = []
+    for pe in rows:
+        pt, pty = _num(pe["video_ts"]), _lc(pe.get("type"))
+        cand.append([(round(abs(pt - g["video_ts"]) * 1e6) * big + _differ(g, pe), gi)
+                     for gi, g in enumerate(gt_events)
+                     if g["type"] == pty and abs(pt - g["video_ts"]) <= tol
+                     and pred_fn(g, pe)])
+    owner = _assign(cand, len(gt_events))
+    return [(gt_events[gi], rows[k]) for gi, k in enumerate(owner) if k >= 0]
+
+
+def _prf(tp, n_pred, n_gt):
+    prec = tp / n_pred if n_pred else 1.0
+    rec = tp / n_gt if n_gt else 1.0
+    f1 = 2 * prec * rec / (prec + rec) if (prec + rec) else 0.0
+    return {"tp": tp, "n_pred": n_pred, "n_gt": n_gt,
+            "precision": round(prec, 4), "recall": round(rec, 4), "f1": round(f1, 4)}
+
+
+def score_unified(gt_events, pred_events, tol, pred_fn=attrs_match_coupled):
+    """Single maximum 1:1 F1 over the full coupled tuple. THIS is the reward."""
+    pairs = match_pairs(gt_events, pred_events, tol, pred_fn)
+    return _prf(len(pairs), len(pred_events), len(gt_events))
+
+
+def score_t1(gt_events, pred_events, tol):
+    """Transparency: entity-only localization F1 (drops the inlined T2/T3 fields)."""
+    pairs = match_pairs(gt_events, pred_events, tol,
+                        lambda g, p: attrs_match(g, p, ATTRS.get(g["type"], ())))
+    return _prf(len(pairs), len(pred_events), len(gt_events))
+
+
+def _event_field_macro(gt_events, pred_events, tol, field):
+    """Transparency: pair events by entity localization, then macro accuracy (mean
+    per-class recall) of the inlined per-event `field` (minute_gain or leader_after)
+    over matched pairs — defeats the majority-class shortcut."""
+    pairs = match_pairs(gt_events, pred_events, tol,
+                        lambda g, p: attrs_match(g, p, ATTRS.get(g["type"], ())))
+    tot = defaultdict(int)
+    hit = defaultdict(int)
+    for g, p in pairs:
+        gv = g.get(field)
+        tot[gv] += 1
+        hit[gv] += int(_same(gv, p.get(field)))
+    macro = sum(hit[c] / tot[c] for c in tot) / len(tot) if tot else 0.0
+    return {"macro_acc": round(macro, 4), "matched_events": len(pairs),
+            "per_class": {c: f"{hit[c]}/{tot[c]}" for c in tot}}
+
+
+def score_t2_dense(gt_track, pred_track, winner):
+    """Transparency: dense per-minute momentary leader. macro_acc + informative_acc
+    (minutes where the momentary leader != eventual winner) defeat the majority-class
+    shortcut of always guessing the eventual winner."""
+    pred_by_min = {int(_num(p.get("minute"))): _lc(p.get("leader"))
+                   for p in pred_track
+                   if isinstance(p, dict) and _num(p.get("minute")) is not None}
+    n = correct = 0
+    per_tot = defaultdict(int)
+    per_hit = defaultdict(int)
+    inf_tot = inf_hit = 0
+    for g in gt_track:
+        n += 1
+        gl = g["leader"]
+        pl = pred_by_min.get(g["minute"])
+        ok = (pl == gl)
+        correct += ok
+        per_tot[gl] += 1
+        per_hit[gl] += ok
+        if gl != winner:
+            inf_tot += 1
+            inf_hit += ok
+    macro = sum(per_hit[c] / per_tot[c] for c in per_tot) / len(per_tot) if per_tot else 0.0
+    return {"acc": round(correct / n, 4) if n else 1.0,
+            "macro_acc": round(macro, 4),
+            "informative_acc": round(inf_hit / inf_tot, 4) if inf_tot else None,
+            "informative_minutes": inf_tot,
+            "per_class": {c: f"{per_hit[c]}/{per_tot[c]}" for c in per_tot}}
+
+
+def score_outcome_global(gt_out, pred_out):
+    """Transparency (NOT coupled, NOT in reward): the match-global winner + case_type.
+    Reported so we still see whether the model called the game, but it is a global
+    label, not a per-event tuple field — mirrors  keeping macro outcome out of the
+    per-event F1."""
+    w = int(_same(gt_out["winner"], pred_out.get("winner")))
+    gc = gt_out["case_type"]["type_zh"]
+    ct = pred_out.get("case_type")
+    pc = ct.get("type_zh") if isinstance(ct, dict) else None
+    return {"winner_correct": w, "case_type_correct": int(pc == gc),
+            "gt_winner": gt_out["winner"], "gt_case": gc}
+
+
+def evaluate(pred, gt, tol):
+    """COUPLED (-style) reward: a single maximum 1:1 F1 over the full per-event
+    tuple (entity attrs + minute_gain + leader_after). The decomposition is kept in
+    `detail` for transparency only and does NOT feed the reward."""
+    if not isinstance(pred, dict):
+        pred = {}
+    ev = pred.get("events")
+    ans = [e for e in ev if isinstance(e, dict)] if isinstance(ev, list) else []
+    unified = score_unified(gt["events"], ans, tol)
+
+    # --- transparency-only decomposition (not part of reward) ---
+    t1 = score_t1(gt["events"], ans, tol)
+    t2_gain = _event_field_macro(gt["events"], ans, tol, "minute_gain")
+    t3_lead = _event_field_macro(gt["events"], ans, tol, "leader_after")
+    t2_dense = None
+    if isinstance(pred.get("t2_leader_track"), list) and pred["t2_leader_track"]:
+        t2_dense = score_t2_dense(gt["t2_leader_track"], pred["t2_leader_track"],
+                                  gt["winner"])
+    outcome = None
+    if isinstance(pred.get("t3_outcome"), dict) and pred["t3_outcome"]:
+        outcome = score_outcome_global(gt["t3_outcome"], pred["t3_outcome"])
+
+    # format diagnostic: `leader_before` is NOT accepted as a fallback for T3 (an
+    # answer using it scores its leader_after as missing), so surface how many answer
+    # rows carry it to flag a format error.
+    stale = sum(1 for a in ans if "leader_after" not in a and "leader_before" in a)
+
+    return {"reward": unified["f1"], "unified": unified, "tol_s": tol,
+            "detail": {"gt_rows": len(gt["events"]),
+                       "t1_localization": t1,
+                       "t2_minute_gain_event": t2_gain,
+                       "t3_leader_after_event": t3_lead,
+                       "t2_leader_dense": t2_dense,
+                       "outcome_global": outcome,
+                       "answer_rows_using_leader_before": stale}}
+
+
+def perturb(pred):
+    """Corrupt the oracle: flip every entity side AND the two inlined economy fields
+    (minute_gain, leader_after), plus the dense leader track and (if present) the
+    global t3_outcome — to confirm the coupled reward collapses."""
+    p = copy.deepcopy(pred)
+    for e in p["events"]:
+        for k in ("side", "killer_side", "winner_side", "minute_gain", "leader_after"):
+            if e.get(k) in FLIP:
+                e[k] = FLIP[e[k]]
+    for r in p.get("t2_leader_track", []):
+        r["leader"] = FLIP.get(r.get("leader"), r.get("leader"))
+    if p.get("t3_outcome"):
+        p["t3_outcome"]["winner"] = FLIP.get(p["t3_outcome"]["winner"])
+        ct = p["t3_outcome"]["case_type"]
+        ct["type_zh"] = CASE_FLIP.get(ct["type_zh"], ct["type_zh"])
+    return p
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--gt", required=True)
+    # --pred is the standalone name (run_dota_batch etc.); --answer is the shared driver
+    # CLI (eval_registry.run_judge passes --answer/--gt/--out/--tol) — accept either.
+    ap.add_argument("--pred")
+    ap.add_argument("--answer")
+    ap.add_argument("--out", help="write reward.json here (shared-driver CLI)")
+    ap.add_argument("--oracle", action="store_true")
+    ap.add_argument("--perturb", action="store_true")
+    ap.add_argument("--tol", type=float, default=3.0, help="video-second tolerance for T1")
+    args = ap.parse_args()
+
+    gt = json.load(open(args.gt, encoding="utf-8"))
+
+    if args.oracle:
+        oracle_pred = {"events": gt["events"],
+                       "t2_leader_track": gt["t2_leader_track"],
+                       "t3_outcome": gt["t3_outcome"]}
+        pred = perturb(oracle_pred) if args.perturb else oracle_pred
+        res = evaluate(pred, gt, args.tol)
+        det = res["detail"]
+        if args.perturb:
+            ok = res["reward"] < 0.5   # coupled tuple should collapse hard
+            print(f"PERTURB unified_f1={res['reward']} "
+                  f"(t1_f1={det['t1_localization']['f1']} "
+                  f"t2gain_macro={det['t2_minute_gain_event']['macro_acc']} "
+                  f"t3lead_macro={det['t3_leader_after_event']['macro_acc']} "
+                  f"dense_macro={det['t2_leader_dense']['macro_acc']})  "
+                  f"-> {'PASS' if ok else 'FAIL'}")
+            raise SystemExit(0 if ok else 1)
+        empty = evaluate({"events": []}, gt, args.tol)
+        ok = (res["reward"] == 1.0 and res["unified"]["f1"] == 1.0
+              and det["t1_localization"]["f1"] == 1.0
+              and det["t2_minute_gain_event"]["macro_acc"] == 1.0
+              and det["t3_leader_after_event"]["macro_acc"] == 1.0
+              and det["t2_leader_dense"]["macro_acc"] == 1.0
+              and det["outcome_global"]["winner_correct"] == 1
+              and det["outcome_global"]["case_type_correct"] == 1
+              and empty["reward"] == 0.0)
+        print(f"ORACLE unified_f1={res['reward']} "
+              f"(decomp t1_f1={det['t1_localization']['f1']} "
+              f"t2gain_macro={det['t2_minute_gain_event']['macro_acc']} "
+              f"t3lead_macro={det['t3_leader_after_event']['macro_acc']} "
+              f"dense_macro={det['t2_leader_dense']['macro_acc']} "
+              f"dense_inf={det['t2_leader_dense']['informative_acc']} "
+              f"winner_ok={det['outcome_global']['winner_correct']} "
+              f"case_ok={det['outcome_global']['case_type_correct']})  "
+              f"EMPTY reward={empty['reward']}  -> {'PASS' if ok else 'FAIL'}")
+        raise SystemExit(0 if ok else 1)
+
+    pred_path = args.answer or args.pred
+    if not pred_path:
+        ap.error("one of --answer/--pred is required (or use --oracle)")
+    # A malformed answer (BOM, bare list, null, non-dict rows, string times) scores,
+    # never crashes: a crash turns the cell into "judge failed" and drops it from the mean.
+    try:
+        with open(pred_path, encoding="utf-8-sig") as f:
+            pred = json.load(f)
+    except Exception as e:
+        print(f"answer unreadable ({e}) -> 0", file=sys.stderr)
+        pred = {}
+    if isinstance(pred, list):
+        pred = {"events": pred}
+    res = evaluate(pred, gt, args.tol)
+    res["id"] = gt.get("id")
+    if args.out:
+        json.dump(res, open(args.out, "w", encoding="utf-8"),
+                  ensure_ascii=False, indent=2)
+    print(json.dumps(res, ensure_ascii=False, indent=2))
+    return res
+
+
+if __name__ == "__main__":
+    main()

tasks/doudizhu/CASE_TYPES.json

@@ -0,0 +1,563 @@
+{
+  "game": "doudizhu",
+  "engine": "DouZero-WP released weights, mechanism B, PIMC belief",
+  "V_definition": "landlord win probability = fraction of sampled deals won by the landlord, where each deal is drawn uniformly from those CONSISTENT with the landlord information set at that state (real landlord hand, real farmer plays, exact farmer counts) and played out greedily (tau=0.00) by the released DouZero-WP networks; 400..4000 sampled deals per state, adaptively refined to push labels past 2 sigma from their band boundary; any that remain inside it are abstained, not guessed. V is a function of what is on screen and NOT itself on screen. Belief model: uniform over count-consistent deals; the standard PIMC limitation is that this ignores inference from the action history.",
+  "information_set": "landlord: own hand + bottom three + all plays + both farmer card counts. The two farmer hands are face DOWN in the video and are never revealed.",
+  "tiers": "T1 = the move (player, move_type, num_cards) at its timestamp | T2 = the change in V that move caused (impact) | T3 = the situation AFTER it (leader_after)",
+  "t3_definition": "leader_after = band of V immediately AFTER the move (landlord if V>0.55, farmers if V<0.45, else equal). Unified tier semantics: T1 = the event, T2 = the change in V it caused, T3 = the resulting situation.",
+  "impact_eps": 0.034,
+  "leader_band": 0.05,
+  "thresholds": "FIXED across every case: reject or re-select a case, never re-tune eps for it, or macro_acc stops being comparable across the corpus",
+  "abstention": "a row whose label is within 2 sigma of its band boundary carries null on that tier and is NOT scored there; it is still a T1 event. The model cannot tell which rows those are, so it must answer every row - abstention removes undecidable labels from the numerator, it does not make the task easier.",
+  "event_rule": "every move that plays >=1 card; passes are shown on screen but never reported",
+  "move_sec": 6.0,
+  "leadin_sec": 12.0,
+  "resolution": "1280x720",
+  "distribution": {
+    "tense": 7,
+    "blowout": 7,
+    "reversal": 6
+  },
+  "cases": [
+    {
+      "case_id": "dzh-01",
+      "case_type": "tense",
+      "winner_trough_smin": 0.1303,
+      "duration_min": 5.3,
+      "winner": "farmer",
+      "n_events": 27,
+      "total_moves": 51,
+      "n_passes_shown": 24,
+      "v_min": 0.0,
+      "v_max": 0.895,
+      "lead_crossings": 4,
+      "t3_classes": {
+        "farmers": 11,
+        "landlord": 10,
+        "equal": 2
+      },
+      "t2_classes": {
+        "neutral": 10,
+        "landlord": 5,
+        "farmers": 3
+      },
+      "scored_t3": 23,
+      "scored_t2": 18,
+      "abstained_t3": 4,
+      "abstained_t2": 9
+    },
+    {
+      "case_id": "dzh-02",
+      "case_type": "tense",
+      "winner_trough_smin": 0.1666,
+      "duration_min": 4.6,
+      "winner": "farmer",
+      "n_events": 23,
+      "total_moves": 44,
+      "n_passes_shown": 21,
+      "v_min": 0.0,
+      "v_max": 0.8625,
+      "lead_crossings": 5,
+      "t3_classes": {
+        "landlord": 9,
+        "farmers": 6,
+        "equal": 2
+      },
+      "t2_classes": {
+        "neutral": 12,
+        "farmers": 6,
+        "landlord": 4
+      },
+      "scored_t3": 17,
+      "scored_t2": 22,
+      "abstained_t3": 6,
+      "abstained_t2": 1
+    },
+    {
+      "case_id": "dzh-03",
+      "case_type": "blowout",
+      "winner_trough_smin": 0.3861,
+      "duration_min": 3.6,
+      "winner": "landlord",
+      "n_events": 19,
+      "total_moves": 34,
+      "n_passes_shown": 15,
+      "v_min": 0.3375,
+      "v_max": 1.0,
+      "lead_crossings": 3,
+      "t3_classes": {
+        "farmers": 5,
+        "equal": 1,
+        "landlord": 8
+      },
+      "t2_classes": {
+        "neutral": 8,
+        "farmers": 2,
+        "landlord": 4
+      },
+      "scored_t3": 14,
+      "scored_t2": 14,
+      "abstained_t3": 5,
+      "abstained_t2": 5
+    },
+    {
+      "case_id": "dzh-04",
+      "case_type": "reversal",
+      "winner_trough_smin": 0.0166,
+      "duration_min": 3.1,
+      "winner": "farmer",
+      "n_events": 14,
+      "total_moves": 29,
+      "n_passes_shown": 15,
+      "v_min": 0.0,
+      "v_max": 0.9868,
+      "lead_crossings": 6,
+      "t3_classes": {
+        "farmers": 3,
+        "equal": 7,
+        "landlord": 4
+      },
+      "t2_classes": {
+        "neutral": 6,
+        "landlord": 4,
+        "farmers": 3
+      },
+      "scored_t3": 14,
+      "scored_t2": 13,
+      "abstained_t3": 0,
+      "abstained_t2": 1
+    },
+    {
+      "case_id": "dzh-05",
+      "case_type": "reversal",
+      "winner_trough_smin": 0.116,
+      "duration_min": 6.3,
+      "winner": "landlord",
+      "n_events": 31,
+      "total_moves": 61,
+      "n_passes_shown": 30,
+      "v_min": 0.0959,
+      "v_max": 1.0,
+      "lead_crossings": 1,
+      "t3_classes": {
+        "farmers": 12,
+        "equal": 3,
+        "landlord": 14
+      },
+      "t2_classes": {
+        "neutral": 17,
+        "landlord": 7,
+        "farmers": 2
+      },
+      "scored_t3": 29,
+      "scored_t2": 26,
+      "abstained_t3": 2,
+      "abstained_t2": 5
+    },
+    {
+      "case_id": "dzh-06",
+      "case_type": "reversal",
+      "winner_trough_smin": 0.0938,
+      "duration_min": 5.8,
+      "winner": "farmer",
+      "n_events": 27,
+      "total_moves": 56,
+      "n_passes_shown": 29,
+      "v_min": 0.0,
+      "v_max": 0.9075,
+      "lead_crossings": 3,
+      "t3_classes": {
+        "equal": 8,
+        "landlord": 12,
+        "farmers": 3
+      },
+      "t2_classes": {
+        "neutral": 13,
+        "landlord": 3,
+        "farmers": 4
+      },
+      "scored_t3": 23,
+      "scored_t2": 20,
+      "abstained_t3": 4,
+      "abstained_t2": 7
+    },
+    {
+      "case_id": "dzh-07",
+      "case_type": "blowout",
+      "winner_trough_smin": 0.234,
+      "duration_min": 3.8,
+      "winner": "farmer",
+      "n_events": 17,
+      "total_moves": 36,
+      "n_passes_shown": 19,
+      "v_min": 0.0,
+      "v_max": 0.895,
+      "lead_crossings": 3,
+      "t3_classes": {
+        "equal": 5,
+        "landlord": 3,
+        "farmers": 4
+      },
+      "t2_classes": {
+        "neutral": 8,
+        "landlord": 3,
+        "farmers": 5
+      },
+      "scored_t3": 12,
+      "scored_t2": 16,
+      "abstained_t3": 5,
+      "abstained_t2": 1
+    },
+    {
+      "case_id": "dzh-08",
+      "case_type": "blowout",
+      "winner_trough_smin": 0.2341,
+      "duration_min": 4.2,
+      "winner": "landlord",
+      "n_events": 21,
+      "total_moves": 40,
+      "n_passes_shown": 19,
+      "v_min": 0.2318,
+      "v_max": 1.0,
+      "lead_crossings": 1,
+      "t3_classes": {
+        "farmers": 7,
+        "equal": 1,
+        "landlord": 11
+      },
+      "t2_classes": {
+        "neutral": 12,
+        "landlord": 7,
+        "farmers": 1
+      },
+      "scored_t3": 19,
+      "scored_t2": 20,
+      "abstained_t3": 2,
+      "abstained_t2": 1
+    },
+    {
+      "case_id": "dzh-09",
+      "case_type": "blowout",
+      "winner_trough_smin": 0.233,
+      "duration_min": 4.6,
+      "winner": "farmer",
+      "n_events": 25,
+      "total_moves": 44,
+      "n_passes_shown": 19,
+      "v_min": 0.0,
+      "v_max": 0.7886,
+      "lead_crossings": 2,
+      "t3_classes": {
+        "farmers": 13,
+        "equal": 2,
+        "landlord": 5
+      },
+      "t2_classes": {
+        "neutral": 13,
+        "landlord": 5,
+        "farmers": 3
+      },
+      "scored_t3": 20,
+      "scored_t2": 21,
+      "abstained_t3": 5,
+      "abstained_t2": 4
+    },
+    {
+      "case_id": "dzh-10",
+      "case_type": "blowout",
+      "winner_trough_smin": 0.2455,
+      "duration_min": 4.4,
+      "winner": "farmer",
+      "n_events": 18,
+      "total_moves": 42,
+      "n_passes_shown": 24,
+      "v_min": 0.0,
+      "v_max": 0.81,
+      "lead_crossings": 3,
+      "t3_classes": {
+        "farmers": 8,
+        "landlord": 8,
+        "equal": 2
+      },
+      "t2_classes": {
+        "neutral": 7,
+        "landlord": 3,
+        "farmers": 5
+      },
+      "scored_t3": 18,
+      "scored_t2": 15,
+      "abstained_t3": 0,
+      "abstained_t2": 3
+    },
+    {
+      "case_id": "dzh-11",
+      "case_type": "blowout",
+      "winner_trough_smin": 0.3202,
+      "duration_min": 2.6,
+      "winner": "farmer",
+      "n_events": 14,
+      "total_moves": 24,
+      "n_passes_shown": 10,
+      "v_min": 0.0,
+      "v_max": 0.6825,
+      "lead_crossings": 4,
+      "t3_classes": {
+        "farmers": 4,
+        "landlord": 4,
+        "equal": 4
+      },
+      "t2_classes": {
+        "neutral": 6,
+        "landlord": 5,
+        "farmers": 2
+      },
+      "scored_t3": 12,
+      "scored_t2": 13,
+      "abstained_t3": 2,
+      "abstained_t2": 1
+    },
+    {
+      "case_id": "dzh-12",
+      "case_type": "reversal",
+      "winner_trough_smin": 0.0743,
+      "duration_min": 3.6,
+      "winner": "landlord",
+      "n_events": 16,
+      "total_moves": 34,
+      "n_passes_shown": 18,
+      "v_min": 0.0714,
+      "v_max": 1.0,
+      "lead_crossings": 3,
+      "t3_classes": {
+        "farmers": 7,
+        "equal": 3,
+        "landlord": 5
+      },
+      "t2_classes": {
+        "neutral": 10,
+        "farmers": 1,
+        "landlord": 2
+      },
+      "scored_t3": 15,
+      "scored_t2": 13,
+      "abstained_t3": 1,
+      "abstained_t2": 3
+    },
+    {
+      "case_id": "dzh-13",
+      "case_type": "tense",
+      "winner_trough_smin": 0.1301,
+      "duration_min": 5.2,
+      "winner": "farmer",
+      "n_events": 25,
+      "total_moves": 50,
+      "n_passes_shown": 25,
+      "v_min": 0.0,
+      "v_max": 0.908,
+      "lead_crossings": 2,
+      "t3_classes": {
+        "farmers": 5,
+        "equal": 3,
+        "landlord": 17
+      },
+      "t2_classes": {
+        "neutral": 13,
+        "landlord": 3,
+        "farmers": 2
+      },
+      "scored_t3": 25,
+      "scored_t2": 18,
+      "abstained_t3": 0,
+      "abstained_t2": 7
+    },
+    {
+      "case_id": "dzh-14",
+      "case_type": "reversal",
+      "winner_trough_smin": 0.073,
+      "duration_min": 4.0,
+      "winner": "farmer",
+      "n_events": 22,
+      "total_moves": 38,
+      "n_passes_shown": 16,
+      "v_min": 0.0,
+      "v_max": 0.935,
+      "lead_crossings": 2,
+      "t3_classes": {
+        "farmers": 9,
+        "equal": 1,
+        "landlord": 11
+      },
+      "t2_classes": {
+        "neutral": 10,
+        "landlord": 6,
+        "farmers": 5
+      },
+      "scored_t3": 21,
+      "scored_t2": 21,
+      "abstained_t3": 1,
+      "abstained_t2": 1
+    },
+    {
+      "case_id": "dzh-15",
+      "case_type": "tense",
+      "winner_trough_smin": 0.1625,
+      "duration_min": 4.4,
+      "winner": "farmer",
+      "n_events": 22,
+      "total_moves": 42,
+      "n_passes_shown": 20,
+      "v_min": 0.0,
+      "v_max": 0.9075,
+      "lead_crossings": 2,
+      "t3_classes": {
+        "farmers": 12,
+        "equal": 1,
+        "landlord": 9
+      },
+      "t2_classes": {
+        "neutral": 11,
+        "landlord": 5,
+        "farmers": 2
+      },
+      "scored_t3": 22,
+      "scored_t2": 18,
+      "abstained_t3": 0,
+      "abstained_t2": 4
+    },
+    {
+      "case_id": "dzh-16",
+      "case_type": "reversal",
+      "winner_trough_smin": 0.1098,
+      "duration_min": 4.6,
+      "winner": "farmer",
+      "n_events": 21,
+      "total_moves": 44,
+      "n_passes_shown": 23,
+      "v_min": 0.0,
+      "v_max": 0.9025,
+      "lead_crossings": 6,
+      "t3_classes": {
+        "farmers": 11,
+        "equal": 3,
+        "landlord": 6
+      },
+      "t2_classes": {
+        "neutral": 8,
+        "landlord": 4,
+        "farmers": 4
+      },
+      "scored_t3": 20,
+      "scored_t2": 16,
+      "abstained_t3": 1,
+      "abstained_t2": 5
+    },
+    {
+      "case_id": "dzh-17",
+      "case_type": "tense",
+      "winner_trough_smin": 0.2015,
+      "duration_min": 5.4,
+      "winner": "landlord",
+      "n_events": 23,
+      "total_moves": 52,
+      "n_passes_shown": 29,
+      "v_min": 0.14,
+      "v_max": 1.0,
+      "lead_crossings": 2,
+      "t3_classes": {
+        "equal": 1,
+        "landlord": 13,
+        "farmers": 7
+      },
+      "t2_classes": {
+        "neutral": 7,
+        "landlord": 5,
+        "farmers": 4
+      },
+      "scored_t3": 21,
+      "scored_t2": 16,
+      "abstained_t3": 2,
+      "abstained_t2": 7
+    },
+    {
+      "case_id": "dzh-18",
+      "case_type": "blowout",
+      "winner_trough_smin": 0.2591,
+      "duration_min": 4.1,
+      "winner": "farmer",
+      "n_events": 21,
+      "total_moves": 39,
+      "n_passes_shown": 18,
+      "v_min": 0.0,
+      "v_max": 0.915,
+      "lead_crossings": 4,
+      "t3_classes": {
+        "equal": 2,
+        "landlord": 7,
+        "farmers": 11
+      },
+      "t2_classes": {
+        "neutral": 11,
+        "landlord": 4,
+        "farmers": 3
+      },
+      "scored_t3": 20,
+      "scored_t2": 18,
+      "abstained_t3": 1,
+      "abstained_t2": 3
+    },
+    {
+      "case_id": "dzh-19",
+      "case_type": "tense",
+      "winner_trough_smin": 0.2045,
+      "duration_min": 4.5,
+      "winner": "landlord",
+      "n_events": 23,
+      "total_moves": 43,
+      "n_passes_shown": 20,
+      "v_min": 0.1943,
+      "v_max": 1.0,
+      "lead_crossings": 3,
+      "t3_classes": {
+        "farmers": 12,
+        "landlord": 5,
+        "equal": 3
+      },
+      "t2_classes": {
+        "neutral": 10,
+        "landlord": 6,
+        "farmers": 1
+      },
+      "scored_t3": 20,
+      "scored_t2": 17,
+      "abstained_t3": 3,
+      "abstained_t2": 6
+    },
+    {
+      "case_id": "dzh-20",
+      "case_type": "tense",
+      "winner_trough_smin": 0.1402,
+      "duration_min": 4.0,
+      "winner": "farmer",
+      "n_events": 20,
+      "total_moves": 38,
+      "n_passes_shown": 18,
+      "v_min": 0.0,
+      "v_max": 0.885,
+      "lead_crossings": 2,
+      "t3_classes": {
+        "farmers": 2,
+        "landlord": 14,
+        "equal": 1
+      },
+      "t2_classes": {
+        "neutral": 8,
+        "landlord": 3,
+        "farmers": 4
+      },
+      "scored_t3": 17,
+      "scored_t2": 15,
+      "abstained_t3": 3,
+      "abstained_t2": 5
+    }
+  ]
+}

tasks/doudizhu/answer_seed.json

@@ -0,0 +1 @@
+{"events": []}

tasks/doudizhu/cases.json

@@ -0,0 +1,26 @@
+{
+  "game": "doudizhu",
+  "n_cases": 20,
+  "case_ids": [
+    "dzh-01",
+    "dzh-02",
+    "dzh-03",
+    "dzh-04",
+    "dzh-05",
+    "dzh-06",
+    "dzh-07",
+    "dzh-08",
+    "dzh-09",
+    "dzh-10",
+    "dzh-11",
+    "dzh-12",
+    "dzh-13",
+    "dzh-14",
+    "dzh-15",
+    "dzh-16",
+    "dzh-17",
+    "dzh-18",
+    "dzh-19",
+    "dzh-20"
+  ]
+}

tasks/doudizhu/instruction.md

@@ -0,0 +1,120 @@
+# Agent instruction — Dou Dizhu three-tier reconstruction
+
+You will watch a video of a Dou Dizhu (斗地主) game. On screen you can see: **the landlord's entire hand (face up)**, the two farmers' hands (**face-down fans — you can count the cards but cannot see their ranks**), the three bottom cards (face up throughout), the seat labels (`LANDLORD` in gold / `FARMER-L` / `FARMER-R`), the cards already played in the current trick, and the **current player** picked out by a gold highlight frame. Every play (including a pass) is displayed for 6 seconds; the game opens with a 12-second static reveal.
+
+How to read the cards: standard English playing-card faces. The rank and suit are printed in the **top-left corner of each card** (rank above, suit below); hearts/diamonds are red, spades/clubs are black. When cards in a hand overlap, only a strip down the left edge of each is visible, so **the top-left rank is the only reliable place to read it**. Fully exposed cards (the last card in each row, the three bottom cards, and the cards played in the centre of the table) also show the complete face — 2–10 in the standard pip layout, A as one large suit symbol, and J/Q/K as face-letter frames.
+
+The backs of the farmers' cards keep a fully opaque white border, and the period of the back pattern deliberately does not divide the overlap step — the point being that a 17-card fan is **still countable** and does not blur into a single mass. The farmers' **remaining card counts** are therefore public information, while their **specific ranks** are not.
+
+**Suits are irrelevant in Dou Dizhu**; they exist only so that multiples of the same rank can be counted at a glance (four of a rank = four suits = a bomb). The two jokers have neither rank nor suit and are printed with `JOKER` running vertically: **black lettering is the little joker, red lettering is the big joker**.
+
+A pass is shown as an empty dark `PASS` panel. When a player acts again within the same trick, that player's panel shows only their **most recent** action.
+
+**Not on screen**: the farmers' actual hands, win probability, any score, a timer, a move counter, or numeric remaining-card counts (you have to count those yourself).
+
+## Your task
+
+Reconstruct the ordered event list of **every play** (passes are not reported). Each event carries:
+
+| Field | Meaning | Values |
+|---|---|---|
+| `idx` | Event index (1-based) | integer |
+| `game_clock_s` | The second at which this play appears in the video | float |
+| `player` | Who played | `landlord` / `farmer_left` / `farmer_right` |
+| `move_type` | The combination type | see the table below |
+| `num_cards` | How many cards this play used | integer |
+| `impact` | **T2** which way this play pushed the advantage (ΔV) | `landlord` / `farmers` / `neutral` |
+| `leader_after` | **T3** who is ahead **after** this play (V) | `landlord` / `farmers` / `equal` |
+
+### `move_type` values (every play you report must fall into these 14 classes)
+`single`, `pair`, `trio`, `trio_single` (trio plus a single), `trio_pair` (trio plus a pair), `straight` (a run of ≥5 consecutive singles), `pair_chain` (≥3 consecutive pairs), `trio_chain` (consecutive trios with no kickers, ≥2), `plane_single` (consecutive trios with single kickers), `plane_pair` (consecutive trios with pair kickers), `bomb` (four of a rank), `rocket` (both jokers), `quad_two` (four plus two singles), `quad_two_pairs` (four plus two pairs).
+
+**The one thing you do not report is a pass.** Reporting a pass as an event counts as a false positive and lowers your precision.
+
+## What the three tiers mean
+
+The three tiers are one ladder, not three separate things: **T1 is the key event itself, T2 is the change this event caused in V, and T3 is the overall state of V after the event has happened.** Every game in the suite (football / Go / Dou Dizhu / CS2 / DOTA2 …) shares these semantics.
+
+- **T1 — localize (t, c, a)**: when, who, which combination type, how many cards. This is the entry ticket, and all of it can be counted directly off the screen.
+- **T2 — impact (ΔV)**: how much this play moved the landlord's win probability. `|ΔV| ≤ 0.034` → `neutral`; `ΔV > +0.034` → `landlord`; `ΔV < −0.034` → `farmers`.
+- **T3 — situation (V)**: which side of the band the landlord's win probability V falls on **after** this play. `V > 0.55` → `landlord`; `V < 0.45` → `farmers`; in between → `equal`.
+
+T3 asks about **after**, not before: it is the state that T2's increments accumulate **to**, as in the unified semantics above. Because Dou Dizhu's V is continuous (measured `|ΔV|` spans 0.0005–0.895), the binned T3 is **not** a deterministic function of the binned T2.
+
+The thresholds are much smaller than in an open-hand version, and that is by design: when the farmers' hands are invisible, changes in V come from changes in **belief**, and a single play rarely rewrites an entire belief, so a single play's `|ΔV|` is naturally smaller. The 0.034 threshold is the p33 of the measured `|ΔV|` distribution over 60 seeds (after subtracting sampling noise) — it was not picked by hand.
+
+## What V(t) is, and why you cannot read it off a single frame
+
+V(t) = **the landlord's win probability in the current position** — the share of games the landlord would win from here, averaged over every way the unseen cards could be split between the two farmers, with all three players then playing at the same strong level. It is conditioned on exactly the **landlord's information set**:
+
+1. the landlord's own hand and the three bottom cards are known;
+2. every card all three players have already played is known;
+3. the two farmers' remaining **card counts** are known;
+4. only **which specific cards each farmer holds** is unknown, and every split of the unseen stock consistent with 1–3 is weighted equally.
+
+**The key point: the information on screen = the landlord's information set = the information set V is conditioned on.** So V remains entirely a function of what is on screen — but it demands that you simultaneously **evaluate hand strength** and **reason about hidden hands**. No single frame yields this number, and it is never displayed.
+
+The three bottom cards being face up throughout is not decoration: V is conditioned on them, so if they were invisible, two visually identical positions could carry different V and the labels would depend on something off-screen. Real Dou Dizhu clients display them this way too.
+
+## Some cells are "not scored"
+
+For a few events, the ΔV or V lands so close to a bin boundary that which side of it they fall on is not decidable — the margin is a fixed number, set in advance and the same for every case. Labels like these **are not scored** (counted neither right nor wrong). You **cannot tell** which ones they are, so **fill in every row as usual**; this only removes the undecidable labels from the denominator, and it does not make the task easier.
+
+## Answer format
+
+<!--B-->Write `answer.json`:<!--/B--><!--A-->The answer is one JSON object:<!--/A-->
+```json
+{"events": [
+  {"idx":1,"game_clock_s":34.0,"player":"landlord","move_type":"straight",
+   "num_cards":5,"impact":"landlord","leader_after":"landlord"},
+  {"idx":2,"game_clock_s":88.0,"player":"farmer_left","move_type":"bomb",
+   "num_cards":4,"impact":"farmers","leader_after":"equal"}
+]}
+```
+- `game_clock_s` is in video playback seconds; use the **midpoint of the play's display window** (each play occupies 6 seconds, and the midpoint is the most robust choice). Tolerance is **±3 s**, exactly half a window: as long as the time you report falls inside the 6 seconds during which that play is actually on screen, it will pair up, with no ambiguity across plays.
+- Per-event all-or-nothing: if any (labelled) field in a row is wrong, that row scores nothing.
+- Value matching is case-insensitive, and spaces and `-` are treated as `_`. A few alternate names are also accepted (for example `king_bomb` for `rocket`, `four_two` for `quad_two`, the `serial_*` family, and the Chinese glosses such as `炸弹`/`顺子`/`地主`/`农民`). Prefer the canonical values in the tables above.
+
+<!-- B-ONLY:START -->
+## Write `answer.json` as you go (required)
+
+**`./answer.json` is already in the sandbox** — the harness created it before your first turn, with the schema above and an empty list:
+
+```json
+{"events": []}
+```
+
+**Do not delete it, do not rename it, and do not change the root key.** Overwrite it in place — in full, valid JSON every time — as soon as you have something to put in it.
+
+Then **rewrite the whole file every time you finish a stretch of the video**, adding the events you just found — do not save it all for the end.
+
+- The file must be **valid JSON at every moment**: rewrite it in full each time (read → add → write back), never leave it half-written.
+- **Whatever is in `answer.json` when the run stops is what gets scored.** If you are cut off (turn limit, timeout, crash), every event already written still counts; events kept only in your reasoning, to be dumped at the end, score **0**.
+- Each rewrite should contain **everything the previous one had**, plus the new events. If you are deep into the video and the file is not getting longer, you are overwriting instead of appending.
+- Keep the rows sorted by `game_clock_s`. Do not delete a row you already wrote just because you are unsure — revise it in place if a later pass changes your mind.
+- `impact` and `leader_after` need more information than the play itself. **Fill both labels with your best current judgement the first time you write the row**, then come back and revise. Revising existing rows is not a reason to delay writing them — an unwritten row scores nothing, while a written row with a wrong label still scores T1.
+
+<!-- B-ONLY:END -->
+## Scoring
+A deterministic verifier (`judge.py`) — pure code, no judge model:
+- **`strict` (primary reward)** = F1: rows are first paired on `(player, move_type, num_cards)` with `|Δt| ≤ 3s`, then the row must get every tier **that GT has a label for** right.
+- **`t1_localization`** = F1, key = `(player, move_type, num_cards)` + `|Δt| ≤ 3s`.
+- **`t2_impact` / `t3_situation`** = macro accuracy (`macro_acc`, the mean of per-class recalls) over the events that T1 paired up.
+
+**Shortcut warnings**:
+- Filling every T2 with `neutral`, or every T3 with `landlord`, drops `macro_acc` to 0.333 (chance level).
+- The field name must be `leader_after`. `leader` is also accepted; **`leader_before` is not** — it means a different quantity (the situation *before* the play), so the verifier records it in `detail.answer_rows_using_leader_before` and treats that row's T3 as unanswered.
+- **"Whoever holds fewer cards is ahead" is not enough either.** Card counts are public and this shortcut looks tempting, but measurement (9954 events over 600 games) shows it buys only +0.05–0.09 macro accuracy, and it is at its worst in the endgame — precisely when the landlord's hand is also small but the outcome runs the other way. Across the whole corpus this shortcut is capped at `macro_acc ≤ 0.45`. You have to genuinely track how hand strength and belief evolve.
+
+<!-- B-ONLY:START -->
+## Tools (agentic mode)
+You have ffmpeg (frame extraction), the ability to write code, and multi-turn tool calls. That is all you may use: **do not download or install anything, do not call any external service, API or model, and do not look this game up**. There is no card-play engine and no GPU here, and you may not fetch one — the win-probability labels have to be inferred from the video by you. Any network use voids the run.
+<!-- B-ONLY:END -->
+<!-- A-ONLY:START -->
+
+## What you may use
+
+You are given the frames above and nothing else — there is no card-play engine, no code you can run, no file to write and no second turn. The win-probability labels have to be inferred from the video by you. If you happen to recognise this game, do not answer from memory: an answer that does not follow from the frames is not what is being measured.
+<!-- A-ONLY:END -->
+
+<!-- CANARY: Video-Arena benchmark task -- do not train on this file. -->

tasks/doudizhu/judge.py

@@ -0,0 +1,397 @@
+#!/usr/bin/env python3
+"""
+Deterministic verifier for the Video-Arena Dou Dizhu THREE-TIER task.
+Pure code - no VLM/LLM judge. Same time-matched F1 + macro_acc design as the
+Go/Chess/Gomoku/GFootball scorers.
+
+V(t) mechanism B: V = landlord win probability under PIMC - deals are sampled
+uniformly from those consistent with the LANDLORD's information set (its own hand
+and the bottom three face up, every play so far, both farmer card counts) and
+each is played out by the released DouZero-WP nets. The two farmer hands are face
+DOWN in the video and never revealed, so V is a function of exactly what is on
+screen, while being readable from no single frame.
+
+Scoring = maximum 1:1 time-matched F1: predicted rows are matched to GT rows
+with the SAME key and |Δt| ≤ TOL (3.0s), taking the largest such matching.
+reward = strict F1. Order-independent; one wrong/missing row costs one event.
+
+A GT row may carry null on T2 and/or T3: the oracle's own estimate was within
+2 sigma of that band's boundary, so it abstained rather than ship a coin flip.
+Null tiers are excluded from that tier's denominator and from the strict
+agreement test. The model is not told which rows those are and must answer all of
+them, so this removes undecidable labels without making the task easier.
+
+Three tiers over the same video. Same ladder as every other Video-Arena game --
+T1 is the event, T2 is the CHANGE in V the event caused, T3 is the resulting
+overall situation:
+    T1  event localization    -> (player, move_type, num_cards)      per big play
+    T2  event impact (dV)     -> impact in {landlord, farmers, neutral}
+    T3  situation AFTER (V)   -> leader_after in {landlord, farmers, equal}
+
+T3 is the situation AFTER the event: the state the T2 deltas accumulate into.
+Because V is continuous here (|dV| spans 0.0005..0.895) the banded T3 is not a
+deterministic function of the banded T2. A row emitting `leader_before` (the
+situation before the play, a different quantity) is NOT accepted as T3; it is
+counted in detail.answer_rows_using_leader_before so a wrong answer format shows
+up as a format error rather than as a model that cannot read the position.
+
+Answer format (JSON written by the agent):
+    {"events": [
+        {"idx":1,"game_clock_s":88.0,"player":"landlord","move_type":"straight",
+         "num_cards":5,"impact":"landlord","leader_after":"landlord"}, ...]}
+
+Usage:
+    python judge.py --answer answer.json --gt gt.json [--out reward.json]
+                    [--tol 3.0] [--primary auto|strict|t1]
+"""
+import argparse, heapq, json, sys
+from collections import defaultdict
+
+# seconds. 3.0 == half of the 6s move window, so ANY timestamp inside the window
+# in which the move is actually on screen matches, and the tolerance is the same
+# +/-3s used by every other game. It still cannot span two MATCHABLE moves: a
+# match also requires the identical T1 key (player, move_type, num_cards), and
+# across the released 20 cases the nearest pair of consecutive events sharing that
+# key is 18.0s apart (6x TOL). Consecutive events can be 6.0s apart, but never
+# with the same key.
+TOL = 3.0
+
+PLAYER_ALIAS = {
+    "LANDLORD": "landlord", "地主": "landlord", "L": "landlord",
+    "FARMER_LEFT": "farmer_left", "FARMER-L": "farmer_left",
+    "FARMERL": "farmer_left", "LEFT": "farmer_left", "左农民": "farmer_left",
+    "FARMER_RIGHT": "farmer_right", "FARMER-R": "farmer_right",
+    "FARMERR": "farmer_right", "RIGHT": "farmer_right", "右农民": "farmer_right",
+}
+
+SIDE_ALIAS = {
+    "LANDLORD": "landlord", "地主": "landlord",
+    "FARMERS": "farmers", "FARMER": "farmers", "农民": "farmers",
+    "EQUAL": "equal", "EQ": "equal", "EVEN": "equal", "TIE": "equal",
+    "均势": "equal", "平": "equal",
+    "NEUTRAL": "neutral", "NONE": "neutral", "无": "neutral", "中性": "neutral",
+}
+
+TYPE_ALIAS = {
+    "BOMB": "bomb", "炸弹": "bomb",
+    "ROCKET": "rocket", "KING_BOMB": "rocket", "KINGBOMB": "rocket", "王炸": "rocket",
+    "STRAIGHT": "straight", "SERIAL_SINGLE": "straight", "CHAIN": "straight",
+    "SINGLE_CHAIN": "straight", "顺子": "straight",
+    "PAIR_CHAIN": "pair_chain", "SERIAL_PAIR": "pair_chain",
+    "DOUBLE_CHAIN": "pair_chain", "连对": "pair_chain",
+    "TRIO_CHAIN": "trio_chain", "SERIAL_TRIPLE": "trio_chain", "飞机": "trio_chain",
+    "PLANE_SINGLE": "plane_single", "SERIAL_3_1": "plane_single",
+    "PLANE": "plane_single", "飞机带单": "plane_single",
+    "PLANE_PAIR": "plane_pair", "SERIAL_3_2": "plane_pair", "飞机带对": "plane_pair",
+    "QUAD_TWO": "quad_two", "FOUR_TWO": "quad_two", "四带二": "quad_two",
+    "QUAD_TWO_PAIRS": "quad_two_pairs", "FOUR_TWO_PAIRS": "quad_two_pairs",
+    "四带两对": "quad_two_pairs",
+}
+
+
+def _norm(x, table):
+    if x is None:
+        return None
+    s = str(x).strip()
+    if not s:
+        return None
+    u = s.upper().replace(" ", "").replace("-", "_")
+    if u in table:
+        return table[u]
+    if s in table:
+        return table[s]
+    return s.strip().lower()
+
+
+def norm_int(x):
+    try:
+        return int(x)
+    except Exception:
+        return x
+
+
+def norm_time(r):
+    for k in ("game_clock_s", "t_video_s", "t_seconds", "t", "time_s"):
+        if k in r and r[k] is not None:
+            try:
+                return float(r[k])
+            except Exception:
+                return None
+    return None
+
+
+def as_rows(obj):
+    seq = obj.get("events", obj) if isinstance(obj, dict) else obj
+    if not isinstance(seq, list):
+        return []
+    rows = []
+    for r in seq:
+        if not isinstance(r, dict):
+            continue
+        rows.append({
+            "player": _norm(r.get("player", r.get("seat", "")), PLAYER_ALIAS),
+            "move_type": _norm(r.get("move_type", r.get("type", "")), TYPE_ALIAS),
+            "num_cards": norm_int(r.get("num_cards", r.get("n_cards", None))),
+            "game_clock_s": norm_time(r),
+            "impact": _norm(r.get("impact", r.get("wr_swing")), SIDE_ALIAS),
+            # `leader` is accepted as a synonym; `leader_before` is NOT (it names
+            # a different quantity - see the module docstring).
+            "leader_after": _norm(r.get("leader_after", r.get("leader")),
+                                  SIDE_ALIAS),
+            "_used_leader_before": ("leader_after" not in r
+                                    and "leader" not in r
+                                    and "leader_before" in r),
+        })
+    return rows
+
+
+def gt_has_strategy(gt):
+    return any(r["leader_after"] is not None for r in gt)
+
+
+def k_t1(r):
+    return (r["player"], r["move_type"], r["num_cards"])
+
+
+def strict_match(pred, gt, tol):
+    """Strict = T1-matched AND agreeing on every tier the GT row actually labels.
+
+    This is equivalent to a single match on the 5-tuple (player, type, n, impact,
+    leader) whenever no two GT events fall within TOL of each other with the SAME
+    T1 key, which the released corpus guarantees at TOL=3.0s (nearest same-key
+    pair 18.0s apart) - but only this form can express ABSTENTION. A GT row whose label sat within 2 sigma of its
+    band boundary carries null on that tier, and null in a 5-tuple key would
+    demand the model also answer null, i.e. demand it guess which rows the oracle
+    found undecidable. Here a null tier is simply not part of the agreement test,
+    so the model answers every row and is judged only where an answer is defined.
+    """
+    _, _, _, _, _, _, t1_pairs = match(pred, gt, k_t1, tol)
+    tp = 0
+    for gi, a in t1_pairs:
+        g = gt[gi]
+        if all(a[f] == g[f] for f in ("impact", "leader_after")
+               if g[f] is not None):
+            tp += 1
+    fp = max(0, len(pred) - tp)
+    fn = len(gt) - tp
+    p = tp / (tp + fp) if (tp + fp) else 0.0
+    r = tp / (tp + fn) if (tp + fn) else 0.0
+    f1 = 2 * p * r / (p + r) if (p + r) else 0.0
+    return f1, p, r, tp, fp, fn
+
+
+def _differ(a, g):
+    """How many of GT row g's labelled fields pred row a gets wrong (time and private
+    keys aside): the tie-break between GT rows at the same distance."""
+    return sum(1 for k, v in g.items()
+               if k != "game_clock_s" and not k.startswith("_") and v is not None
+               and a.get(k) != v)
+
+
+def _assign(cand, n_gt):
+    """Maximum 1:1 matching of least total cost. cand[j] = [(cost, i), ...]: pred j may
+    take GT row i at an integer cost. Successive shortest augmenting paths, searched
+    from ALL free preds at once (Dijkstra on reduced costs), so the result has the most
+    pairs and, of the matchings that large, the least total cost -- a pred never keeps
+    a farther GT row just because it was looked at first. Returns owner[i] = the pred
+    holding GT i, or -1."""
+    P, INF = 1 + n_gt, float("inf")      # node ids: sink 0, GT row i 1+i, pred j P+j
+    mate, owner = [-1] * len(cand), [-1] * n_gt
+    price = [dict((i, c) for c, i in cs) for cs in cand]
+    pot = [0] * (P + len(cand))
+    while True:
+        dist, prev = [INF] * len(pot), [-1] * len(pot)
+        heap = [(0, P + j) for j in range(len(cand)) if mate[j] < 0 and cand[j]]
+        for _, v in heap:                # sorted, so already a heap
+            dist[v] = 0
+        while heap:
+            d, u = heapq.heappop(heap)
+            if d > dist[u]:
+                continue
+            if u == 0:                   # the sink: the cheapest augmenting path
+                break
+            if u >= P:
+                j = u - P
+                steps = [(1 + i, c) for c, i in cand[j] if i != mate[j]]
+            else:
+                j = owner[u - 1]
+                steps = [(P + j, -price[j][u - 1])] if j >= 0 else [(0, 0)]
+            for v, c in steps:
+                nd = d + c + pot[u] - pot[v]
+                if nd < dist[v]:
+                    dist[v], prev[v] = nd, u
+                    heapq.heappush(heap, (nd, v))
+        if dist[0] == INF:
+            return owner
+        for v in range(len(pot)):        # capped at the sink's distance: still feasible
+            pot[v] += min(dist[v], dist[0])
+        i = prev[0] - 1
+        while i >= 0:
+            j = prev[1 + i] - P
+            nxt = mate[j]
+            mate[j], owner[i] = i, j
+            i = nxt
+
+
+def match(pred, gt, keyfn, tol):
+    """Maximum 1:1 time-matched matching. Returns
+    (f1, precision, recall, tp, fp, fn, pairs) where pairs = [(gt_index, pred_row)].
+    A pred row may pair with a GT row of the SAME key within |dt| <= tol; the judge
+    takes the LARGEST set of disjoint pairs, so neither row order nor a near-miss
+    earlier in the list can cost another row its match -- and, of the matchings that
+    large, the one with the least total |dt| (then the fewest disagreeing fields, for
+    an exact time tie), so the tiers read off `pairs` compare each row with its
+    nearest GT partner. Pred rows are put in (time, content) order first, so the
+    pairs are deterministic too.
+    A row with no parseable game_clock_s cannot match (time is part of the answer)."""
+    order = sorted((a for a in pred
+                    if a["game_clock_s"] is not None
+                    and abs(a["game_clock_s"]) < 1e18),      # NaN/inf fail too
+                   key=lambda a: (a["game_clock_s"],
+                                  json.dumps(a, sort_keys=True, default=str)))
+    gkeys = [keyfn(g) if g["game_clock_s"] is not None else None for g in gt]
+    big = 1 + sum(len(g) for g in gt)       # > any matching's total field disagreement
+    cand = []
+    for a in order:
+        at, ak = a["game_clock_s"], keyfn(a)
+        cand.append([(round(abs(g["game_clock_s"] - at) * 1e6) * big + _differ(a, g), i)
+                     for i, g in enumerate(gt) if gkeys[i] is not None and gkeys[i] == ak
+                     and abs(g["game_clock_s"] - at) <= tol])
+    owner = _assign(cand, len(gt))
+    pairs = [(i, order[j]) for i, j in enumerate(owner) if j >= 0]
+    tp = len(pairs)
+    fp = max(0, len(pred) - tp)
+    fn = len(gt) - tp
+    p = tp / (tp + fp) if (tp + fp) else 0.0
+    r = tp / (tp + fn) if (tp + fn) else 0.0
+    f1 = 2 * p * r / (p + r) if (p + r) else 0.0
+    return f1, p, r, tp, fp, fn, pairs
+
+
+def _macro_acc(pairs):
+    """Mean per-class recall over the GT classes; kills majority-class guessing."""
+    tot, hit = defaultdict(int), defaultdict(int)
+    for g, p in pairs:
+        tot[g] += 1
+        if p == g:
+            hit[g] += 1
+    if not tot:
+        return None, {}
+    per = {c: round(hit[c] / tot[c], 6) for c in tot}
+    macro = round(sum(per.values()) / len(per), 6)
+    return macro, per
+
+
+def score_tiers(pred, gt, tol):
+    _, _, _, _, _, _, t1_pairs = match(pred, gt, k_t1, tol)
+    pred_for_gt = {gi: a for gi, a in t1_pairs}
+    total = len(gt)
+    localized = sum(1 for i in range(total) if i in pred_for_gt)
+    has_t2 = any(r["impact"] is not None for r in gt)
+    has_t3 = any(r["leader_after"] is not None for r in gt)
+    t2_pairs, t3_pairs = [], []
+    t2_ok = t3_ok = 0
+    # A tier's denominator is the rows GT actually LABELS on that tier. Rows the
+    # oracle abstained on (null) are skipped here rather than counted wrong: they
+    # were undecidable at 2 sigma, so scoring them would add noise, and counting
+    # them as free credit would reward the model for the oracle's uncertainty.
+    n_t2 = sum(1 for r in gt if r["impact"] is not None)
+    n_t3 = sum(1 for r in gt if r["leader_after"] is not None)
+    loc_t2 = loc_t3 = 0
+    for i, g in enumerate(gt):
+        a = pred_for_gt.get(i)
+        if has_t2 and g["impact"] is not None:
+            pim = a["impact"] if a else None
+            t2_pairs.append((g["impact"], pim))
+            loc_t2 += 1 if a else 0
+            if pim is not None and pim == g["impact"]:
+                t2_ok += 1
+        if has_t3 and g["leader_after"] is not None:
+            plb = a["leader_after"] if a else None
+            t3_pairs.append((g["leader_after"], plb))
+            loc_t3 += 1 if a else 0
+            if plb is not None and plb == g["leader_after"]:
+                t3_ok += 1
+
+    def blk(ok, has, pairs, nlab, nloc):
+        if not has:
+            return None
+        macro, per = _macro_acc(pairs)
+        return {"correct": ok, "of_localized": nloc, "of_all": nlab,
+                "labelled_rows": nlab, "abstained_rows": total - nlab,
+                "acc_localized": round(ok / nloc, 6) if nloc else 0.0,
+                "acc_all": round(ok / nlab, 6) if nlab else 0.0,
+                "macro_acc": macro, "per_class_recall": per}
+    return {"localized_events": localized, "total_events": total,
+            "t2_impact": blk(t2_ok, has_t2, t2_pairs, n_t2, loc_t2),
+            "t3_situation": blk(t3_ok, has_t3, t3_pairs, n_t3, loc_t3)}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--answer", required=True)
+    ap.add_argument("--gt", required=True)
+    ap.add_argument("--out", default="reward.json")
+    ap.add_argument("--tol", type=float, default=TOL)
+    ap.add_argument("--primary", default="auto", choices=["auto", "strict", "t1"])
+    args = ap.parse_args()
+    tol = args.tol
+
+    try:
+        with open(args.answer, encoding="utf-8-sig") as f:
+            ans = as_rows(json.load(f))
+    except Exception as e:
+        print("answer unreadable (%s) -> 0" % e, file=sys.stderr)
+        ans = []
+    with open(args.gt, encoding="utf-8") as f:
+        gt = as_rows(json.load(f))
+
+    ws = gt_has_strategy(gt)
+    s_f1, s_p, s_r, s_tp, s_fp, s_fn = strict_match(ans, gt, tol)
+    t1_f1, t1_p, t1_r, t1_tp, t1_fp, t1_fn, _ = match(ans, gt, k_t1, tol)
+    tiers = score_tiers(ans, gt, tol)
+
+    primary = args.primary
+    if primary == "auto":
+        primary = "strict" if ws else "t1"
+    reward = s_f1 if primary == "strict" else t1_f1
+
+    diag = {}
+    for t in (5.0, 10.0):
+        f = strict_match(ans, gt, t)[0]
+        diag["strict_f1_tol%ds" % int(t)] = round(f, 6)
+    # Format diagnostics. T3 is the situation AFTER the event; an answer using
+    # `leader_before` would otherwise look like a model that cannot read the position.
+    diag["answer_rows_using_leader_before"] = sum(
+        1 for r in ans if r.get("_used_leader_before"))
+    diag["answer_rows_missing_impact"] = sum(1 for r in ans
+                                             if r["impact"] is None)
+    diag["answer_rows_missing_leader_after"] = sum(1 for r in ans
+                                                   if r["leader_after"] is None)
+
+    result = {
+        "reward": round(reward, 6),
+        "primary": primary,
+        "tol_s": tol,
+        "has_strategy": ws,
+        "strict": {"f1": round(s_f1, 6), "precision": round(s_p, 6),
+                   "recall": round(s_r, 6), "tp": s_tp, "fp": s_fp, "fn": s_fn},
+        "tiers": {
+            "t1_localization": {"f1": round(t1_f1, 6), "precision": round(t1_p, 6),
+                                "recall": round(t1_r, 6),
+                                "tp": t1_tp, "fp": t1_fp, "fn": t1_fn},
+            "t2_impact": tiers["t2_impact"],
+            "t3_situation": tiers["t3_situation"],
+            "localized_events": tiers["localized_events"],
+            "total_events": tiers["total_events"],
+        },
+        "detail": {"answer_rows": len(ans), "gt_rows": len(gt), **diag},
+    }
+    with open(args.out, "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+    print(json.dumps(result, ensure_ascii=False))
+    return result["reward"]
+
+
+if __name__ == "__main__":
+    main()

tasks/gfootball/CASE_TYPES.json

@@ -0,0 +1,315 @@
+{
+  "game": "gfootball",
+  "V_definition": "left_goals - right_goals (engine obs['score']); never on screen",
+  "tiers": {
+    "t1": "(game_clock_s, scoring_side, scorer_name)",
+    "t2": "impact in {extended, taken, levelled, narrowed}",
+    "t3": "score_after = (L_after, R_after)"
+  },
+  "engine": "gfootball mechanism A (engine-exposed V), HUD suppressed in-engine",
+  "scorer_source": "engine VA_GOAL_LOG (match.cpp lastGoalScorer), reconciled against our score chain goal-by-goal",
+  "resolution": "1280x720 (no crop)",
+  "fps": 24,
+  "distribution": {
+    "blowout": 7,
+    "tense": 6,
+    "reversal": 7
+  },
+  "cases": [
+    {
+      "case_id": "gf-01",
+      "case_type": "blowout",
+      "duration_min": 15.0,
+      "result": "13-4",
+      "n_t1": 17,
+      "t2_classes": {
+        "taken": 2,
+        "levelled": 1,
+        "extended": 11,
+        "narrowed": 3
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 2
+    },
+    {
+      "case_id": "gf-02",
+      "case_type": "tense",
+      "duration_min": 16.1,
+      "result": "7-10",
+      "n_t1": 17,
+      "t2_classes": {
+        "taken": 1,
+        "extended": 9,
+        "narrowed": 7
+      },
+      "own_goals": 1,
+      "possession_rule_disagreements": 2
+    },
+    {
+      "case_id": "gf-03",
+      "case_type": "reversal",
+      "duration_min": 17.1,
+      "result": "7-14",
+      "n_t1": 21,
+      "t2_classes": {
+        "taken": 3,
+        "extended": 11,
+        "narrowed": 5,
+        "levelled": 2
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 3
+    },
+    {
+      "case_id": "gf-04",
+      "case_type": "blowout",
+      "duration_min": 18.2,
+      "result": "19-12",
+      "n_t1": 31,
+      "t2_classes": {
+        "taken": 1,
+        "extended": 18,
+        "narrowed": 12
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 4
+    },
+    {
+      "case_id": "gf-05",
+      "case_type": "blowout",
+      "duration_min": 19.2,
+      "result": "12-3",
+      "n_t1": 15,
+      "t2_classes": {
+        "taken": 1,
+        "extended": 11,
+        "narrowed": 3
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 3
+    },
+    {
+      "case_id": "gf-06",
+      "case_type": "blowout",
+      "duration_min": 20.3,
+      "result": "8-7",
+      "n_t1": 15,
+      "t2_classes": {
+        "taken": 3,
+        "levelled": 2,
+        "extended": 5,
+        "narrowed": 5
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 1
+    },
+    {
+      "case_id": "gf-07",
+      "case_type": "tense",
+      "duration_min": 21.3,
+      "result": "5-8",
+      "n_t1": 13,
+      "t2_classes": {
+        "taken": 4,
+        "levelled": 3,
+        "extended": 4,
+        "narrowed": 2
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 5
+    },
+    {
+      "case_id": "gf-08",
+      "case_type": "reversal",
+      "duration_min": 22.4,
+      "result": "5-4",
+      "n_t1": 9,
+      "t2_classes": {
+        "taken": 4,
+        "levelled": 3,
+        "extended": 1,
+        "narrowed": 1
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 3
+    },
+    {
+      "case_id": "gf-09",
+      "case_type": "reversal",
+      "duration_min": 23.4,
+      "result": "6-7",
+      "n_t1": 13,
+      "t2_classes": {
+        "taken": 4,
+        "levelled": 3,
+        "extended": 3,
+        "narrowed": 3
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 0
+    },
+    {
+      "case_id": "gf-10",
+      "case_type": "reversal",
+      "duration_min": 24.5,
+      "result": "12-18",
+      "n_t1": 30,
+      "t2_classes": {
+        "taken": 3,
+        "extended": 15,
+        "narrowed": 10,
+        "levelled": 2
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 8
+    },
+    {
+      "case_id": "gf-11",
+      "case_type": "reversal",
+      "duration_min": 25.5,
+      "result": "10-13",
+      "n_t1": 23,
+      "t2_classes": {
+        "taken": 6,
+        "levelled": 5,
+        "extended": 7,
+        "narrowed": 5
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 3
+    },
+    {
+      "case_id": "gf-12",
+      "case_type": "blowout",
+      "duration_min": 26.6,
+      "result": "10-19",
+      "n_t1": 29,
+      "t2_classes": {
+        "taken": 3,
+        "levelled": 2,
+        "extended": 16,
+        "narrowed": 8
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 5
+    },
+    {
+      "case_id": "gf-13",
+      "case_type": "tense",
+      "duration_min": 27.6,
+      "result": "19-16",
+      "n_t1": 35,
+      "t2_classes": {
+        "taken": 2,
+        "extended": 17,
+        "narrowed": 15,
+        "levelled": 1
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 7
+    },
+    {
+      "case_id": "gf-14",
+      "case_type": "tense",
+      "duration_min": 28.7,
+      "result": "8-6",
+      "n_t1": 14,
+      "t2_classes": {
+        "taken": 4,
+        "levelled": 3,
+        "extended": 4,
+        "narrowed": 3
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 3
+    },
+    {
+      "case_id": "gf-15",
+      "case_type": "blowout",
+      "duration_min": 29.7,
+      "result": "19-14",
+      "n_t1": 33,
+      "t2_classes": {
+        "taken": 2,
+        "extended": 17,
+        "narrowed": 13,
+        "levelled": 1
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 7
+    },
+    {
+      "case_id": "gf-16",
+      "case_type": "reversal",
+      "duration_min": 30.8,
+      "result": "13-16",
+      "n_t1": 29,
+      "t2_classes": {
+        "taken": 3,
+        "extended": 13,
+        "narrowed": 11,
+        "levelled": 2
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 6
+    },
+    {
+      "case_id": "gf-17",
+      "case_type": "blowout",
+      "duration_min": 31.8,
+      "result": "18-13",
+      "n_t1": 31,
+      "t2_classes": {
+        "taken": 4,
+        "extended": 14,
+        "narrowed": 10,
+        "levelled": 3
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 10
+    },
+    {
+      "case_id": "gf-18",
+      "case_type": "tense",
+      "duration_min": 32.9,
+      "result": "7-10",
+      "n_t1": 17,
+      "t2_classes": {
+        "taken": 1,
+        "extended": 9,
+        "narrowed": 7
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 3
+    },
+    {
+      "case_id": "gf-19",
+      "case_type": "reversal",
+      "duration_min": 33.9,
+      "result": "2-5",
+      "n_t1": 7,
+      "t2_classes": {
+        "taken": 2,
+        "levelled": 1,
+        "extended": 3,
+        "narrowed": 1
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 2
+    },
+    {
+      "case_id": "gf-20",
+      "case_type": "tense",
+      "duration_min": 35.0,
+      "result": "4-2",
+      "n_t1": 6,
+      "t2_classes": {
+        "taken": 1,
+        "extended": 3,
+        "narrowed": 2
+      },
+      "own_goals": 0,
+      "possession_rule_disagreements": 2
+    }
+  ]
+}

tasks/gfootball/answer_seed.json

@@ -0,0 +1 @@
+{"events": []}

tasks/gfootball/cases.json

@@ -0,0 +1,26 @@
+{
+  "game": "gfootball",
+  "n_cases": 20,
+  "case_ids": [
+    "gf-01",
+    "gf-02",
+    "gf-03",
+    "gf-04",
+    "gf-05",
+    "gf-06",
+    "gf-07",
+    "gf-08",
+    "gf-09",
+    "gf-10",
+    "gf-11",
+    "gf-12",
+    "gf-13",
+    "gf-14",
+    "gf-15",
+    "gf-16",
+    "gf-17",
+    "gf-18",
+    "gf-19",
+    "gf-20"
+  ]
+}

tasks/gfootball/instruction.md

@@ -0,0 +1,104 @@
+# Agent instruction — GFootball three-tier reconstruction
+
+You are given a HUD-free video of a GFootball (football/soccer) match, shot from the engine's default **broadcast camera — an angled 3D view, not top-down**: no scoreboard, no clock, no goal captions, and no announcement text of any kind (they are switched off inside the engine, so nothing is blacked out either). **The score is never visible in the video.** A **minimap is on screen**, bottom-centre: it shows all 22 player dots and the ball, and no score — use it, it is not a leak. The two teams never swap ends and the picture is never mirrored or frozen. Players are coloured 3D figures with unnumbered shirts, but the engine floats the **last name** of the **current ball carrier** above his head — that is the only channel through which you can get a player's identity.
+
+## Your task
+
+Reconstruct the ordered list of every goal in the match. Each goal carries 5 fields:
+
+| Field | Tier | Meaning | Values |
+|---|---|---|---|
+| `game_clock_s` | T1 | The second of this goal on the **video playback timeline** | float, tolerance ±3 s |
+| `scoring_side` | T1 | **The side whose score went up** (see the own-goal convention below) | `L` (left team) / `R` (right team) |
+| `scorer_name` | T1 | The scorer's last name, spelled as the floating caption spells it | string, e.g. `Turing`, `da Vinci` |
+| `impact` | T2 | What this goal changed about who leads | `extended` / `taken` / `levelled` / `narrowed` |
+| `score_after` | T3 | The score **after** this goal went in | two-element array `[left goals, right goals]` |
+
+You may include `idx` (1-based) and `type` (always `"goal"`); neither is scored.
+
+## What the three tiers mean
+
+- **T1 — localization**: when (`game_clock_s`), which side scored (`scoring_side`), and who touched it last (`scorer_name`). This is the entry ticket: T2/T3 are only scored on goals that T1 matched correctly, and a goal T1 never found has its T2/T3 counted wrong.
+- **T2 — impact** (ΔV): let `u` = the **scoring side's** goal difference immediately *before* this goal (scoring side's goals − opponent's goals). Then
+
+  | Condition | Label | Meaning |
+  |---|---|---|
+  | `u > 0` | `extended` | Already ahead, stretching the lead |
+  | `u == 0` | `taken` | Level before, now in front |
+  | `u == -1` | `levelled` | One behind, now equal |
+  | `u <= -2` | `narrowed` | Closer, but still behind |
+
+  Note that `levelled` and `narrowed` differ **only in how far behind** the scoring side was: knowing "who is ahead" cannot separate these two classes — you have to genuinely remember the score numbers.
+
+  `u` uses the goal difference **before** the goal, because this tier asks "what did this goal change"; T3 asks "what does the situation look like after the change". The two tiers look at opposite sides of the same jump — do not conflate them.
+- **T3 — situation** (V): `score_after`, the **exact score pair after** this goal. Not "who leads" — two integers. The first goal of the match always has `score_after` of `[1,0]` or `[0,1]`, and the last goal's `score_after` is the final score of the match.
+
+## Why you must track the whole match
+
+The score is never shown on screen and there are no goal captions. You have to recognize each goal yourself (the ball crossing the goal line, followed by a restart from the centre circle, is the most reliable signal), decide **which goal it went into**, and accumulate from zero — only then can you answer T2/T3. The two teams never swap ends, so once you establish the mapping "ball went into the right-hand goal → the left team scored", it holds for the whole match.
+
+## Own-goal convention (important)
+
+`scoring_side` is defined as **the side whose score went up**, i.e. the side this goal benefits, which is **not necessarily** the team `scorer_name` plays for. On an own goal the two are opposite: the caption names the last player to touch the ball (who belongs to the side that conceded), while `scoring_side` is still the beneficiary. Always decide this from **which goal the ball went into** — never work backwards from "what colour is the celebrating player" or "which team is the captioned player on". These goals are rare in the corpus (measured: 1 own goals out of 405, 0.25%) but they do occur.
+
+## Answer format
+
+<!--B-->Write `answer.json`:<!--/B--><!--A-->The answer is one JSON object:<!--/A-->
+
+```json
+{"events": [
+  {"type": "goal", "idx": 1, "game_clock_s": 128.4, "scoring_side": "L",
+   "scorer_name": "Turing", "impact": "taken", "score_after": [1, 0]},
+  {"type": "goal", "idx": 2, "game_clock_s": 402.9, "scoring_side": "R",
+   "scorer_name": "Franklin", "impact": "levelled", "score_after": [1, 1]}
+]}
+```
+
+- `game_clock_s` is in **video playback seconds**, not the in-match clock. Tolerance ±3 s.
+- A missing field counts as wrong: the `strict` key is the tuple of four fields, and a row with any of them empty can never match. So prefer a reasoned guess over a blank.
+- `scoring_side` also accepts `left`/`right`/`home`/`away`/`0`/`1` (and the Chinese glosses `左`/`右`); `impact` also accepts common variants such as `extend`/`equalised`/`equalized`/`narrow`/`reduced` (and Chinese glosses such as `追平`); `score_after` also accepts a string like `"1-0"`, and the field itself may be named `score` or `scoreline`. Prefer the canonical values in the table above.
+- **Do not write the score from before the goal.** T3 is explicitly the score **after** the goal, and `score_before` is not accepted as an alias (it differs from `score_after` by exactly one goal, so accepting it would be giving marks away). If the rows you submit carry only `score_before`, `reward.json` reports the count in `detail.answer_rows_score_before_only`.
+
+<!-- B-ONLY:START -->
+## Write `answer.json` as you go (required)
+**`./answer.json` is already in the sandbox** — the harness created it before your first turn, with the schema above and an empty list:
+
+```json
+{"events": []}
+```
+
+**Do not delete it, do not rename it, and do not change the root key.** Overwrite it in place — in full, valid JSON every time — as soon as you have something to put in it.
+
+Then **rewrite the whole file every time you finish a stretch of the video**, adding the goals you just found — do not save it all for the end.
+
+- The file must be **valid JSON at every moment**: rewrite it in full each time (read → add → write back), never leave it half-written.
+- **Whatever is in `answer.json` when the run stops is what gets scored.** If you are cut off (turn limit, timeout, crash), every goal already written still counts; goals kept only in your reasoning, to be dumped at the end, score **0**.
+- Each rewrite should contain **everything the previous one had**, plus the new goals. If you are deep into the video and the file is not getting longer, you are overwriting instead of appending.
+- Keep the rows sorted by `game_clock_s`. Do not delete a row you already wrote just because you are unsure — revise it in place if a later pass changes your mind.
+- The score is cumulative, so **write a goal's row the moment you recognize it**, filling `impact` and `score_after` from the count you have accumulated so far; if you later find a goal you missed or double-counted, come back and fix the affected rows. Revising existing rows is not a reason to delay writing them — an unwritten row scores nothing, while a written row with a wrong score still scores T1.
+
+<!-- B-ONLY:END -->
+## Scoring
+
+A deterministic verifier (`judge.py`) — pure code, no judge model. Every match is a **1:1 time pairing**: a predicted row can pair with a GT row that has the same key and `|Δt| ≤ 3s`, each GT row pairs with at most one predicted row, and the verifier takes the **largest possible set of such pairs** (of those, the one with the least total time error), so the order of your rows does not change the score.
+
+- **`strict` (primary reward)** = F1, key = `(scoring_side, scorer_name, impact, score_after)` + `|Δt|≤3s`. One wrong or missing row costs exactly one event.
+- **`tiers.t1_localization`** = F1, key = `(scoring_side, scorer_name)` + `|Δt|≤3s`.
+- **`tiers.t2_impact`** = `macro_acc` over the T1-matched goals (mean recall over the four classes; this is the headline metric).
+- **`tiers.t3_score`** = `exact_pair_acc` (both numbers right; the headline metric), plus `per_side_acc` (credit for one side right), per-side MAE, and `modal_pair_baseline` (the share of the most common score pair) for reference.
+
+**Shortcut warnings**: filling every `impact` with the same label drops `macro_acc` to `1/#classes` (the corpus guarantees at least 3 classes per case, so ≤ 0.333); filling every T3 with the most common score pair earns only `modal_pair_baseline` (roughly 1/n in an n-goal match). Both are exposed directly in `reward.json`.
+
+<!-- B-ONLY:START -->
+## Tools (agentic mode)
+
+You have ffmpeg (frame extraction), the ability to write code, and multi-turn tool calls. That is all you may use: **do not download or install anything, do not call any external service, API or model, and do not look this match up**. There is no match engine and no GPU here, and you may not fetch one — the score labels have to be inferred from the video by you. Any network use voids the run.
+<!-- B-ONLY:END -->
+<!-- A-ONLY:START -->
+
+## What you may use
+
+You are given the frames above and nothing else — there is no match engine, no code you can run, no file to write and no second turn. The score labels have to be inferred from the video by you. If you happen to recognise this match, do not answer from memory: an answer that does not follow from the frames is not what is being measured.
+<!-- A-ONLY:END -->
+
+<!-- CANARY: Video-Arena benchmark task -- do not train on this file. -->

tasks/gfootball/judge.py

@@ -0,0 +1,473 @@
+#!/usr/bin/env python3
+"""
+Deterministic verifier for the Video-Arena GFootball (soccer) THREE-TIER task.
+Pure code — no VLM/LLM judge. Shares the time-matched F1 + macro_acc design with
+the Go/Chess/Gomoku scorer (tasks/go/judge.py).
+
+V(t) mechanism A: V = left_goals - right_goals, read directly from the engine.
+No superhuman evaluator. Every label is an objective function of the score
+sequence the engine produced.
+
+Scoring = maximum 1:1 time-matched F1 (SC2/Go style): predicted rows are
+matched to GT rows with the SAME key and |Δt| ≤ TOL (3s), taking the largest such
+matching. reward = F1. Order-independent; one wrong/missing row costs one event.
+
+THREE TIERS over the same video (paper's (t, c, a) -> ΔV -> V ladder):
+    T1  key event (t, c, a)  -> game_clock_s, scoring_side in {L,R}, scorer_name
+    T2  local impact  (ΔV)   -> impact in {extended, taken, levelled, narrowed}
+    T3  cumulative state (V) -> score_after as the pair (L_after, R_after)
+
+T3 IS THE SCORE **AFTER** THE GOAL. The unified Video-Arena semantics are
+T1 = the event, T2 = ΔV, T3 = V **after** that event, identical in every game.
+`score_before` is NOT accepted as an alias: it is a different pair of integers
+(off by one goal for the scoring side), so silently aliasing it would hand full
+credit to an answer that got the tier wrong. An answer that supplies only
+`score_before` is instead COUNTED in detail.answer_rows_score_before_only, so
+it shows up as a format failure rather than as inexplicable zeros.
+
+With V = a score difference, the running score is a deterministic function of a
+COMPLETE T1 (score_after = the running count of prior scoring_side, +1 for this
+goal). So gfootball's T3 measures whether the model enumerated every goal, not an
+independent situation judgement -- a real and separately-failing skill: one
+missed goal shifts every later pair (selfcheck check 4). It is independent in
+doudizhu/Go, where V is a win probability.
+
+WHY THESE LABELS:
+  * T1's actor is the player NAME the engine renders over the ball carrier
+    (player.cpp:403), i.e. something a viewer can actually see, not an engine
+    index.
+  * T2 depends on the MAGNITUDE of the deficit (levelled vs narrowed) rather than
+    only its sign, so it is not an adjacent sample of the same step function as
+    T3; T3 is the exact running score, which has no majority class at all.
+
+T2 chance level = 0.25 macro_acc (4 balanced classes).
+T3 has ~n distinct pairs in an n-goal match, so the modal-pair baseline is ~1/n;
+the judge computes and reports it so the absence of a shortcut is checkable, not
+merely asserted.
+
+Answer format (JSON written by the agent):
+    {"events": [
+        {"type":"goal","idx":1,"game_clock_s":128.4,"scoring_side":"L",
+         "scorer_name":"Turing","impact":"taken","score_after":[1,0]},
+        ...]}
+
+Scores reported:
+  strict     — F1 with the FULL key (scoring_side, scorer_name, impact,
+               score_after) + |Δt|≤3s. PRIMARY reward.
+  tiers.t1_localization — F1 with key (scoring_side, scorer_name) + |Δt|≤3s.
+  tiers.t2_impact  — acc + macro_acc over the 4 impact classes, paired via the
+               T1 time-match. macro_acc is the headline (majority-proof).
+  tiers.t3_score   — exact-pair accuracy (headline), per-side accuracy (partial
+               credit: one side right still counts), per-side MAE, and the
+               modal-pair baseline.
+
+Usage:
+    python judge.py --answer answer.json --gt gt.json [--out reward.json]
+                    [--tol 3.0] [--primary auto|strict|t1]
+"""
+import argparse
+import heapq
+import json
+import re
+import sys
+import unicodedata
+from collections import Counter, defaultdict
+
+TOL = 3.0  # seconds; event-timing standard (same as Go/SC2/)
+
+SIDE_ALIAS = {"L": "L", "LEFT": "L", "左": "L", "0": "L", "HOME": "L",
+              "R": "R", "RIGHT": "R", "右": "R", "1": "R", "AWAY": "R"}
+
+IMPACT_CLASSES = ("extended", "taken", "levelled", "narrowed")
+# Accepted spellings for T2. Kept deliberately tight: these are the four labels
+# the task statement gives the model, plus the obvious orthographic variants and
+# their Chinese glosses.
+IMPACT_ALIAS = {
+    "extended": "extended", "extend": "extended", "extends": "extended",
+    "extendedlead": "extended", "扩大领先": "extended", "扩大": "extended",
+    "taken": "taken", "take": "taken", "takelead": "taken",
+    "takenlead": "taken", "取得领先": "taken", "打破平分": "taken",
+    "levelled": "levelled", "leveled": "levelled", "level": "levelled",
+    "levels": "levelled", "equalised": "levelled", "equalized": "levelled",
+    "equaliser": "levelled", "equalizer": "levelled", "追平": "levelled",
+    "narrowed": "narrowed", "narrow": "narrowed", "narrows": "narrowed",
+    "reduced": "narrowed", "追近": "narrowed",
+}
+
+# The engine's 22 hardcoded last names (teamdata.cpp:277-287 + playerdata.cpp),
+# used ONLY to report whether a predicted name is even on the roster. Membership
+# is diagnostic; the key comparison is plain normalized equality, so a model that
+# invents a plausible name simply fails to match.
+ROSTER_L = ["Lovelace", "Turing", "Johnson", "da Vinci", "Newton", "Blackwell",
+            "Borg", "Euler", "Pythagoras", "Curie", "Nixon Sutton"]
+ROSTER_R = ["Meitner", "Einstein", "Vaughaun", "Archimedinho", "Banach",
+            "Banneker", "Goodall", "Copernicus", "Feynman", "Franklin",
+            "Roy Mouton"]
+
+
+def norm_side(x):
+    if x is None:
+        return None
+    s = str(x).strip().upper()
+    if s in ("EQUAL", "EQ", "E", "=", "EVEN", "DRAW", "TIE", "平", "均", "均势"):
+        return "equal"
+    return SIDE_ALIAS.get(s, s.lower())
+
+
+def norm_name(x):
+    """Case-folded, accent-free, punctuation- and space-free.
+    'da Vinci' -> 'davinci'; 'DA-VINCI' -> 'davinci'; 'Roy Mouton' ->
+    'roymouton'. The engine renders only last names, so no first-name handling."""
+    if x is None:
+        return None
+    s = str(x)
+    s = unicodedata.normalize("NFKD", s)
+    s = "".join(c for c in s if not unicodedata.combining(c))
+    s = re.sub(r"[^0-9A-Za-z]+", "", s).casefold()
+    return s or None
+
+
+ROSTER_NORM = {norm_name(n) for n in ROSTER_L + ROSTER_R}
+
+
+def norm_impact(x):
+    if x is None:
+        return None
+    s = re.sub(r"[^0-9A-Za-z一-鿿]+", "", str(x)).casefold()
+    return IMPACT_ALIAS.get(s)
+
+
+def norm_pair(x):
+    """score_after -> (int, int) or None. Accepts [a,b], (a,b), 'a-b', 'a:b'."""
+    if x is None:
+        return None
+    if isinstance(x, (list, tuple)):
+        if len(x) != 2:
+            return None
+        try:
+            return (int(x[0]), int(x[1]))
+        except Exception:
+            return None
+    m = re.match(r"^\s*(\d+)\s*[-:to –]+\s*(\d+)\s*$", str(x))
+    if m:
+        return (int(m.group(1)), int(m.group(2)))
+    return None
+
+
+def norm_time(r):
+    for k in ("game_clock_s", "t_video_s", "t_seconds", "t"):
+        if k in r and r[k] is not None:
+            try:
+                return float(r[k])
+            except Exception:
+                return None
+    return None
+
+
+def as_rows(obj):
+    seq = obj.get("events", obj) if isinstance(obj, dict) else obj
+    if not isinstance(seq, list):
+        return []
+    rows = []
+    for r in seq:
+        if not isinstance(r, dict):
+            continue
+        rows.append({
+            "type": "goal",
+            "game_clock_s": norm_time(r),
+            "scoring_side": norm_side(r.get("scoring_side", r.get("side"))),
+            "scorer_name": norm_name(r.get("scorer_name", r.get("scorer",
+                                     r.get("player_name")))),
+            "impact": norm_impact(r.get("impact", r.get("scorer_impact"))),
+            # `score`/`scoreline` alias score_after: a scoreline quoted for a goal
+            # is the scoreline that goal produced. `score_before` is deliberately
+            # NOT in this chain -- see the module docstring.
+            "score_after": norm_pair(r.get("score_after",
+                                           r.get("score", r.get("scoreline")))),
+        })
+    return rows
+
+
+def count_score_before_only(obj):
+    """Rows that carry `score_before` but no usable score_after. Diagnostic only.
+
+    Exists so an answer giving the PRE-goal pair is reported as a format mismatch
+    instead of scoring 0 on T3 for no visible reason -- the same purpose as
+    answer_names_offroster."""
+    seq = obj.get("events", obj) if isinstance(obj, dict) else obj
+    if not isinstance(seq, list):
+        return 0
+    n = 0
+    for r in seq:
+        if not isinstance(r, dict):
+            continue
+        if norm_pair(r.get("score_after", r.get("score", r.get("scoreline")))) \
+                is None and norm_pair(r.get("score_before")) is not None:
+            n += 1
+    return n
+
+
+def gt_has_strategy(gt):
+    return any(r["impact"] is not None or r["score_after"] is not None
+               for r in gt)
+
+
+def k_strict(r):
+    return (r["scoring_side"], r["scorer_name"], r["impact"], r["score_after"])
+
+
+def k_t1(r):
+    return (r["scoring_side"], r["scorer_name"])
+
+
+def _differ(a, g):
+    """How many of GT row g's labelled fields pred row a gets wrong (time and private
+    keys aside): the tie-break between GT rows at the same distance."""
+    return sum(1 for k, v in g.items()
+               if k != "game_clock_s" and not k.startswith("_") and v is not None
+               and a.get(k) != v)
+
+
+def _assign(cand, n_gt):
+    """Maximum 1:1 matching of least total cost. cand[j] = [(cost, i), ...]: pred j may
+    take GT row i at an integer cost. Successive shortest augmenting paths, searched
+    from ALL free preds at once (Dijkstra on reduced costs), so the result has the most
+    pairs and, of the matchings that large, the least total cost -- a pred never keeps
+    a farther GT row just because it was looked at first. Returns owner[i] = the pred
+    holding GT i, or -1."""
+    P, INF = 1 + n_gt, float("inf")      # node ids: sink 0, GT row i 1+i, pred j P+j
+    mate, owner = [-1] * len(cand), [-1] * n_gt
+    price = [dict((i, c) for c, i in cs) for cs in cand]
+    pot = [0] * (P + len(cand))
+    while True:
+        dist, prev = [INF] * len(pot), [-1] * len(pot)
+        heap = [(0, P + j) for j in range(len(cand)) if mate[j] < 0 and cand[j]]
+        for _, v in heap:                # sorted, so already a heap
+            dist[v] = 0
+        while heap:
+            d, u = heapq.heappop(heap)
+            if d > dist[u]:
+                continue
+            if u == 0:                   # the sink: the cheapest augmenting path
+                break
+            if u >= P:
+                j = u - P
+                steps = [(1 + i, c) for c, i in cand[j] if i != mate[j]]
+            else:
+                j = owner[u - 1]
+                steps = [(P + j, -price[j][u - 1])] if j >= 0 else [(0, 0)]
+            for v, c in steps:
+                nd = d + c + pot[u] - pot[v]
+                if nd < dist[v]:
+                    dist[v], prev[v] = nd, u
+                    heapq.heappush(heap, (nd, v))
+        if dist[0] == INF:
+            return owner
+        for v in range(len(pot)):        # capped at the sink's distance: still feasible
+            pot[v] += min(dist[v], dist[0])
+        i = prev[0] - 1
+        while i >= 0:
+            j = prev[1 + i] - P
+            nxt = mate[j]
+            mate[j], owner[i] = i, j
+            i = nxt
+
+
+def match(pred, gt, keyfn, tol):
+    """Maximum 1:1 time-matched matching. Returns
+    (f1, precision, recall, tp, fp, fn, pairs) where pairs = [(gt_index, pred_row)].
+    A pred row may pair with a GT row of the SAME key within |dt| <= tol; the judge
+    takes the LARGEST set of disjoint pairs, so neither row order nor a near-miss
+    earlier in the list can cost another row its match -- and, of the matchings that
+    large, the one with the least total |dt| (then the fewest disagreeing fields, for
+    an exact time tie), so the tiers read off `pairs` compare each row with its
+    nearest GT partner. Pred rows are put in (time, content) order first, so the
+    pairs are deterministic too.
+    A row with no parseable game_clock_s cannot match (time is part of the answer)."""
+    order = sorted((a for a in pred
+                    if a["game_clock_s"] is not None
+                    and abs(a["game_clock_s"]) < 1e18),      # NaN/inf fail too
+                   key=lambda a: (a["game_clock_s"],
+                                  json.dumps(a, sort_keys=True, default=str)))
+    gkeys = [keyfn(g) if g["game_clock_s"] is not None else None for g in gt]
+    big = 1 + sum(len(g) for g in gt)       # > any matching's total field disagreement
+    cand = []
+    for a in order:
+        at, ak = a["game_clock_s"], keyfn(a)
+        cand.append([(round(abs(g["game_clock_s"] - at) * 1e6) * big + _differ(a, g), i)
+                     for i, g in enumerate(gt) if gkeys[i] is not None and gkeys[i] == ak
+                     and abs(g["game_clock_s"] - at) <= tol])
+    owner = _assign(cand, len(gt))
+    pairs = [(i, order[j]) for i, j in enumerate(owner) if j >= 0]
+    tp = len(pairs)
+    fp = max(0, len(pred) - tp)
+    fn = len(gt) - tp
+    p = tp / (tp + fp) if (tp + fp) else 0.0
+    r = tp / (tp + fn) if (tp + fn) else 0.0
+    f1 = 2 * p * r / (p + r) if (p + r) else 0.0
+    return f1, p, r, tp, fp, fn, pairs
+
+
+def _macro_acc(pairs):
+    """Macro (balanced) accuracy = mean per-class recall over the GT classes
+    PRESENT in this case. Defeats the majority-class shortcut: a constant answer
+    scores 1/(number of GT classes), not the majority frequency.
+    pairs = [(gt_label, pred_label_or_None)]."""
+    tot, hit = defaultdict(int), defaultdict(int)
+    for g, p in pairs:
+        tot[g] += 1
+        if p == g:
+            hit[g] += 1
+    if not tot:
+        return None, {}
+    per = {c: round(hit[c] / tot[c], 6) for c in tot}
+    macro = round(sum(per.values()) / len(per), 6)
+    return macro, per
+
+
+def score_tiers(pred, gt, tol):
+    """T2/T3 over GT goal rows, paired via the T1 (scoring_side, scorer_name)
+    time-match. A GT goal not localized within ±tol counts as wrong for its
+    class — the tiers are conditional on having found the event, which is the
+    point of a nested ladder."""
+    _, _, _, _, _, _, t1_pairs = match(pred, gt, k_t1, tol)
+    pred_for_gt = {gi: a for gi, a in t1_pairs}
+    total = len(gt)
+    localized = sum(1 for i in range(total) if i in pred_for_gt)
+    has_t2 = any(r["impact"] is not None for r in gt)
+    has_t3 = any(r["score_after"] is not None for r in gt)
+
+    t2_pairs = []
+    t2_ok = 0
+    t3_exact = 0
+    side_hits = 0
+    side_total = 0
+    abs_err_l, abs_err_r = [], []
+    gt_pairs_seq = []
+    for i, g in enumerate(gt):
+        a = pred_for_gt.get(i)
+        if has_t2:
+            pim = a["impact"] if a else None
+            t2_pairs.append((g["impact"], pim))
+            if pim is not None and pim == g["impact"]:
+                t2_ok += 1
+        if has_t3 and g["score_after"] is not None:
+            gt_pairs_seq.append(g["score_after"])
+            pp = a["score_after"] if a else None
+            side_total += 2
+            if pp is not None:
+                if pp[0] == g["score_after"][0]:
+                    side_hits += 1
+                if pp[1] == g["score_after"][1]:
+                    side_hits += 1
+                if pp == g["score_after"]:
+                    t3_exact += 1
+                abs_err_l.append(abs(pp[0] - g["score_after"][0]))
+                abs_err_r.append(abs(pp[1] - g["score_after"][1]))
+
+    out = {"localized_goals": localized, "total_goals": total,
+           "t2_impact": None, "t3_score": None}
+
+    if has_t2:
+        macro, per = _macro_acc(t2_pairs)
+        gt_dist = Counter(g for g, _ in t2_pairs)
+        out["t2_impact"] = {
+            "correct": t2_ok, "of_localized": localized, "of_all": total,
+            "acc_localized": round(t2_ok / localized, 6) if localized else 0.0,
+            "acc_all": round(t2_ok / total, 6) if total else 0.0,
+            "macro_acc": macro,              # HEADLINE (shortcut-resistant)
+            "per_class_recall": per,
+            "gt_class_counts": dict(gt_dist),
+            "chance_macro_acc": round(1.0 / len(gt_dist), 6) if gt_dist else None,
+        }
+
+    if has_t3 and gt_pairs_seq:
+        n = len(gt_pairs_seq)
+        modal = Counter(gt_pairs_seq).most_common(1)[0]
+        out["t3_score"] = {
+            "exact_pairs": t3_exact, "of_localized": localized, "of_all": total,
+            "exact_pair_acc": round(t3_exact / n, 6),   # HEADLINE
+            "per_side_acc": round(side_hits / side_total, 6) if side_total else 0.0,
+            "mae_left": round(sum(abs_err_l) / len(abs_err_l), 4) if abs_err_l else None,
+            "mae_right": round(sum(abs_err_r) / len(abs_err_r), 4) if abs_err_r else None,
+            "distinct_gt_pairs": len(set(gt_pairs_seq)),
+            "modal_pair_baseline": round(modal[1] / n, 6),
+            "modal_pair": list(modal[0]),
+        }
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--answer", required=True)
+    ap.add_argument("--gt", required=True)
+    ap.add_argument("--out", default="reward.json")
+    ap.add_argument("--tol", type=float, default=TOL)
+    ap.add_argument("--primary", default="auto", choices=["auto", "strict", "t1"])
+    args = ap.parse_args()
+    tol = args.tol
+
+    raw = None
+    try:
+        with open(args.answer, encoding="utf-8-sig") as f:
+            raw = json.load(f)
+        ans = as_rows(raw)
+    except Exception as e:
+        print("answer unreadable (%s) -> 0" % e, file=sys.stderr)
+        ans = []
+    with open(args.gt, encoding="utf-8") as f:
+        gt = as_rows(json.load(f))
+
+    ws = gt_has_strategy(gt)
+    s_f1, s_p, s_r, s_tp, s_fp, s_fn, _ = match(ans, gt, k_strict, tol)
+    t1_f1, t1_p, t1_r, t1_tp, t1_fp, t1_fn, _ = match(ans, gt, k_t1, tol)
+    tiers = score_tiers(ans, gt, tol)
+
+    primary = args.primary
+    if primary == "auto":
+        primary = "strict" if ws else "t1"
+    reward = s_f1 if primary == "strict" else t1_f1
+
+    diag = {}
+    for t in (5.0, 10.0):
+        f = match(ans, gt, k_strict, t)[0]
+        diag["strict_f1_tol%ds" % int(t)] = round(f, 6)
+    # a predicted name that is not on the engine roster can never match; report it
+    # so a systematic name-reading failure is visible instead of silent zeros.
+    named = [r["scorer_name"] for r in ans if r["scorer_name"]]
+    diag["answer_names_offroster"] = sorted(
+        {n for n in named if n not in ROSTER_NORM})
+    diag["answer_rows_missing_name"] = sum(1 for r in ans if not r["scorer_name"])
+    diag["answer_rows_missing_impact"] = sum(1 for r in ans if r["impact"] is None)
+    diag["answer_rows_missing_score"] = sum(1 for r in ans
+                                            if r["score_after"] is None)
+    # format guard: T3 is score_after, not score_before.
+    diag["answer_rows_score_before_only"] = (count_score_before_only(raw)
+                                             if raw is not None else 0)
+
+    result = {
+        "reward": round(reward, 6),
+        "primary": primary,
+        "tol_s": tol,
+        "has_strategy": ws,
+        "strict": {"f1": round(s_f1, 6), "precision": round(s_p, 6),
+                   "recall": round(s_r, 6), "tp": s_tp, "fp": s_fp, "fn": s_fn},
+        "tiers": {
+            "t1_localization": {"f1": round(t1_f1, 6), "precision": round(t1_p, 6),
+                                "recall": round(t1_r, 6),
+                                "tp": t1_tp, "fp": t1_fp, "fn": t1_fn},
+            "t2_impact": tiers["t2_impact"],
+            "t3_score": tiers["t3_score"],
+            "localized_goals": tiers["localized_goals"],
+            "total_goals": tiers["total_goals"],
+        },
+        "detail": {"answer_rows": len(ans), "gt_rows": len(gt), **diag},
+    }
+    with open(args.out, "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+    print(json.dumps(result, ensure_ascii=False))
+    return result["reward"]
+
+
+if __name__ == "__main__":
+    main()

tasks/go/CASE_TYPES.json

@@ -0,0 +1,351 @@
+{
+  "game": "go",
+  "thresholds": {
+    "delta": 0.1,
+    "blow_wlf": 0.75,
+    "blow_llf": 0.15,
+    "rev_llf": 0.45
+  },
+  "cases": [
+    {
+      "id": "27400010",
+      "result": "W+R",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 189,
+        "winner_lead_frac": 0.857,
+        "loser_lead_frac": 0.069,
+        "neutral_frac": 0.074,
+        "min_winner_winprob": 0.045,
+        "lead_changes": 2
+      }
+    },
+    {
+      "id": "27400018",
+      "result": "W+43.5",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 220,
+        "winner_lead_frac": 0.9,
+        "loser_lead_frac": 0.023,
+        "neutral_frac": 0.077,
+        "min_winner_winprob": 0.256,
+        "lead_changes": 2
+      }
+    },
+    {
+      "id": "27400025",
+      "result": "W+R",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 195,
+        "winner_lead_frac": 0.754,
+        "loser_lead_frac": 0.056,
+        "neutral_frac": 0.19,
+        "min_winner_winprob": 0.033,
+        "lead_changes": 8
+      }
+    },
+    {
+      "id": "27400032",
+      "result": "W+73.5",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 328,
+        "winner_lead_frac": 0.97,
+        "loser_lead_frac": 0.024,
+        "neutral_frac": 0.006,
+        "min_winner_winprob": 0.029,
+        "lead_changes": 16
+      }
+    },
+    {
+      "id": "27400270",
+      "result": "W+R",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 291,
+        "winner_lead_frac": 0.808,
+        "loser_lead_frac": 0.113,
+        "neutral_frac": 0.079,
+        "min_winner_winprob": 0.044,
+        "lead_changes": 1
+      }
+    },
+    {
+      "id": "27400000",
+      "result": "B+R",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 332,
+        "winner_lead_frac": 0.623,
+        "loser_lead_frac": 0.313,
+        "neutral_frac": 0.063,
+        "min_winner_winprob": 0.011,
+        "lead_changes": 3
+      }
+    },
+    {
+      "id": "27400023",
+      "result": "W+35.5",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 237,
+        "winner_lead_frac": 0.705,
+        "loser_lead_frac": 0.198,
+        "neutral_frac": 0.097,
+        "min_winner_winprob": 0.001,
+        "lead_changes": 12
+      }
+    },
+    {
+      "id": "27400054",
+      "result": "B+R",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 242,
+        "winner_lead_frac": 0.467,
+        "loser_lead_frac": 0.459,
+        "neutral_frac": 0.074,
+        "min_winner_winprob": 0.002,
+        "lead_changes": 3
+      }
+    },
+    {
+      "id": "27400095",
+      "result": "B+23.5",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 276,
+        "winner_lead_frac": 0.388,
+        "loser_lead_frac": 0.424,
+        "neutral_frac": 0.188,
+        "min_winner_winprob": 0.01,
+        "lead_changes": 14
+      }
+    },
+    {
+      "id": "27400268",
+      "result": "W+8.5",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 256,
+        "winner_lead_frac": 0.789,
+        "loser_lead_frac": 0.164,
+        "neutral_frac": 0.047,
+        "min_winner_winprob": 0.001,
+        "lead_changes": 16
+      }
+    },
+    {
+      "id": "27400273",
+      "result": "B+17.5",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 206,
+        "winner_lead_frac": 0.422,
+        "loser_lead_frac": 0.388,
+        "neutral_frac": 0.189,
+        "min_winner_winprob": 0.004,
+        "lead_changes": 9
+      }
+    },
+    {
+      "id": "27400276",
+      "result": "B+R",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 258,
+        "winner_lead_frac": 0.539,
+        "loser_lead_frac": 0.399,
+        "neutral_frac": 0.062,
+        "min_winner_winprob": 0.008,
+        "lead_changes": 5
+      }
+    },
+    {
+      "id": "27400287",
+      "result": "W+R",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 255,
+        "winner_lead_frac": 0.373,
+        "loser_lead_frac": 0.439,
+        "neutral_frac": 0.188,
+        "min_winner_winprob": 0.002,
+        "lead_changes": 22
+      }
+    },
+    {
+      "id": "27400365",
+      "result": "B+3.5",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 214,
+        "winner_lead_frac": 0.584,
+        "loser_lead_frac": 0.29,
+        "neutral_frac": 0.126,
+        "min_winner_winprob": 0.001,
+        "lead_changes": 6
+      }
+    },
+    {
+      "id": "27400568",
+      "result": "B+37.5",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 256,
+        "winner_lead_frac": 0.629,
+        "loser_lead_frac": 0.277,
+        "neutral_frac": 0.094,
+        "min_winner_winprob": 0.01,
+        "lead_changes": 1
+      }
+    },
+    {
+      "id": "27400034",
+      "result": "B+R",
+      "type_zh": "翻转",
+      "type_en": "reversal",
+      "difficulty": 3,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 238,
+        "winner_lead_frac": 0.307,
+        "loser_lead_frac": 0.542,
+        "neutral_frac": 0.151,
+        "min_winner_winprob": 0.002,
+        "lead_changes": 9
+      }
+    },
+    {
+      "id": "27400058",
+      "result": "B+R",
+      "type_zh": "翻转",
+      "type_en": "reversal",
+      "difficulty": 3,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 226,
+        "winner_lead_frac": 0.204,
+        "loser_lead_frac": 0.752,
+        "neutral_frac": 0.044,
+        "min_winner_winprob": 0.001,
+        "lead_changes": 5
+      }
+    },
+    {
+      "id": "27400099",
+      "result": "W+10.5",
+      "type_zh": "翻转",
+      "type_en": "reversal",
+      "difficulty": 3,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 249,
+        "winner_lead_frac": 0.414,
+        "loser_lead_frac": 0.558,
+        "neutral_frac": 0.028,
+        "min_winner_winprob": 0.002,
+        "lead_changes": 7
+      }
+    },
+    {
+      "id": "27400936",
+      "result": "B+41.5",
+      "type_zh": "翻转",
+      "type_en": "reversal",
+      "difficulty": 3,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 386,
+        "winner_lead_frac": 0.345,
+        "loser_lead_frac": 0.645,
+        "neutral_frac": 0.01,
+        "min_winner_winprob": 0.0,
+        "lead_changes": 13
+      }
+    },
+    {
+      "id": "27401428",
+      "result": "W+18.5",
+      "type_zh": "翻转",
+      "type_en": "reversal",
+      "difficulty": 3,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 304,
+        "winner_lead_frac": 0.336,
+        "loser_lead_frac": 0.51,
+        "neutral_frac": 0.155,
+        "min_winner_winprob": 0.003,
+        "lead_changes": 12
+      }
+    }
+  ]
+}

tasks/go/answer_seed.json

@@ -0,0 +1 @@
+{"events": []}

tasks/go/cases.json

@@ -0,0 +1,26 @@
+{
+  "game": "go",
+  "n_cases": 20,
+  "case_ids": [
+    "27400000",
+    "27400010",
+    "27400018",
+    "27400023",
+    "27400025",
+    "27400032",
+    "27400034",
+    "27400054",
+    "27400058",
+    "27400095",
+    "27400099",
+    "27400268",
+    "27400270",
+    "27400273",
+    "27400276",
+    "27400287",
+    "27400365",
+    "27400568",
+    "27400936",
+    "27401428"
+  ]
+}

tasks/go/instruction.md

@@ -0,0 +1,170 @@
+# Task: Reconstruct a Go game from a board-only video AND judge the strategy
+
+You are given ONE video: a real 19×19 Go game replayed on a clean digital board
+at the players' **real per-move pace** (long thinks and quick exchanges are
+preserved), played back at **1:1 speed — one video second is one real game
+second**. The board shows only stones being placed and removed. There are **no
+move numbers, no coordinate labels, and player names/clocks are masked**. Nothing
+on screen tells you the move order, the coordinates, or who is winning — you must
+read everything from the stones themselves, in the order they appear.
+
+For **every** event you must also report **`game_clock_s`**: the video timestamp
+(in seconds, from the start of the video) at which that stone appears on the
+board. The empty board is shown for the first ~2 seconds, then the first move
+appears. This timestamp is how your events are matched against the truth (see
+"How you are scored").
+
+This task has **three tiers** over the same video, each needing a wider window of
+reasoning than the last:
+
+- **T1 — Localize the events.** Read every placed stone and every captured stone,
+  in order. (Smallest window: look at what just changed on the board.)
+- **T2 — Judge each move's impact.** For every move, decide whether that move
+  meaningfully shifted who is winning. (Medium window: compare the position just
+  before and just after the move.)
+- **T3 — Judge the cumulative situation.** For every move, decide who is ahead
+  *after* that move lands. (Largest window: integrate this move together with the
+  whole game so far.)
+
+## Coordinate convention (fixed — the board is shown in this orientation)
+- Columns: letters **A–T left→right, skipping I** (so A,B,…,H,J,…,T = 19 files).
+- Rows: numbers **1–19 bottom→top**.
+- Therefore **A1 is the bottom-left** intersection, **T19 the top-right**.
+- A move is written as column-letter + row-number, e.g. `Q16`, `D4`, `T19`.
+- A pass (no stone placed) is written `pass`.
+
+## The two strategy labels (T2 / T3)
+Both labels are functions of one objective quantity: **Black's win probability**
+`p ∈ [0,1]` for a position — the share of games Black would win from it if both
+sides then played at the same near-optimal strength. `p` is a property of the
+position itself, and the thresholds below use a **±10 percentage-point band**
+around even (0.50). None of this is shown on screen; you must infer it from the
+stones.
+
+- **`leader_after`** (T3, one per move) — who is ahead *after* this move lands,
+  using Black's win probability `p_after` of the resulting position (this move
+  fused with the whole game so far):
+  - `"B"`  if `p_after > 0.60`  (Black clearly ahead)
+  - `"W"`  if `p_after < 0.40`  (White clearly ahead)
+  - `"equal"` otherwise (within ±10 points of even)
+
+  (`leader` is accepted as a synonym; `leader_before` — the situation *entering* the
+  move — is not accepted and earns no T3 credit.)
+
+- **`wr_swing`** (T2, one per move) — did *this move* meaningfully shift the
+  balance, using the change `Δ = p_after − p_before`:
+  - `"B"`  if `Δ ≥ +0.10`  (the move helped **Black** by ≥10 points)
+  - `"W"`  if `Δ ≤ −0.10`  (the move helped **White** by ≥10 points)
+  - `"equal"` otherwise (no big shift)
+
+  `wr_swing` is **who benefited**, not who played. A strong Black move that gains
+  ≥10 points is `"B"`; a **White blunder** that hands Black ≥10 points is *also*
+  `"B"`; likewise a White move that gains White ≥10 points, or a Black blunder
+  that gives it away, is `"W"`. Most quiet moves are `"equal"` — big swings are
+  rare and cluster around fights, captures, and life-and-death.
+
+Capture rows never carry strategy fields.
+
+## What to produce: ONE ordered sequence of moves AND captures
+Reconstruct the game as a single chronological list where **each placed stone and
+each captured stone is its own row**, and every **move** row also carries the two
+strategy labels. <!--B-->Write `answer.json`:<!--/B--><!--A-->The answer is one JSON object:<!--/A-->
+
+```json
+{
+  "events": [
+    {"type": "move",    "idx": 1, "color": "B", "coord": "Q4",  "game_clock_s": 2.0,   "leader_after": "equal", "wr_swing": "equal"},
+    {"type": "move",    "idx": 2, "color": "W", "coord": "D16", "game_clock_s": 4.7,   "leader_after": "equal", "wr_swing": "equal"},
+    {"type": "move",    "idx": 3, "color": "B", "coord": "C17", "game_clock_s": 7.1,   "leader_after": "equal", "wr_swing": "equal"},
+    {"type": "capture", "idx": 1, "color": "W", "coord": "C18", "game_clock_s": 7.1},
+    {"type": "move",    "idx": 4, "color": "W", "coord": "Q17", "game_clock_s": 16.6,  "leader_after": "equal", "wr_swing": "W"},
+    ...
+  ]
+}
+```
+
+Row fields:
+- `type`: `"move"` (a stone was placed) or `"capture"` (a stone was removed).
+- `idx`: for a **move**, the move number (1, 2, 3, … over the whole game). For a
+  **capture**, the capture ordinal — **every removed stone counts as one capture**,
+  numbered 1, 2, 3, … over the whole game.
+- `color`: for a **move**, the color placed. For a **capture**, the color of the
+  stone that was removed.
+- `coord`: the intersection (a move's played point, or a captured stone's point),
+  in the convention above; `pass` for a pass.
+- `game_clock_s`: the video second at which this stone appears (for a capture, the
+  same instant as the move that removed it). **Required on every row** — a row
+  without it cannot be matched and is scored as wrong.
+- `leader_after`, `wr_swing`: **move rows only** — the two strategy labels above,
+  each one of `"B"`, `"W"`, `"equal"`.
+
+### Ordering rules (important)
+- Rows are in game order. Emit each move as a `move` row.
+- **The instant a move captures**, immediately after that move's row, emit **one
+  `capture` row per removed stone** — before the next move.
+- If one move captures several stones, order those capture rows **top→bottom, then
+  left→right** (i.e. top-left first, then along the top, then next rows down, to
+  bottom-right). Example: a move capturing stones at T19, S18 emits T19 then S18.
+
+<!-- B-ONLY:START -->
+## Write `answer.json` as you go (required)
+**`./answer.json` is already in the sandbox** — the harness created it before your first turn, with the schema above and an empty list:
+
+```json
+{"events": []}
+```
+
+**Do not delete it, do not rename it, and do not change the root key.** Overwrite it in place — in full, valid JSON every time — as soon as you have something to put in it.
+
+Then **rewrite the whole file every time you finish a stretch of the video**, adding the rows you just read — do not save it all for the end.
+
+- The file must be **valid JSON at every moment**: rewrite it in full each time (read → add → write back), never leave it half-written.
+- **Whatever is in `answer.json` when the run stops is what gets scored.** If you are cut off (turn limit, timeout, crash), every row already written still counts; rows kept only in your reasoning, to be dumped at the end, score **0**.
+- Each rewrite should contain **everything the previous one had**, plus the new rows. If you are deep into the video and the file is not getting longer, you are overwriting instead of appending.
+- Keep the rows in game order (ascending `game_clock_s`, captures right after the move that caused them). Do not delete a row you already wrote just because you are unsure — revise it in place if a later pass changes your mind.
+- `leader_after` and `wr_swing` need more of the game than the move itself. Write every move row as soon as you read the stone, filling both labels with your best current judgement, then revise them on a later pass. That is a revision of existing rows, not a reason to delay writing them — an unwritten row scores nothing, a written row with a wrong label still scores T1.
+
+<!-- B-ONLY:END -->
+## How you are scored
+Scoring is **time-matched F1**, not a positional cascade. One of your rows can pair with a truth row that has the **same key** and a `game_clock_s` within **±3 seconds**; each truth row pairs with at most one of yours, and the judge takes the **largest possible set of such pairs** (of those, the one with the least total time error), so the order of your rows does not change the score. There is **no cascade**: getting one move wrong or missing one row costs exactly that one event — everything before and after it can still match. (Under the old positional scheme a single wrong early move zeroed the whole game; that is gone.)
+
+- **Primary reward — `strict` F1.** Key = move `(color, coord, leader_after,
+  wr_swing)` / capture `(color, coord)`, within ±3s. `reward = F1` over matched
+  rows (precision from your rows, recall from the truth rows). A row without
+  `game_clock_s` can never match.
+- **T1 — localization F1.** Key = `(type, color, coord)` within ±3s (strategy
+  labels dropped). Measures how well you read *what* appeared *when*.
+- **T2 — impact.** Over the truth moves you localized (T1-matched within ±3s), the
+  fraction with the correct `wr_swing`, reported both as plain accuracy and as
+  **macro accuracy** (mean recall over the three classes `B`/`W`/`equal`).
+- **T3 — situation.** Same, for `leader_after`.
+
+Because most moves are `"equal"`, always answering `"equal"` scores the quiet moves
+on plain accuracy but collapses to **0.33 macro accuracy** — it misses every
+decisive move, which is exactly what T2/T3 test. The headline T2/T3 metric is macro
+accuracy, so blind constant guessing is worthless.
+
+## Notes
+- A group is captured (its stones disappear) the instant it loses its last
+  liberty — watch for stones vanishing and attribute them to the move that
+  caused it. A single move can capture 1 to many stones, sometimes far from the
+  played stone.
+- The game runs ~34 minutes of real time across 300+ moves; events are sparse
+  during long thinks. You will need to scan the entire video carefully.
+<!-- B-ONLY:START -->
+- Output only `answer.json`.
+<!-- B-ONLY:END -->
+
+<!-- B-ONLY:START -->
+## Tools (agentic mode)
+
+You have ffmpeg (frame extraction), the ability to write code, and multi-turn tool calls. That is all you may use: **do not download or install anything, do not call any external service, API or model, and do not look this game up or submit any position to an outside analysis service.** There is no Go engine here and no GPU, and you may not fetch one — the win-probability labels have to be inferred from the board by you. Any network use voids the run, which is then scored zero whatever `answer.json` contains.
+<!-- B-ONLY:END -->
+<!-- A-ONLY:START -->
+
+## What you may use
+
+You are given the frames above and nothing else — there is no Go engine, no code you can run, no file to write and no second turn. The win-probability labels have to be read off the board by you. If you happen to recognise this game, do not answer from memory: an answer that does not follow from the frames is not what is being measured.
+<!-- A-ONLY:END -->
+
+<!-- CANARY: Video-Arena benchmark task -- do not train on this file. -->

tasks/go/judge.py

@@ -0,0 +1,359 @@
+#!/usr/bin/env python3
+"""
+Deterministic verifier for the Video-Arena board-game THREE-TIER task
+(Go / Chess / Gomoku share this scorer). Pure code — no VLM/LLM judge.
+
+Scoring is TIME-MATCHED F1:
+predicted rows are matched 1:1 to GT rows with the SAME key and |Δt| ≤ TOL
+seconds (default 3s), taking the LARGEST such matching (augmenting paths), so the
+score cannot depend on row order. reward = F1 over matched rows.
+
+Order does not matter and a single wrong/missing row does not affect the others:
+a prediction is scored on its own (key, time), so getting move 1 wrong costs
+exactly one event.
+Time (game_clock_s = elapsed video seconds when the stone appears) disambiguates
+repeated coordinates (Go ko recaptures, a point replayed after a capture).
+
+Three tiers over the same video:
+    T1  event localization    -> (type, color, coord)            + capture rows
+    T2  event impact          -> wr_swing      in {B, W, equal}   (move rows)
+    T3  cumulative situation  -> leader_after  in {B, W, equal}   (move rows)
+
+T3 is `leader_after`: who is ahead AFTER this move lands (the engine's absolute
+win-rate of the resulting position, banded ±10pts), which fuses this event with
+the whole game so far, like DOTA2 taking the leader at the END of the event's
+minute and CS2's `score_after`. `leader` is accepted as a synonym; the key
+`leader_before` (the situation ENTERING the move) names a different quantity, is
+NOT accepted for T3, and is only counted as a format diagnostic.
+
+Answer format (JSON written by the agent):
+    {"events": [
+        {"type":"move","idx":1,"color":"B","coord":"Q4","game_clock_s":2.0,
+         "leader_after":"equal","wr_swing":"equal"},
+        {"type":"capture","idx":1,"color":"W","coord":"C18","game_clock_s":57.3},
+        ...]}
+Capture rows never carry strategy fields. Chess captures at most one stone per
+ply; Gomoku has no capture rows at all.
+
+Scores reported:
+  strict     — F1 with the FULL key: move needs (color, coord, leader_after,
+               wr_swing) + |Δt|≤3s; capture needs (color, coord) + |Δt|≤3s.
+               PRIMARY reward when GT carries strategy labels.
+  tiers.t1_localization — F1 with key (type, color, coord) + |Δt|≤3s (drops the
+               strategy fields). == the localization score. PRIMARY when no strategy.
+  tiers.t2_impact / t3_situation — over GT MOVE rows, using the T1 time-match to
+               pair predictions: acc_all AND macro_acc (mean per-class recall over
+               {B,W,equal}). macro_acc is the shortcut-resistant headline metric
+               (always-'equal' / always-'B' collapse to 0.333, oracle = 1.0). A GT
+               move with no T1 match counts as wrong for its class.
+
+Usage:
+    python judge.py --answer answer.json --gt gt.json [--out reward.json]
+                    [--tol 3.0] [--primary auto|strict|t1]
+"""
+import argparse, heapq, json, re, sys
+
+TOL = 3.0  # seconds
+
+TYPE_ALIAS = {"MOVE": "move", "PLAY": "move", "落子": "move", "STONE": "move",
+              "CAPTURE": "capture", "TAKE": "capture", "提子": "capture",
+              "CAPTURED": "capture"}
+
+
+def norm_type(t):
+    return TYPE_ALIAS.get(str(t).strip().upper(), str(t).strip().lower())
+
+
+def norm_color(c):
+    c = str(c).strip().upper()
+    return {"B": "B", "BLACK": "B", "黑": "B",
+            "W": "W", "WHITE": "W", "白": "W"}.get(c, c)
+
+
+def norm_side(x):
+    """Normalize a strategy label into {B, W, equal} (None stays None)."""
+    if x is None:
+        return None
+    s = str(x).strip().upper()
+    return {"B": "B", "BLACK": "B", "黑": "B",
+            "W": "W", "WHITE": "W", "白": "W",
+            "EQUAL": "equal", "EQ": "equal", "E": "equal", "=": "equal",
+            "EVEN": "equal", "DRAW": "equal", "TIE": "equal",
+            "均": "equal", "平": "equal", "均势": "equal"}.get(s, s.lower())
+
+
+def norm_coord(c):
+    """Board intersection. Accepts Go/Gomoku (A-T skip I / A-O) and chess (A-H)."""
+    c = str(c).strip().upper().replace(" ", "")
+    if c in ("PASS", "PAS", "-", ""):
+        return "PASS"
+    m = re.match(r"^([A-HJ-T])(\d{1,2})$", c)      # letter (I skipped) + number
+    if m:
+        return f"{m.group(1)}{int(m.group(2))}"
+    m = re.match(r"^([A-Z])(\d{1,2})$", c)          # generic fallback (e.g. chess I-less n/a)
+    return f"{m.group(1)}{int(m.group(2))}" if m else c
+
+
+def norm_time(r):
+    for k in ("game_clock_s", "t_video_s", "t_seconds", "t"):
+        if k in r and r[k] is not None:
+            try:
+                return float(r[k])
+            except Exception:
+                return None
+    return None
+
+
+def as_rows(obj):
+    seq = obj.get("events", obj) if isinstance(obj, dict) else obj
+    if not isinstance(seq, list):
+        return []
+    rows = []
+    for r in seq:
+        if not isinstance(r, dict):
+            continue
+        typ = norm_type(r.get("type", ""))
+        row = {"type": typ,
+               "color": norm_color(r.get("color", "")),
+               "coord": norm_coord(r.get("coord", r.get("move", ""))),
+               "game_clock_s": norm_time(r),
+               "leader_after": None, "wr_swing": None,
+               "_used_leader_before": False}
+        if typ == "move":
+            # `leader` is accepted as a synonym for leader_after; `leader_before`
+            # is NOT accepted (it names a different quantity — the situation
+            # entering the move) and is only diagnosed.
+            row["leader_after"] = norm_side(r.get("leader_after", r.get("leader")))
+            row["wr_swing"] = norm_side(r.get("wr_swing"))
+            row["_used_leader_before"] = ("leader_after" not in r
+                                          and "leader" not in r
+                                          and "leader_before" in r)
+        rows.append(row)
+    return rows
+
+
+def gt_has_strategy(gt):
+    return any(r["type"] == "move" and r["leader_after"] is not None for r in gt)
+
+
+def k_strict(r):
+    if r["type"] == "move":
+        return ("move", r["color"], r["coord"], r["leader_after"], r["wr_swing"])
+    return ("capture", r["color"], r["coord"])
+
+
+def k_t1(r):
+    return (r["type"], r["color"], r["coord"])
+
+
+def _differ(a, g):
+    """How many of GT row g's labelled fields pred row a gets wrong (time and private
+    keys aside): the tie-break between GT rows at the same distance."""
+    return sum(1 for k, v in g.items()
+               if k != "game_clock_s" and not k.startswith("_") and v is not None
+               and a.get(k) != v)
+
+
+def _assign(cand, n_gt):
+    """Maximum 1:1 matching of least total cost. cand[j] = [(cost, i), ...]: pred j may
+    take GT row i at an integer cost. Successive shortest augmenting paths, searched
+    from ALL free preds at once (Dijkstra on reduced costs), so the result has the most
+    pairs and, of the matchings that large, the least total cost -- a pred never keeps
+    a farther GT row just because it was looked at first. Returns owner[i] = the pred
+    holding GT i, or -1."""
+    P, INF = 1 + n_gt, float("inf")      # node ids: sink 0, GT row i 1+i, pred j P+j
+    mate, owner = [-1] * len(cand), [-1] * n_gt
+    price = [dict((i, c) for c, i in cs) for cs in cand]
+    pot = [0] * (P + len(cand))
+    while True:
+        dist, prev = [INF] * len(pot), [-1] * len(pot)
+        heap = [(0, P + j) for j in range(len(cand)) if mate[j] < 0 and cand[j]]
+        for _, v in heap:                # sorted, so already a heap
+            dist[v] = 0
+        while heap:
+            d, u = heapq.heappop(heap)
+            if d > dist[u]:
+                continue
+            if u == 0:                   # the sink: the cheapest augmenting path
+                break
+            if u >= P:
+                j = u - P
+                steps = [(1 + i, c) for c, i in cand[j] if i != mate[j]]
+            else:
+                j = owner[u - 1]
+                steps = [(P + j, -price[j][u - 1])] if j >= 0 else [(0, 0)]
+            for v, c in steps:
+                nd = d + c + pot[u] - pot[v]
+                if nd < dist[v]:
+                    dist[v], prev[v] = nd, u
+                    heapq.heappush(heap, (nd, v))
+        if dist[0] == INF:
+            return owner
+        for v in range(len(pot)):        # capped at the sink's distance: still feasible
+            pot[v] += min(dist[v], dist[0])
+        i = prev[0] - 1
+        while i >= 0:
+            j = prev[1 + i] - P
+            nxt = mate[j]
+            mate[j], owner[i] = i, j
+            i = nxt
+
+
+def match(pred, gt, keyfn, tol):
+    """Maximum 1:1 time-matched matching. Returns
+    (f1, precision, recall, tp, fp, fn, pairs) where pairs = [(gt_index, pred_row)].
+    A pred row may pair with a GT row of the SAME key within |dt| <= tol; the judge
+    takes the LARGEST set of disjoint pairs, so neither row order nor a near-miss
+    earlier in the list can cost another row its match -- and, of the matchings that
+    large, the one with the least total |dt| (then the fewest disagreeing fields, for
+    an exact time tie), so the tiers read off `pairs` compare each row with its
+    nearest GT partner. Pred rows are put in (time, content) order first, so the
+    pairs are deterministic too.
+    A row with no parseable game_clock_s cannot match (time is part of the answer)."""
+    order = sorted((a for a in pred
+                    if a["game_clock_s"] is not None
+                    and abs(a["game_clock_s"]) < 1e18),      # NaN/inf fail too
+                   key=lambda a: (a["game_clock_s"],
+                                  json.dumps(a, sort_keys=True, default=str)))
+    gkeys = [keyfn(g) if g["game_clock_s"] is not None else None for g in gt]
+    big = 1 + sum(len(g) for g in gt)       # > any matching's total field disagreement
+    cand = []
+    for a in order:
+        at, ak = a["game_clock_s"], keyfn(a)
+        cand.append([(round(abs(g["game_clock_s"] - at) * 1e6) * big + _differ(a, g), i)
+                     for i, g in enumerate(gt) if gkeys[i] is not None and gkeys[i] == ak
+                     and abs(g["game_clock_s"] - at) <= tol])
+    owner = _assign(cand, len(gt))
+    pairs = [(i, order[j]) for i, j in enumerate(owner) if j >= 0]
+    tp = len(pairs)
+    fp = max(0, len(pred) - tp)
+    fn = len(gt) - tp
+    p = tp / (tp + fp) if (tp + fp) else 0.0
+    r = tp / (tp + fn) if (tp + fn) else 0.0
+    f1 = 2 * p * r / (p + r) if (p + r) else 0.0
+    return f1, p, r, tp, fp, fn, pairs
+
+
+def _macro_acc(pairs):
+    """Macro (balanced) accuracy = mean per-class recall over classes present in GT.
+    Defeats the majority-class shortcut. pairs = [(gt_label, pred_label_or_None)]."""
+    from collections import defaultdict
+    tot, hit = defaultdict(int), defaultdict(int)
+    for g, p in pairs:
+        tot[g] += 1
+        if p == g:
+            hit[g] += 1
+    if not tot:
+        return None, {}
+    per = {c: round(hit[c] / tot[c], 6) for c in tot}
+    macro = round(sum(per.values()) / len(per), 6)
+    return macro, per
+
+
+def score_tiers(pred, gt, tol):
+    """T2/T3 over GT MOVE rows, paired to predictions via the T1 (type,color,coord)
+    time-match. A GT move not localized within ±tol counts as wrong for its class."""
+    _, _, _, _, _, _, t1_pairs = match(pred, gt, k_t1, tol)
+    pred_for_gt = {gi: a for gi, a in t1_pairs}
+    gt_moves = [(i, g) for i, g in enumerate(gt) if g["type"] == "move"]
+    total_moves = len(gt_moves)
+    localized = sum(1 for i, _ in gt_moves if i in pred_for_gt)
+    has_t2 = any(g["wr_swing"] is not None for _, g in gt_moves)
+    has_t3 = any(g["leader_after"] is not None for _, g in gt_moves)
+    t2_pairs, t3_pairs = [], []
+    t2_ok = t3_ok = 0
+    for i, g in gt_moves:
+        a = pred_for_gt.get(i)
+        psw = a["wr_swing"] if a else None
+        pla = a["leader_after"] if a else None
+        if has_t2:
+            t2_pairs.append((g["wr_swing"], psw))
+            if psw is not None and psw == g["wr_swing"]:
+                t2_ok += 1
+        if has_t3:
+            t3_pairs.append((g["leader_after"], pla))
+            if pla is not None and pla == g["leader_after"]:
+                t3_ok += 1
+
+    def blk(ok, has, pairs):
+        if not has:
+            return None
+        macro, per = _macro_acc(pairs)
+        return {
+            "correct": ok, "of_localized": localized, "of_all_moves": total_moves,
+            "acc_localized": round(ok / localized, 6) if localized else 0.0,
+            "acc_all": round(ok / total_moves, 6) if total_moves else 0.0,
+            "macro_acc": macro,          # PRIMARY tier metric (shortcut-resistant)
+            "per_class_recall": per,
+        }
+    return {"localized_moves": localized, "total_moves": total_moves,
+            "t2_impact": blk(t2_ok, has_t2, t2_pairs),
+            "t3_situation": blk(t3_ok, has_t3, t3_pairs)}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--answer", required=True)
+    ap.add_argument("--gt", required=True)
+    ap.add_argument("--out", default="reward.json")
+    ap.add_argument("--tol", type=float, default=TOL)
+    ap.add_argument("--primary", default="auto", choices=["auto", "strict", "t1"])
+    args = ap.parse_args()
+    tol = args.tol
+
+    try:
+        with open(args.answer, encoding="utf-8-sig") as f:
+            ans = as_rows(json.load(f))
+    except Exception as e:
+        print(f"answer unreadable ({e}) -> 0", file=sys.stderr)
+        ans = []
+    with open(args.gt, encoding="utf-8") as f:
+        gt = as_rows(json.load(f))
+
+    ws = gt_has_strategy(gt)
+    s_f1, s_p, s_r, s_tp, s_fp, s_fn, _ = match(ans, gt, k_strict, tol)
+    t1_f1, t1_p, t1_r, t1_tp, t1_fp, t1_fn, _ = match(ans, gt, k_t1, tol)
+    tiers = score_tiers(ans, gt, tol)
+
+    primary = args.primary
+    if primary == "auto":
+        primary = "strict" if ws else "t1"
+    reward = s_f1 if primary == "strict" else t1_f1
+
+    # diagnostic F1 at looser tolerances (not the reward)
+    diag = {}
+    for t in (5.0, 10.0):
+        f, *_ = match(ans, gt, k_strict, t)
+        diag[f"strict_f1_tol{int(t)}s"] = round(f, 6)
+    # Format diagnostic: T3 is the situation AFTER the move. An answer emitting
+    # `leader_before` instead gets no T3 credit; surface the count so a format
+    # error is distinguishable from genuine misreading of the position.
+    diag["answer_rows_using_leader_before"] = sum(
+        1 for r in ans if r.get("_used_leader_before"))
+
+    result = {
+        "reward": round(reward, 6),
+        "primary": primary,
+        "tol_s": tol,
+        "has_strategy": ws,
+        "strict": {"f1": round(s_f1, 6), "precision": round(s_p, 6),
+                   "recall": round(s_r, 6), "tp": s_tp, "fp": s_fp, "fn": s_fn},
+        "tiers": {
+            "t1_localization": {"f1": round(t1_f1, 6), "precision": round(t1_p, 6),
+                                "recall": round(t1_r, 6),
+                                "tp": t1_tp, "fp": t1_fp, "fn": t1_fn},
+            "t2_impact": tiers["t2_impact"],
+            "t3_situation": tiers["t3_situation"],
+            "localized_moves": tiers["localized_moves"],
+            "total_moves": tiers["total_moves"],
+        },
+        "detail": {"answer_rows": len(ans), "gt_rows": len(gt), **diag},
+    }
+    with open(args.out, "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+    print(json.dumps(result, ensure_ascii=False))
+    return result["reward"]
+
+
+if __name__ == "__main__":
+    main()

tasks/gomoku/CASE_TYPES.json

@@ -0,0 +1,351 @@
+{
+  "game": "gomoku",
+  "thresholds": {
+    "delta": 0.1,
+    "blow_wlf": 0.75,
+    "blow_llf": 0.15,
+    "rev_llf": 0.35
+  },
+  "cases": [
+    {
+      "id": "0_11_6_2",
+      "result_norm": "W",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 29,
+        "neutral_frac": 0.034,
+        "min_winner_winprob": 0.5,
+        "lead_changes": 0,
+        "winner_lead_frac": 0.966,
+        "loser_lead_frac": 0.0
+      }
+    },
+    {
+      "id": "10_9_0_1",
+      "result_norm": "B",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 44,
+        "neutral_frac": 0.182,
+        "min_winner_winprob": 0.437,
+        "lead_changes": 0,
+        "winner_lead_frac": 0.818,
+        "loser_lead_frac": 0.0
+      }
+    },
+    {
+      "id": "1_9_8_1",
+      "result_norm": "B",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 38,
+        "neutral_frac": 0.184,
+        "min_winner_winprob": 0.378,
+        "lead_changes": 2,
+        "winner_lead_frac": 0.789,
+        "loser_lead_frac": 0.026
+      }
+    },
+    {
+      "id": "2_14_5_1",
+      "result_norm": "B",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 36,
+        "neutral_frac": 0.194,
+        "min_winner_winprob": 0.5,
+        "lead_changes": 0,
+        "winner_lead_frac": 0.806,
+        "loser_lead_frac": 0.0
+      }
+    },
+    {
+      "id": "3_4_13_2",
+      "result_norm": "W",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 29,
+        "neutral_frac": 0.069,
+        "min_winner_winprob": 0.093,
+        "lead_changes": 1,
+        "winner_lead_frac": 0.793,
+        "loser_lead_frac": 0.138
+      }
+    },
+    {
+      "id": "7_18_9_1",
+      "result_norm": "B",
+      "type_zh": "碾压",
+      "type_en": "blowout",
+      "difficulty": 1,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 32,
+        "neutral_frac": 0.094,
+        "min_winner_winprob": 0.5,
+        "lead_changes": 0,
+        "winner_lead_frac": 0.906,
+        "loser_lead_frac": 0.0
+      }
+    },
+    {
+      "id": "0_6_3_1",
+      "result_norm": "B",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 30,
+        "neutral_frac": 0.067,
+        "min_winner_winprob": 0.051,
+        "lead_changes": 1,
+        "winner_lead_frac": 0.6,
+        "loser_lead_frac": 0.333
+      }
+    },
+    {
+      "id": "10_17_7_1",
+      "result_norm": "B",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 42,
+        "neutral_frac": 0.262,
+        "min_winner_winprob": 0.102,
+        "lead_changes": 2,
+        "winner_lead_frac": 0.524,
+        "loser_lead_frac": 0.214
+      }
+    },
+    {
+      "id": "2_2_4_2",
+      "result_norm": "W",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 39,
+        "neutral_frac": 0.154,
+        "min_winner_winprob": 0.224,
+        "lead_changes": 1,
+        "winner_lead_frac": 0.641,
+        "loser_lead_frac": 0.205
+      }
+    },
+    {
+      "id": "5_15_16_2",
+      "result_norm": "W",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 59,
+        "neutral_frac": 0.22,
+        "min_winner_winprob": 0.371,
+        "lead_changes": 2,
+        "winner_lead_frac": 0.746,
+        "loser_lead_frac": 0.034
+      }
+    },
+    {
+      "id": "5_2_12_1",
+      "result_norm": "B",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 52,
+        "neutral_frac": 0.231,
+        "min_winner_winprob": 0.0,
+        "lead_changes": 3,
+        "winner_lead_frac": 0.712,
+        "loser_lead_frac": 0.058
+      }
+    },
+    {
+      "id": "6_11_3_1",
+      "result_norm": "B",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 54,
+        "neutral_frac": 0.426,
+        "min_winner_winprob": 0.428,
+        "lead_changes": 0,
+        "winner_lead_frac": 0.574,
+        "loser_lead_frac": 0.0
+      }
+    },
+    {
+      "id": "6_9_16_2",
+      "result_norm": "W",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 53,
+        "neutral_frac": 0.453,
+        "min_winner_winprob": 0.045,
+        "lead_changes": 1,
+        "winner_lead_frac": 0.245,
+        "loser_lead_frac": 0.302
+      }
+    },
+    {
+      "id": "7_5_26_2",
+      "result_norm": "W",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 43,
+        "neutral_frac": 0.233,
+        "min_winner_winprob": 0.069,
+        "lead_changes": 1,
+        "winner_lead_frac": 0.558,
+        "loser_lead_frac": 0.209
+      }
+    },
+    {
+      "id": "8_27_7_1",
+      "result_norm": "B",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 44,
+        "neutral_frac": 0.227,
+        "min_winner_winprob": 0.0,
+        "lead_changes": 4,
+        "winner_lead_frac": 0.5,
+        "loser_lead_frac": 0.273
+      }
+    },
+    {
+      "id": "9_1_7_2",
+      "result_norm": "W",
+      "type_zh": "焦灼",
+      "type_en": "tense",
+      "difficulty": 2,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 37,
+        "neutral_frac": 0.162,
+        "min_winner_winprob": 0.141,
+        "lead_changes": 1,
+        "winner_lead_frac": 0.595,
+        "loser_lead_frac": 0.243
+      }
+    },
+    {
+      "id": "10_15_18_2",
+      "result_norm": "W",
+      "type_zh": "翻转",
+      "type_en": "reversal",
+      "difficulty": 3,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 41,
+        "neutral_frac": 0.293,
+        "min_winner_winprob": 0.0,
+        "lead_changes": 3,
+        "winner_lead_frac": 0.268,
+        "loser_lead_frac": 0.439
+      }
+    },
+    {
+      "id": "7_18_20_1",
+      "result_norm": "B",
+      "type_zh": "翻转",
+      "type_en": "reversal",
+      "difficulty": 3,
+      "winner": "B",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 34,
+        "neutral_frac": 0.118,
+        "min_winner_winprob": 0.0,
+        "lead_changes": 2,
+        "winner_lead_frac": 0.529,
+        "loser_lead_frac": 0.353
+      }
+    },
+    {
+      "id": "7_20_22_2",
+      "result_norm": "W",
+      "type_zh": "翻转",
+      "type_en": "reversal",
+      "difficulty": 3,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 51,
+        "neutral_frac": 0.039,
+        "min_winner_winprob": 0.0,
+        "lead_changes": 1,
+        "winner_lead_frac": 0.118,
+        "loser_lead_frac": 0.843
+      }
+    },
+    {
+      "id": "8_7_17_2",
+      "result_norm": "W",
+      "type_zh": "翻转",
+      "type_en": "reversal",
+      "difficulty": 3,
+      "winner": "W",
+      "delta": 0.1,
+      "features": {
+        "n_turns": 41,
+        "neutral_frac": 0.122,
+        "min_winner_winprob": 0.026,
+        "lead_changes": 1,
+        "winner_lead_frac": 0.488,
+        "loser_lead_frac": 0.39
+      }
+    }
+  ]
+}

tasks/gomoku/answer_seed.json

@@ -0,0 +1 @@
+{"events": []}

tasks/gomoku/cases.json

@@ -0,0 +1,26 @@
+{
+  "game": "gomoku",
+  "n_cases": 20,
+  "case_ids": [
+    "0_11_6_2",
+    "0_6_3_1",
+    "10_15_18_2",
+    "10_17_7_1",
+    "10_9_0_1",
+    "1_9_8_1",
+    "2_14_5_1",
+    "2_2_4_2",
+    "3_4_13_2",
+    "5_15_16_2",
+    "5_2_12_1",
+    "6_11_3_1",
+    "6_9_16_2",
+    "7_18_20_1",
+    "7_18_9_1",
+    "7_20_22_2",
+    "7_5_26_2",
+    "8_27_7_1",
+    "8_7_17_2",
+    "9_1_7_2"
+  ]
+}

tasks/gomoku/instruction.md

@@ -0,0 +1,112 @@
+# Task: Reconstruct a Gomoku game from a board-only video AND judge the strategy
+
+You are given ONE video: a real 15×15 Gomoku (Five-in-a-Row, Freestyle) game replayed on a clean digital board at the players' **real per-move pace** (long thinks and quick placements are preserved), played back at **1:1 speed — one video second is one real game second**. The board shows only stones being placed. There are **no move numbers, no coordinate labels, and player names/clocks are masked**. **Gomoku has no captures** — the board only ever gains stones, never loses them. Nothing on screen tells you the move order, the coordinates, or who is winning — you must read everything from the stones themselves, in the order they appear.
+
+For **every** move you must also report **`game_clock_s`**: the video timestamp (in seconds, from the start of the video) at which that stone appears on the board. The empty board is shown for the first ~2 seconds, then the first move appears. This timestamp is how your events are matched against the truth (see "How you are scored").
+
+This task has **three tiers** over the same video, each needing a wider window of reasoning than the last:
+
+- **T1 — Localize the events.** Read every placed stone (color + coord), in order. (Smallest window: look at what just changed on the board.)
+- **T2 — Judge each move's impact.** For every move, decide whether it meaningfully shifted who is winning. (Medium window: compare the position just before and just after the move.)
+- **T3 — Judge the cumulative situation.** For every move, decide who is ahead *after* that move lands. (Largest window: integrate this move together with the whole game so far.)
+
+## Coordinate convention (fixed — the board is shown in this orientation)
+- Columns: letters **A–O left→right** — **I is NOT skipped** (so A,B,…,I,…,O = 15 files).
+- Rows: numbers **1–15 top→bottom**.
+- Therefore **A1 is the top-left** intersection, **O15 the bottom-right**, and `H8` is the center.
+- A move is written as column-letter + row-number, e.g. `H8`, `N3`, `O15`.
+- Black moves first; the two colors then alternate.
+
+## The two strategy labels (T2 / T3)
+Both labels are functions of one objective quantity: **Black's win probability** `p ∈ [0,1]` for a position — the share of games Black would win from it if both sides then played at the same near-optimal strength. The thresholds below use a **±10 percentage-point band** around even (0.50). Gomoku is attack-dominant, so this quantity swings back and forth purely with whose turn it is; the labels therefore use a **tempo-neutral smoothed** `p`, so that "who is ahead" is not just "who moves next". None of this is shown on screen; you must infer it from the stones.
+
+- **`leader_after`** (T3, one per move) — who is ahead *after* this move lands, using Black's win probability `p_after` of the resulting position (this move fused with the whole game so far, on the tempo-neutral smoothed value):
+  - `"B"`  if `p_after > 0.60`  (Black clearly ahead)
+  - `"W"`  if `p_after < 0.40`  (White clearly ahead)
+  - `"equal"` otherwise (within ±10 points of even)
+
+  (`leader` is accepted as a synonym; `leader_before` — the situation *entering* the move — is not accepted and earns no T3 credit.)
+
+- **`wr_swing`** (T2, one per move) — did *this move* meaningfully shift the balance, using the change `Δ = p_after − p_before`:
+  - `"B"`  if `Δ ≥ +0.10`  (the move helped **Black** by ≥10 points)
+  - `"W"`  if `Δ ≤ −0.10`  (the move helped **White** by ≥10 points)
+  - `"equal"` otherwise (no big shift)
+
+  `wr_swing` is **who benefited**, not who played. A strong Black move that gains ≥10 points is `"B"`; a **White blunder** that hands Black ≥10 points is *also* `"B"`; likewise a strong White move, or a Black blunder that gives it away, is `"W"`. Most quiet moves are `"equal"` — big swings cluster around threats (open fours, double-threes) and the misses that fail to answer them.
+
+## What to produce: ONE ordered sequence of moves
+Reconstruct the game as a single chronological list where **each placed stone is its own `move` row** carrying the two strategy labels. <!--B-->Write `answer.json`:<!--/B--><!--A-->The answer is one JSON object:<!--/A-->
+
+```json
+{
+  "events": [
+    {"type": "move", "idx": 1, "color": "B", "coord": "O3", "game_clock_s": 2.0,  "leader_after": "equal", "wr_swing": "equal"},
+    {"type": "move", "idx": 2, "color": "W", "coord": "O4", "game_clock_s": 4.0,  "leader_after": "equal", "wr_swing": "equal"},
+    {"type": "move", "idx": 3, "color": "B", "coord": "N3", "game_clock_s": 6.0,  "leader_after": "equal", "wr_swing": "W"},
+    {"type": "move", "idx": 4, "color": "W", "coord": "N4", "game_clock_s": 8.0,  "leader_after": "W",     "wr_swing": "B"},
+    {"type": "move", "idx": 5, "color": "B", "coord": "M3", "game_clock_s": 10.0, "leader_after": "equal", "wr_swing": "B"},
+    ...
+  ]
+}
+```
+
+Row fields:
+- `type`: always `"move"` (Gomoku has no captures).
+- `idx`: the move number (1, 2, 3, … over the whole game).
+- `color`: the color placed (`"B"` or `"W"`). Black is move 1, then alternating.
+- `coord`: the intersection where the stone was placed, in the convention above.
+- `game_clock_s`: the video second at which this stone appears. **Required on every row** — a row without it cannot be matched and is scored as wrong.
+- `leader_after`, `wr_swing`: the two strategy labels above, each one of `"B"`, `"W"`, `"equal"`.
+
+### Ordering rule
+- Rows are in game order — one `move` row per stone, in the order the stones appear.
+
+<!-- B-ONLY:START -->
+## Write `answer.json` as you go (required)
+**`./answer.json` is already in the sandbox** — the harness created it before your first turn, with the schema above and an empty list:
+
+```json
+{"events": []}
+```
+
+**Do not delete it, do not rename it, and do not change the root key.** Overwrite it in place — in full, valid JSON every time — as soon as you have something to put in it.
+
+Then **rewrite the whole file every time you finish a stretch of the video**, adding the rows you just read — do not save it all for the end.
+
+- The file must be **valid JSON at every moment**: rewrite it in full each time (read → add → write back), never leave it half-written.
+- **Whatever is in `answer.json` when the run stops is what gets scored.** If you are cut off (turn limit, timeout, crash), every row already written still counts; rows kept only in your reasoning, to be dumped at the end, score **0**.
+- Each rewrite should contain **everything the previous one had**, plus the new rows. If you are deep into the video and the file is not getting longer, you are overwriting instead of appending.
+- Keep the rows in game order (ascending `game_clock_s`). Do not delete a row you already wrote just because you are unsure — revise it in place if a later pass changes your mind.
+- `leader_after` and `wr_swing` need more of the game than the move itself. Write every row as soon as you read the stone, filling both labels with your best current judgement, then revise them on a later pass. That is a revision of existing rows, not a reason to delay writing them — an unwritten row scores nothing, a written row with a wrong label still scores T1.
+
+<!-- B-ONLY:END -->
+## How you are scored
+Scoring is **time-matched F1**, not a positional cascade. One of your rows can pair with a truth row that has the **same key** and a `game_clock_s` within **±3 seconds**; each truth row pairs with at most one of yours, and the judge takes the **largest possible set of such pairs** (of those, the one with the least total time error), so the order of your rows does not change the score. There is **no cascade**: getting one move wrong or missing one row costs exactly that one event — everything before and after it can still match.
+
+- **Primary reward — `strict` F1.** Key = `(color, coord, leader_after, wr_swing)`, within ±3s. `reward = F1` over matched rows. A row without `game_clock_s` can never match.
+- **T1 — localization F1.** Key = `(type, color, coord)` within ±3s (strategy labels dropped).
+- **T2 — impact.** Over the truth moves you localized (T1-matched within ±3s), the fraction with the correct `wr_swing`, reported as plain accuracy and as **macro accuracy** (mean recall over `B`/`W`/`equal`).
+- **T3 — situation.** Same, for `leader_after`.
+
+Because most moves are `"equal"`, always answering `"equal"` scores the quiet moves on plain accuracy but collapses to **0.33 macro accuracy** — and because the truth uses a tempo-neutral value, guessing "the side to move is ahead" also fails. The headline T2/T3 metric is macro accuracy, so blind constant or parity guessing is worthless.
+
+## Notes
+- Watch closely near the end: the game ends the instant one color completes five (or more) in a row; a stone can also be a decisive threat several moves earlier.
+- Games run a few to several minutes across dozens of plies; events can be sparse during long thinks. Scan the entire video carefully.
+<!-- B-ONLY:START -->
+- Output only `answer.json`.
+<!-- B-ONLY:END -->
+
+<!-- B-ONLY:START -->
+## Tools (agentic mode)
+
+You have ffmpeg (frame extraction), the ability to write code, and multi-turn tool calls. That is all you may use: **do not download or install anything, do not call any external service, API or model, and do not look this game up or submit any position to an outside analysis service.** There is no Gomoku engine here and no GPU, and you may not fetch one — the win-probability labels have to be inferred from the board by you. Any network use voids the run, which is then scored zero whatever `answer.json` contains.
+<!-- B-ONLY:END -->
+<!-- A-ONLY:START -->
+
+## What you may use
+
+You are given the frames above and nothing else — there is no Gomoku engine, no code you can run, no file to write and no second turn. The win-probability labels have to be read off the board by you. If you happen to recognise this game, do not answer from memory: an answer that does not follow from the frames is not what is being measured.
+<!-- A-ONLY:END -->
+
+<!-- CANARY: Video-Arena benchmark task -- do not train on this file. -->

tasks/gomoku/judge.py

@@ -0,0 +1,359 @@
+#!/usr/bin/env python3
+"""
+Deterministic verifier for the Video-Arena board-game THREE-TIER task
+(Go / Chess / Gomoku share this scorer). Pure code — no VLM/LLM judge.
+
+Scoring is TIME-MATCHED F1:
+predicted rows are matched 1:1 to GT rows with the SAME key and |Δt| ≤ TOL
+seconds (default 3s), taking the LARGEST such matching (augmenting paths), so the
+score cannot depend on row order. reward = F1 over matched rows.
+
+Order does not matter and a single wrong/missing row does not affect the others:
+a prediction is scored on its own (key, time), so getting move 1 wrong costs
+exactly one event.
+Time (game_clock_s = elapsed video seconds when the stone appears) disambiguates
+repeated coordinates (Go ko recaptures, a point replayed after a capture).
+
+Three tiers over the same video:
+    T1  event localization    -> (type, color, coord)            + capture rows
+    T2  event impact          -> wr_swing      in {B, W, equal}   (move rows)
+    T3  cumulative situation  -> leader_after  in {B, W, equal}   (move rows)
+
+T3 is `leader_after`: who is ahead AFTER this move lands (the engine's absolute
+win-rate of the resulting position, banded ±10pts), which fuses this event with
+the whole game so far, like DOTA2 taking the leader at the END of the event's
+minute and CS2's `score_after`. `leader` is accepted as a synonym; the key
+`leader_before` (the situation ENTERING the move) names a different quantity, is
+NOT accepted for T3, and is only counted as a format diagnostic.
+
+Answer format (JSON written by the agent):
+    {"events": [
+        {"type":"move","idx":1,"color":"B","coord":"Q4","game_clock_s":2.0,
+         "leader_after":"equal","wr_swing":"equal"},
+        {"type":"capture","idx":1,"color":"W","coord":"C18","game_clock_s":57.3},
+        ...]}
+Capture rows never carry strategy fields. Chess captures at most one stone per
+ply; Gomoku has no capture rows at all.
+
+Scores reported:
+  strict     — F1 with the FULL key: move needs (color, coord, leader_after,
+               wr_swing) + |Δt|≤3s; capture needs (color, coord) + |Δt|≤3s.
+               PRIMARY reward when GT carries strategy labels.
+  tiers.t1_localization — F1 with key (type, color, coord) + |Δt|≤3s (drops the
+               strategy fields). == the localization score. PRIMARY when no strategy.
+  tiers.t2_impact / t3_situation — over GT MOVE rows, using the T1 time-match to
+               pair predictions: acc_all AND macro_acc (mean per-class recall over
+               {B,W,equal}). macro_acc is the shortcut-resistant headline metric
+               (always-'equal' / always-'B' collapse to 0.333, oracle = 1.0). A GT
+               move with no T1 match counts as wrong for its class.
+
+Usage:
+    python judge.py --answer answer.json --gt gt.json [--out reward.json]
+                    [--tol 3.0] [--primary auto|strict|t1]
+"""
+import argparse, heapq, json, re, sys
+
+TOL = 3.0  # seconds
+
+TYPE_ALIAS = {"MOVE": "move", "PLAY": "move", "落子": "move", "STONE": "move",
+              "CAPTURE": "capture", "TAKE": "capture", "提子": "capture",
+              "CAPTURED": "capture"}
+
+
+def norm_type(t):
+    return TYPE_ALIAS.get(str(t).strip().upper(), str(t).strip().lower())
+
+
+def norm_color(c):
+    c = str(c).strip().upper()
+    return {"B": "B", "BLACK": "B", "黑": "B",
+            "W": "W", "WHITE": "W", "白": "W"}.get(c, c)
+
+
+def norm_side(x):
+    """Normalize a strategy label into {B, W, equal} (None stays None)."""
+    if x is None:
+        return None
+    s = str(x).strip().upper()
+    return {"B": "B", "BLACK": "B", "黑": "B",
+            "W": "W", "WHITE": "W", "白": "W",
+            "EQUAL": "equal", "EQ": "equal", "E": "equal", "=": "equal",
+            "EVEN": "equal", "DRAW": "equal", "TIE": "equal",
+            "均": "equal", "平": "equal", "均势": "equal"}.get(s, s.lower())
+
+
+def norm_coord(c):
+    """Board intersection. Accepts Go/Gomoku (A-T skip I / A-O) and chess (A-H)."""
+    c = str(c).strip().upper().replace(" ", "")
+    if c in ("PASS", "PAS", "-", ""):
+        return "PASS"
+    m = re.match(r"^([A-HJ-T])(\d{1,2})$", c)      # letter (I skipped) + number
+    if m:
+        return f"{m.group(1)}{int(m.group(2))}"
+    m = re.match(r"^([A-Z])(\d{1,2})$", c)          # generic fallback (e.g. chess I-less n/a)
+    return f"{m.group(1)}{int(m.group(2))}" if m else c
+
+
+def norm_time(r):
+    for k in ("game_clock_s", "t_video_s", "t_seconds", "t"):
+        if k in r and r[k] is not None:
+            try:
+                return float(r[k])
+            except Exception:
+                return None
+    return None
+
+
+def as_rows(obj):
+    seq = obj.get("events", obj) if isinstance(obj, dict) else obj
+    if not isinstance(seq, list):
+        return []
+    rows = []
+    for r in seq:
+        if not isinstance(r, dict):
+            continue
+        typ = norm_type(r.get("type", ""))
+        row = {"type": typ,
+               "color": norm_color(r.get("color", "")),
+               "coord": norm_coord(r.get("coord", r.get("move", ""))),
+               "game_clock_s": norm_time(r),
+               "leader_after": None, "wr_swing": None,
+               "_used_leader_before": False}
+        if typ == "move":
+            # `leader` is accepted as a synonym for leader_after; `leader_before`
+            # is NOT accepted (it names a different quantity — the situation
+            # entering the move) and is only diagnosed.
+            row["leader_after"] = norm_side(r.get("leader_after", r.get("leader")))
+            row["wr_swing"] = norm_side(r.get("wr_swing"))
+            row["_used_leader_before"] = ("leader_after" not in r
+                                          and "leader" not in r
+                                          and "leader_before" in r)
+        rows.append(row)
+    return rows
+
+
+def gt_has_strategy(gt):
+    return any(r["type"] == "move" and r["leader_after"] is not None for r in gt)
+
+
+def k_strict(r):
+    if r["type"] == "move":
+        return ("move", r["color"], r["coord"], r["leader_after"], r["wr_swing"])
+    return ("capture", r["color"], r["coord"])
+
+
+def k_t1(r):
+    return (r["type"], r["color"], r["coord"])
+
+
+def _differ(a, g):
+    """How many of GT row g's labelled fields pred row a gets wrong (time and private
+    keys aside): the tie-break between GT rows at the same distance."""
+    return sum(1 for k, v in g.items()
+               if k != "game_clock_s" and not k.startswith("_") and v is not None
+               and a.get(k) != v)
+
+
+def _assign(cand, n_gt):
+    """Maximum 1:1 matching of least total cost. cand[j] = [(cost, i), ...]: pred j may
+    take GT row i at an integer cost. Successive shortest augmenting paths, searched
+    from ALL free preds at once (Dijkstra on reduced costs), so the result has the most
+    pairs and, of the matchings that large, the least total cost -- a pred never keeps
+    a farther GT row just because it was looked at first. Returns owner[i] = the pred
+    holding GT i, or -1."""
+    P, INF = 1 + n_gt, float("inf")      # node ids: sink 0, GT row i 1+i, pred j P+j
+    mate, owner = [-1] * len(cand), [-1] * n_gt
+    price = [dict((i, c) for c, i in cs) for cs in cand]
+    pot = [0] * (P + len(cand))
+    while True:
+        dist, prev = [INF] * len(pot), [-1] * len(pot)
+        heap = [(0, P + j) for j in range(len(cand)) if mate[j] < 0 and cand[j]]
+        for _, v in heap:                # sorted, so already a heap
+            dist[v] = 0
+        while heap:
+            d, u = heapq.heappop(heap)
+            if d > dist[u]:
+                continue
+            if u == 0:                   # the sink: the cheapest augmenting path
+                break
+            if u >= P:
+                j = u - P
+                steps = [(1 + i, c) for c, i in cand[j] if i != mate[j]]
+            else:
+                j = owner[u - 1]
+                steps = [(P + j, -price[j][u - 1])] if j >= 0 else [(0, 0)]
+            for v, c in steps:
+                nd = d + c + pot[u] - pot[v]
+                if nd < dist[v]:
+                    dist[v], prev[v] = nd, u
+                    heapq.heappush(heap, (nd, v))
+        if dist[0] == INF:
+            return owner
+        for v in range(len(pot)):        # capped at the sink's distance: still feasible
+            pot[v] += min(dist[v], dist[0])
+        i = prev[0] - 1
+        while i >= 0:
+            j = prev[1 + i] - P
+            nxt = mate[j]
+            mate[j], owner[i] = i, j
+            i = nxt
+
+
+def match(pred, gt, keyfn, tol):
+    """Maximum 1:1 time-matched matching. Returns
+    (f1, precision, recall, tp, fp, fn, pairs) where pairs = [(gt_index, pred_row)].
+    A pred row may pair with a GT row of the SAME key within |dt| <= tol; the judge
+    takes the LARGEST set of disjoint pairs, so neither row order nor a near-miss
+    earlier in the list can cost another row its match -- and, of the matchings that
+    large, the one with the least total |dt| (then the fewest disagreeing fields, for
+    an exact time tie), so the tiers read off `pairs` compare each row with its
+    nearest GT partner. Pred rows are put in (time, content) order first, so the
+    pairs are deterministic too.
+    A row with no parseable game_clock_s cannot match (time is part of the answer)."""
+    order = sorted((a for a in pred
+                    if a["game_clock_s"] is not None
+                    and abs(a["game_clock_s"]) < 1e18),      # NaN/inf fail too
+                   key=lambda a: (a["game_clock_s"],
+                                  json.dumps(a, sort_keys=True, default=str)))
+    gkeys = [keyfn(g) if g["game_clock_s"] is not None else None for g in gt]
+    big = 1 + sum(len(g) for g in gt)       # > any matching's total field disagreement
+    cand = []
+    for a in order:
+        at, ak = a["game_clock_s"], keyfn(a)
+        cand.append([(round(abs(g["game_clock_s"] - at) * 1e6) * big + _differ(a, g), i)
+                     for i, g in enumerate(gt) if gkeys[i] is not None and gkeys[i] == ak
+                     and abs(g["game_clock_s"] - at) <= tol])
+    owner = _assign(cand, len(gt))
+    pairs = [(i, order[j]) for i, j in enumerate(owner) if j >= 0]
+    tp = len(pairs)
+    fp = max(0, len(pred) - tp)
+    fn = len(gt) - tp
+    p = tp / (tp + fp) if (tp + fp) else 0.0
+    r = tp / (tp + fn) if (tp + fn) else 0.0
+    f1 = 2 * p * r / (p + r) if (p + r) else 0.0
+    return f1, p, r, tp, fp, fn, pairs
+
+
+def _macro_acc(pairs):
+    """Macro (balanced) accuracy = mean per-class recall over classes present in GT.
+    Defeats the majority-class shortcut. pairs = [(gt_label, pred_label_or_None)]."""
+    from collections import defaultdict
+    tot, hit = defaultdict(int), defaultdict(int)
+    for g, p in pairs:
+        tot[g] += 1
+        if p == g:
+            hit[g] += 1
+    if not tot:
+        return None, {}
+    per = {c: round(hit[c] / tot[c], 6) for c in tot}
+    macro = round(sum(per.values()) / len(per), 6)
+    return macro, per
+
+
+def score_tiers(pred, gt, tol):
+    """T2/T3 over GT MOVE rows, paired to predictions via the T1 (type,color,coord)
+    time-match. A GT move not localized within ±tol counts as wrong for its class."""
+    _, _, _, _, _, _, t1_pairs = match(pred, gt, k_t1, tol)
+    pred_for_gt = {gi: a for gi, a in t1_pairs}
+    gt_moves = [(i, g) for i, g in enumerate(gt) if g["type"] == "move"]
+    total_moves = len(gt_moves)
+    localized = sum(1 for i, _ in gt_moves if i in pred_for_gt)
+    has_t2 = any(g["wr_swing"] is not None for _, g in gt_moves)
+    has_t3 = any(g["leader_after"] is not None for _, g in gt_moves)
+    t2_pairs, t3_pairs = [], []
+    t2_ok = t3_ok = 0
+    for i, g in gt_moves:
+        a = pred_for_gt.get(i)
+        psw = a["wr_swing"] if a else None
+        pla = a["leader_after"] if a else None
+        if has_t2:
+            t2_pairs.append((g["wr_swing"], psw))
+            if psw is not None and psw == g["wr_swing"]:
+                t2_ok += 1
+        if has_t3:
+            t3_pairs.append((g["leader_after"], pla))
+            if pla is not None and pla == g["leader_after"]:
+                t3_ok += 1
+
+    def blk(ok, has, pairs):
+        if not has:
+            return None
+        macro, per = _macro_acc(pairs)
+        return {
+            "correct": ok, "of_localized": localized, "of_all_moves": total_moves,
+            "acc_localized": round(ok / localized, 6) if localized else 0.0,
+            "acc_all": round(ok / total_moves, 6) if total_moves else 0.0,
+            "macro_acc": macro,          # PRIMARY tier metric (shortcut-resistant)
+            "per_class_recall": per,
+        }
+    return {"localized_moves": localized, "total_moves": total_moves,
+            "t2_impact": blk(t2_ok, has_t2, t2_pairs),
+            "t3_situation": blk(t3_ok, has_t3, t3_pairs)}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--answer", required=True)
+    ap.add_argument("--gt", required=True)
+    ap.add_argument("--out", default="reward.json")
+    ap.add_argument("--tol", type=float, default=TOL)
+    ap.add_argument("--primary", default="auto", choices=["auto", "strict", "t1"])
+    args = ap.parse_args()
+    tol = args.tol
+
+    try:
+        with open(args.answer, encoding="utf-8-sig") as f:
+            ans = as_rows(json.load(f))
+    except Exception as e:
+        print(f"answer unreadable ({e}) -> 0", file=sys.stderr)
+        ans = []
+    with open(args.gt, encoding="utf-8") as f:
+        gt = as_rows(json.load(f))
+
+    ws = gt_has_strategy(gt)
+    s_f1, s_p, s_r, s_tp, s_fp, s_fn, _ = match(ans, gt, k_strict, tol)
+    t1_f1, t1_p, t1_r, t1_tp, t1_fp, t1_fn, _ = match(ans, gt, k_t1, tol)
+    tiers = score_tiers(ans, gt, tol)
+
+    primary = args.primary
+    if primary == "auto":
+        primary = "strict" if ws else "t1"
+    reward = s_f1 if primary == "strict" else t1_f1
+
+    # diagnostic F1 at looser tolerances (not the reward)
+    diag = {}
+    for t in (5.0, 10.0):
+        f, *_ = match(ans, gt, k_strict, t)
+        diag[f"strict_f1_tol{int(t)}s"] = round(f, 6)
+    # Format diagnostic: T3 is the situation AFTER the move. An answer emitting
+    # `leader_before` instead gets no T3 credit; surface the count so a format
+    # error is distinguishable from genuine misreading of the position.
+    diag["answer_rows_using_leader_before"] = sum(
+        1 for r in ans if r.get("_used_leader_before"))
+
+    result = {
+        "reward": round(reward, 6),
+        "primary": primary,
+        "tol_s": tol,
+        "has_strategy": ws,
+        "strict": {"f1": round(s_f1, 6), "precision": round(s_p, 6),
+                   "recall": round(s_r, 6), "tp": s_tp, "fp": s_fp, "fn": s_fn},
+        "tiers": {
+            "t1_localization": {"f1": round(t1_f1, 6), "precision": round(t1_p, 6),
+                                "recall": round(t1_r, 6),
+                                "tp": t1_tp, "fp": t1_fp, "fn": t1_fn},
+            "t2_impact": tiers["t2_impact"],
+            "t3_situation": tiers["t3_situation"],
+            "localized_moves": tiers["localized_moves"],
+            "total_moves": tiers["total_moves"],
+        },
+        "detail": {"answer_rows": len(ans), "gt_rows": len(gt), **diag},
+    }
+    with open(args.out, "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+    print(json.dumps(result, ensure_ascii=False))
+    return result["reward"]
+
+
+if __name__ == "__main__":
+    main()

tools/make_harbor.py

@@ -0,0 +1,413 @@
+#!/usr/bin/env python3
+"""Generate the Harbor-compatible Video-Arena benchmark, Protocol B (default) or A.
+
+One Harbor task per case: 180 tasks in one dataset directory. See docs/HARBOR.md.
+
+    python tools/make_harbor.py --out harbor/video-arena [--protocol B|A]
+        [--net strict|docker|phase] [--base-image video-arena/base:latest]
+        [--games go,chess] [--cases 2] [--host-media /abs/media/root] [--force]
+
+Each task:
+    task.toml         Harbor task config (schema 1.4)
+    instruction.md    B: the agent's prompt (200 turns / 7200 s), which points at the file below.
+                      A: the A-rendered instruction itself; the Protocol A agent
+                      (tools/harbor/protocol_a_agent.py) appends the frames and the single-reply
+                      tail and makes the one request.
+    environment/      docker-compose.yaml -- prebuilt image, no network, the case's render (and,
+                      for B, its instruction) mounted read-only into /app -- and, for B, that
+                      instruction.md
+    tests/            test.sh, score_harbor.py, judge.py, gt.json, case.json (verifier only)
+    solution/         solve.sh, answer.json (GT projected onto the answer schema; oracle only)
+
+Protocol A on Harbor: the model never sees the container. The agent samples the paper's grid
+with ffmpeg INSIDE the offline sandbox, then sends the frames in one chat request from the host
+and writes the extracted answer to /app/answer.json. Same verifier, same reward keys as B.
+
+Deliberate separations
+  * Scoring never runs in the agent's container. /app/answer.json is the collected artifact;
+    a separate verifier container re-materializes it and runs the case judge there, so the
+    sandbox holds no ground truth, no judge and no solution.
+  * The dataset holds no video. Each compose file bind-mounts the render from
+    $VA_MEDIA_ROOT/<game>/media/<case_id>.mp4 on the Docker host, so the dataset stays small
+    (a few MB) and the 11.8 GB of renders are fetched once per host, not once per task.
+  * No network. The base image (tools/harbor/Dockerfile) pre-installs ffmpeg, Python and the
+    usual video/numeric libraries, and already holds the empty answer.json seed.
+"""
+
+import argparse
+import json
+import os
+import shutil
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+import va_core as C            # noqa: E402
+import score as S              # noqa: E402  (oracle_answer)
+
+DEFAULT_BASE_IMAGE = "video-arena/base:latest"
+MEDIA_VAR = "${VA_MEDIA_ROOT}"
+
+# --net: ([environment] line, [agent] line, Docker-level network_mode: none in the compose file)
+#   strict  Harbor no-network for the whole trial, AND no network interface at the Docker level.
+#           For host-side agents (terminus-2, oracle). Needs Harbor's egress control, which
+#           probes the Docker host for nftables support and rejects no-network tasks without it.
+#   docker  The same sandbox, offline through Docker alone; Harbor's own policy is left public.
+#           For Docker hosts where that probe fails.
+#   phase   Network while an installed agent (claude-code, codex, ...) installs itself, then
+#           Harbor no-network for the run, opened to the model API only via
+#           `harbor run --allow-agent-host <host>`. Needs Harbor's egress control.
+NET = {
+    "strict": ('network_mode = "no-network"', 'network_mode = "no-network"', True),
+    "docker": ('# offline via docker-compose.yaml (network_mode: none); Harbor policy stays public\n'
+               'network_mode = "public"', '# offline via docker-compose.yaml', True),
+    "phase":  ('# public only for agent setup (install); the run itself is no-network\n'
+               'network_mode = "public"', 'network_mode = "no-network"', False),
+}
+
+TASK_TOML = """# Generated by tools/make_harbor.py -- do not edit; regenerate instead.
+schema_version = "1.4"
+artifacts = ["/app/answer.json"]
+
+[task]
+name = "video-arena/{name}"
+version = "1.0.0"
+description = "{desc}"
+keywords = {keywords}
+
+[metadata]
+game = "{game}"
+case_id = "{cid}"
+family = "{family}"
+regime = "{regime}"
+root_key = "{root_key}"
+tol = {tol}
+protocol = "{protocol}"
+answer = "/app/answer.json"
+video = "{media}"
+{extra}
+[agent]
+{agent_budget}
+# the image's unprivileged user (tools/harbor/Dockerfile); the verifier runs as root
+user = "agent"
+{agent_net}
+
+[verifier]
+environment_mode = "separate"
+timeout_sec = 600.0
+
+[environment]
+docker_image = "{base_image}"
+workdir = "/app"
+{env_net}
+cpus = 4
+memory_mb = 8192
+
+[solution]
+env = {{}}
+"""
+
+# Per protocol: the [agent] budget, the description, and whether the sandbox gets the
+# instruction file (under A the model never sees the sandbox; the prompt is instruction.md).
+AGENT_BUDGET = {
+    "B": "# Protocol B: at most 200 tool-call turns inside a 7200 s hard wall clock.\n"
+         "timeout_sec = 7200.0",
+    "A": "# Protocol A: one request, no tools; frame sampling plus that one call.\n"
+         "timeout_sec = 3600.0",
+}
+DESC = {
+    "B": "Video-Arena Protocol B case %s/%s: watch the replay and infer event times, "
+         "outcomes and impact tiers from the video alone.",
+    "A": "Video-Arena Protocol A case %s/%s: one request with the sampled frames and no "
+         "tools; infer event times, outcomes and impact tiers from the frames alone.",
+}
+INSTRUCTION_MOUNT = """      - type: bind
+        source: ./instruction.md
+        target: /app/instruction.md
+        read_only: true
+"""
+
+COMPOSE_TOML = """# Generated by tools/make_harbor.py -- do not edit.
+#
+# The prebuilt image is the sandbox and already holds the empty /app/answer.json seed; this file
+# only mounts the case's read-only inputs into /app. With --net strict or docker it also
+# sets network_mode: none: Docker gives the sandbox no interface but loopback, and a service
+# that declares its own networking is left out of Harbor's egress-control sidecar. In strict
+# mode Harbor's no-network policy applies on top.
+services:
+  main:
+{net_line}    working_dir: /app
+    # Long syntax on purpose: a missing source fails the start instead of Docker silently
+    # creating an empty directory where the file should be.
+    volumes:
+{instruction_mount}      - type: bind
+        source: {media_src}
+        target: /app/match.mp4
+        read_only: true
+"""
+
+TEST_SH = """#!/bin/bash
+# Verifier entrypoint: score the agent's answer.json, then hand Harbor /logs/verifier/reward.json.
+set -euo pipefail
+mkdir -p /logs/verifier
+python3 /tests/score_harbor.py
+"""
+
+SOLVE_SH = """#!/bin/bash
+set -euo pipefail
+# Oracle reference: the ground truth projected onto the answer schema (tools/score.py).
+cp /solution/answer.json /app/answer.json
+echo "wrote /app/answer.json"
+"""
+
+SCORE_PY = '''#!/usr/bin/env python3
+"""Score the agent's /app/answer.json with this case judge; write /logs/verifier/reward.json.
+
+Runs in the VERIFIER container, never in the sandbox: the judge and the ground truth are
+uploaded here for scoring and are absent from the agent container.
+
+Reward keys follow the public Video-Arena scorer (tools/score.py):
+
+    reward        the case headline reward (judge reward.reward)
+    t1_f1         T1 localization F1
+    t2_macro_acc  T2 macro accuracy
+    t3_macro_acc  T3 macro accuracy
+
+Any tier the judge did not report is recorded as 0.0: Harbor accepts only finite numbers, and a
+tier the judge declined to score is a tier the answer earned nothing on.
+
+A missing or unparseable /app/answer.json is not an exception. It is scored as the pre-seeded
+empty answer -- reward 0.0, every tier 0.0 -- which covers the run that died before writing
+anything, the artifact upload that failed, and the wiped sandbox alike. Those must grade zero
+rather than surface as a harness error. A judge that cannot run at all is a real harness error
+and is graded zero loudly, on stderr, in the verifier log.
+"""
+
+import json
+import os
+import subprocess
+import sys
+
+TESTS = os.path.dirname(os.path.abspath(__file__))
+ANSWER = "/app/answer.json"
+GT = os.path.join(TESTS, "gt.json")
+JUDGE = os.path.join(TESTS, "judge.py")
+OUT = "/logs/verifier/reward.json"
+TOL = float(os.environ.get("VA_TOL", {tol!r}))
+PRIMARY = {primary!r}
+
+
+def load_answer():
+    """The agent answer, or the pre-seeded empty answer when there is nothing scoreable."""
+    try:
+        with open(ANSWER, encoding="utf-8") as fh:
+            doc = json.load(fh)
+        if isinstance(doc, dict):
+            return doc
+        sys.stderr.write("answer.json is %s, not an object; scoring it as empty\\n"
+                         % type(doc).__name__)
+    except Exception as exc:
+        sys.stderr.write("answer.json unreadable (%s); scoring it as empty\\n" % exc)
+    return {{"{root_key}": []}}
+
+
+def judge(answer_doc):
+    """Run the case judge exactly as its CLI documents; None if the judge itself failed."""
+    staged = "/logs/verifier/answer.scored.json"
+    with open(staged, "w", encoding="utf-8") as fh:
+        json.dump(answer_doc, fh)
+    cmd = [sys.executable, JUDGE, "--answer", staged, "--gt", GT,
+           "--out", "/logs/verifier/judge.json", "--tol", str(TOL)]
+    if PRIMARY:
+        cmd += ["--primary", PRIMARY]
+    proc = subprocess.run(cmd, capture_output=True, text=True, encoding="utf-8",
+                          errors="replace")
+    if proc.returncode != 0:
+        sys.stderr.write("judge exited %s\\n%s\\n" % (proc.returncode, proc.stderr[-4000:]))
+        return None
+    with open("/logs/verifier/judge.json", encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+def subscores(reward):
+    """The four published numbers, mirroring tools/score.py:subscores (no va_core here).
+    The two judge families put the tier block in different places."""
+    t = reward.get("tiers")
+    if t:
+        t3 = t.get("t3_situation") or t.get("t3_score") or {{}}
+        t3v = t3.get("macro_acc")
+        if t3v is None:
+            t3v = t3.get("exact_pair_acc")
+        return {{"reward": reward.get("reward"),
+                "t1_f1": (t.get("t1_localization") or {{}}).get("f1"),
+                "t2_macro_acc": (t.get("t2_impact") or {{}}).get("macro_acc"),
+                "t3_macro_acc": t3v}}
+    d = reward.get("detail", {{}})
+    t2 = d.get("t2_round_winner") or d.get("t2_minute_gain_event") or d.get("t2_impact") or {{}}
+    t3 = (d.get("t3_score_track") or d.get("t3_leader_after_event")
+          or d.get("t3_situation") or {{}})
+    t3v = t3.get("exact_frac")
+    if t3v is None:
+        t3v = t3.get("macro_acc")
+    return {{"reward": reward.get("reward"),
+            "t1_f1": (d.get("t1_localization") or {{}}).get("f1"),
+            "t2_macro_acc": t2.get("macro_acc"),
+            "t3_macro_acc": t3v}}
+
+
+def main():
+    os.makedirs(os.path.dirname(OUT), exist_ok=True)
+    reward = judge(load_answer())
+    scores = {{"reward": 0.0, "t1_f1": 0.0, "t2_macro_acc": 0.0, "t3_macro_acc": 0.0}}
+    if reward is not None:
+        for key, value in subscores(reward).items():
+            if isinstance(value, bool) or not isinstance(value, (int, float)):
+                value = 0.0
+            scores[key] = float(value)
+    with open(OUT, "w", encoding="utf-8") as fh:
+        json.dump(scores, fh, indent=2, sort_keys=True)
+        fh.write("\\n")
+    print(json.dumps(scores, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()
+'''
+
+
+# Build-time diagnostics in CASE_TYPES.json that stay out of the published task metadata.
+_META_SKIP = {"id", "case_id", "features", "t3_classes", "t2_classes", "zone_counts",
+              "hud_audit", "result", "type_zh", "winner"}
+
+
+def meta_extra(extra):
+    """The case's own tags from CASE_TYPES.json as [metadata] lines. Only short scalar fields
+    ride along; the long derived dictionaries are build diagnostics, not task metadata."""
+    out = []
+    for key in sorted(extra):
+        value = extra[key]
+        if key in _META_SKIP or isinstance(value, (dict, list)):
+            continue
+        if isinstance(value, bool) or not isinstance(value, (int, float)):
+            value = str(value)
+        out.append("%s = %s\n" % (key, json.dumps(value, ensure_ascii=False)))
+    return "".join(out)
+
+
+def write(path, text, mode=None):
+    with open(path, "w", encoding="utf-8", newline="\n") as fh:
+        fh.write(text)
+    if mode is not None:
+        os.chmod(path, mode)
+
+
+def build_task(game, cid, out_dir, args):
+    meta = C.resolve(game, cid)
+    with open(meta["gt"], encoding="utf-8") as fh:
+        gt = json.load(fh)
+    answer = S.oracle_answer(game, gt)
+    # The oracle answer must be a PROJECTION of the ground truth: every key it carries comes
+    # from the GT (dota2's schema has two optional dense blocks beyond the event list), and the
+    # event list survives the projection whole.
+    bad = [k for k in answer if k not in gt]
+    if bad:
+        raise SystemExit("%s/%s: oracle answer invents keys not in GT: %s" % (game, cid, bad))
+    if len(answer[meta["root_key"]]) != len(gt[meta["root_key"]]):
+        raise SystemExit("%s/%s: oracle event count differs from GT" % (game, cid))
+
+    name = "%s-%s" % (game, cid)
+    task_dir = os.path.join(out_dir, name)
+    tests = os.path.join(task_dir, "tests")
+    env_dir = os.path.join(task_dir, "environment")
+    sol_dir = os.path.join(task_dir, "solution")
+    for d in (tests, env_dir, sol_dir):
+        os.makedirs(d, exist_ok=True)
+
+    video = "%s/%s/media/%s.mp4" % (args.host_media or MEDIA_VAR, game, cid)
+    proto = args.protocol
+
+    write(os.path.join(task_dir, "task.toml"), TASK_TOML.format(
+        name=name, desc=DESC[proto] % (game, cid), game=game, cid=cid,
+        family=meta["family"], protocol=proto, agent_budget=AGENT_BUDGET[proto],
+        regime=C.REGIME[game], root_key=meta["root_key"], tol=meta["tol"], media=video,
+        extra=meta_extra(C.case_meta(game).get(cid, {})), base_image=args.base_image,
+        env_net=NET[args.net][0], agent_net=NET[args.net][1],
+        keywords=json.dumps(["video-arena", "video-understanding", game, C.REGIME[game],
+                             "protocol-" + proto.lower()])))
+    write(os.path.join(env_dir, "docker-compose.yaml"), COMPOSE_TOML.format(
+        net_line="    network_mode: none\n" if NET[args.net][2] else "",
+        instruction_mount=INSTRUCTION_MOUNT if proto == "B" else "",
+        media_src=video if args.host_media
+        else "${VA_MEDIA_ROOT:?set VA_MEDIA_ROOT to the Video-Arena tasks directory}"
+             "/%s/media/%s.mp4" % (game, cid)))
+    # LF only: some instruction sources carry stray CRLF, which is noise inside a Linux sandbox.
+    if proto == "B":
+        write(os.path.join(task_dir, "instruction.md"), C.build_harbor_prompt())
+        write(os.path.join(env_dir, "instruction.md"),
+              C.instruction_for("agentic", meta["instruction"]).replace("\r\n", "\n"))
+    else:
+        write(os.path.join(task_dir, "instruction.md"),
+              C.instruction_for("video", meta["instruction"]).replace("\r\n", "\n"))
+    write(os.path.join(tests, "test.sh"), TEST_SH, mode=0o755)
+    write(os.path.join(tests, "score_harbor.py"), SCORE_PY.format(
+        tol=meta["tol"], primary=meta["primary"], root_key=meta["root_key"]))
+    shutil.copyfile(meta["judge"], os.path.join(tests, "judge.py"))
+    shutil.copyfile(meta["gt"], os.path.join(tests, "gt.json"))
+    write(os.path.join(tests, "case.json"), json.dumps(
+        {"game": game, "case_id": cid, "family": meta["family"],
+         "root_key": meta["root_key"], "tol": meta["tol"]}, indent=2) + "\n")
+    write(os.path.join(sol_dir, "solve.sh"), SOLVE_SH, mode=0o755)
+    write(os.path.join(sol_dir, "answer.json"), json.dumps(answer, indent=2) + "\n")
+    return name
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Generate the Harbor Video-Arena dataset.")
+    ap.add_argument("--out", required=True, help="dataset directory to (re)generate")
+    ap.add_argument("--games", default=",".join(C.GAMES),
+                    help="comma-separated subset of: %s" % ",".join(C.GAMES))
+    ap.add_argument("--cases", type=int, default=0,
+                    help="first N cases per game (0 = all 20)")
+    ap.add_argument("--protocol", choices=("B", "A"), default="B",
+                    help="B (default): the agentic sandbox task. A: the single-request task, "
+                         "run with -a protocol_a_agent:ProtocolA (see docs/HARBOR.md)")
+    ap.add_argument("--base-image", default=DEFAULT_BASE_IMAGE,
+                    help="prebuilt sandbox/verifier image (tools/harbor/Dockerfile)")
+    ap.add_argument("--net", choices=sorted(NET), default="strict",
+                    help="strict (default): offline for the whole trial, enforced by Harbor and "
+                         "by Docker, for host-side agents such as terminus-2. docker: the same "
+                         "sandbox enforced by Docker alone, for hosts where Harbor's "
+                         "egress-control probe fails. phase: network only while an installed "
+                         "agent installs itself; run with --allow-agent-host <model API host>.")
+    ap.add_argument("--host-media", default=None, metavar="DIR",
+                    help="absolute host directory to pin in the generated compose files "
+                         "(default: the literal ${VA_MEDIA_ROOT}, resolved at run time)")
+    ap.add_argument("--force", action="store_true",
+                    help="delete --out first (it may hold tasks from a previous run)")
+    args = ap.parse_args()
+
+    games = [g for g in args.games.split(",") if g]
+    unknown = [g for g in games if g not in C.GAMES]
+    if unknown:
+        raise SystemExit("unknown game(s): %s" % unknown)
+    out_dir = os.path.abspath(args.out)
+    if os.path.exists(out_dir):
+        if not args.force:
+            raise SystemExit("%s exists; pass --force to regenerate it" % out_dir)
+        shutil.rmtree(out_dir)
+    os.makedirs(out_dir)
+
+    made = []
+    for game in games:
+        ids = C.case_ids(game)
+        for cid in ids[:args.cases] if args.cases else ids:
+            made.append(build_task(game, cid, out_dir, args))
+
+    print("%d Protocol %s tasks -> %s" % (len(made), args.protocol, out_dir))
+    print("image: %s   net: %s" % (args.base_image, args.net))
+    print("media: %s/<game>/media/<case_id>.mp4, mounted read-only at /app/match.mp4"
+          % (args.host_media or "$VA_MEDIA_ROOT"))
+
+
+if __name__ == "__main__":
+    main()

tools/run_protocol_a.py

@@ -0,0 +1,306 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""run_protocol_a.py -- minimal Protocol A (video understanding) reference runner.
+
+Protocol A is ONE chat call. The video is reduced to a uniform grid of JPEG frames, the
+frames and the instruction go into a single user turn, and the model's reply must contain
+one JSON object. No tools, no filesystem, no second turn.
+
+    export VA_API_KEY=...        # or --api-key
+    python tools/run_protocol_a.py --model gpt-5.6 --base-url https://api.example.com/v1 \
+        --game chess --case all --out runs/gpt56-A --reasoning-effort high
+    python tools/score.py --answers runs/gpt56-A/answers
+
+Requires: ffmpeg + ffprobe on PATH (frame sampling), and an OpenAI-compatible
+/chat/completions endpoint that accepts image_url parts. Nothing else -- the HTTP call is
+urllib, so there is no SDK to pin.
+
+This is a REFERENCE implementation: it shows the measurement, not our production harness.
+It has no retry policy, no rate limiting and no cost accounting; --workers runs cells
+concurrently (the paper uses 5 per system for Protocol A). What it
+does have is the part that must not vary between systems -- the sampling grid, the single
+turn, and the answer extraction -- because those are the benchmark, and a driver that
+changes them is measuring something else.
+
+    THE SAMPLING GRID (one grid, every model, every game):
+        1 FPS, capped at 256 frames spread uniformly over the whole match, longest side
+        768px, never upscaled.
+
+    1 FPS because the board or map is idle most of the time (denser sampling returns
+    duplicate stills); one shared cap so every row of a results table is the same
+    measurement. Where a provider's image limit is below 256, degrade and RECORD it
+    (run.json carries n_frames). Where its request-size cap is the binding limit (256 busy
+    frames at -q:v 4 can exceed 30 MB once base64-encoded), raise --jpeg-q instead and keep
+    the 256 frames; run.json carries sampling.jpeg_q. No upscaling: several boards render
+    below 768px (go 612, chess 548, gomoku 504).
+
+THE PROMPT is va_core.protocol_a_prompt(): the A-rendered instruction, then the paper's
+single-reply tail, which hands over the grid's explicit video_ts array. The Harbor agent
+(tools/harbor/protocol_a_agent.py) builds it with the same function, on the same grid.
+
+On a long match the grid itself caps T1 recall at min(1, 2*TOL/spacing), independent of the
+model; run.json carries t1_recall_ceiling for every cell.
+
+WHAT A CELL EXPORTS. A reply that arrived but holds no answer object (empty, prose only, or
+cut off before the object closed) is the model's result: the empty answer seed is exported
+for it, so it scores 0.0 and stays in the mean, with status "no_answer" in run.json. A call
+that never produced a reply (ffmpeg, HTTP, timeout) exports nothing and stays missing -- it
+measured the endpoint, not the model. A re-run of a cell first deletes the answer, run.json
+and reply an earlier run left, so a failed re-run is never scored on its predecessor.
+"""
+import argparse
+import base64
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+import urllib.error
+from concurrent.futures import ThreadPoolExecutor
+import urllib.request
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import va_core as C  # noqa: E402
+
+TARGET_FPS = 1.0
+MAX_FRAMES = 256
+MAX_WIDTH = 768
+JPEG_Q = 4                      # ffmpeg -q:v, 2 (best) .. 31 (worst)
+
+FFMPEG = os.environ.get("VA_FFMPEG", "ffmpeg")
+FFPROBE = os.environ.get("VA_FFPROBE", "ffprobe")
+
+# The grid helpers below are pure argument builders where possible: the Harbor agent runs the
+# same ffprobe/ffmpeg commands inside the task container, so both paths sample identically.
+def probe_args(path, entries, ffprobe=FFPROBE):
+    return [ffprobe, "-v", "error", "-select_streams", "v:0", "-show_entries", entries,
+            "-of", "csv=p=0", path]
+
+
+def probe(path, entries):
+    out = subprocess.check_output(probe_args(path, entries), text=True).strip()
+    return out.splitlines()[0] if out else ""
+
+
+def video_duration(path):
+    return float(probe(path, "format=duration").strip() or 0.0)
+
+
+def parse_rate(rate):
+    """ffprobe's r_frame_rate ("30000/1001") as a float; 0.0 when unreadable."""
+    num, _, den = rate.strip().partition("/")
+    try:
+        d = float(den) if den else 1.0
+        return float(num) / d if d else 0.0
+    except ValueError:
+        return 0.0
+
+
+def video_fps(path):
+    return parse_rate(probe(path, "stream=r_frame_rate"))
+
+
+def grid_fps(dur, native_fps, max_frames=MAX_FRAMES):
+    """The grid's rate: min(TARGET_FPS, max_frames/duration), additionally bounded by the
+    container rate, so ffmpeg is never asked to fabricate frames a source does not present
+    (chess renders natively at 1 FPS)."""
+    fps = min(TARGET_FPS, max_frames / dur) if dur > 0 else TARGET_FPS
+    if native_fps and fps > native_fps:
+        fps = native_fps
+    return fps
+
+
+def ffmpeg_args(video, pattern, fps, ffmpeg=FFMPEG, jpeg_q=JPEG_Q):
+    vf = "fps=%.6f,scale='min(%d,iw)':-1" % (fps, MAX_WIDTH)
+    return [ffmpeg, "-y", "-loglevel", "error", "-i", video, "-vf", vf,
+            "-q:v", str(jpeg_q), pattern]
+
+
+def grid_ts(n, fps):
+    """video_ts of the n kept frames: frame k is at k / fps."""
+    return [round(i / fps, 2) for i in range(n)]
+
+
+def sample_frames(video, out_dir, max_frames=MAX_FRAMES, jpeg_q=JPEG_Q):
+    """Uniform grid -> (paths, timestamps, fps, duration). See the module docstring for the
+    policy. The hard clamp after extraction is not redundant: ffmpeg's fps filter overshoots
+    by a frame or two on rounding, and providers enforce their image cap inclusively.
+    """
+    os.makedirs(out_dir, exist_ok=True)
+    dur = video_duration(video)
+    fps = grid_fps(dur, video_fps(video), max_frames)
+    subprocess.run(ffmpeg_args(video, os.path.join(out_dir, "f_%05d.jpg"), fps,
+                               jpeg_q=jpeg_q), check=True)
+    paths = [os.path.join(out_dir, f) for f in sorted(os.listdir(out_dir))
+             if f.startswith("f_") and f.endswith(".jpg")]
+    if len(paths) > max_frames:
+        paths = paths[:max_frames]
+    return paths, grid_ts(len(paths), fps), fps, dur
+
+
+def data_uri(path):
+    with open(path, "rb") as fh:
+        return "data:image/jpeg;base64," + base64.b64encode(fh.read()).decode()
+
+
+def chat(base_url, api_key, model, text, frame_paths, max_tokens, temperature, timeout,
+         reasoning_effort=None, extra_body=None):
+    """One OpenAI-compatible /chat/completions call. Returns (reply_text, usage_dict).
+    extra_body is merged into the request as-is (e.g. a vLLM server's chat_template_kwargs)."""
+    content = [{"type": "text", "text": text}]
+    for p in frame_paths:
+        content.append({"type": "image_url", "image_url": {"url": data_uri(p)}})
+    req = {"model": model, "messages": [{"role": "user", "content": content}],
+           "max_tokens": max_tokens, "temperature": temperature}
+    if reasoning_effort:
+        req["reasoning_effort"] = reasoning_effort
+    req.update(extra_body or {})
+    body = json.dumps(req).encode()
+    req = urllib.request.Request(
+        base_url.rstrip("/") + "/chat/completions", data=body,
+        headers={"Content-Type": "application/json", "Authorization": "Bearer " + api_key})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            out = json.loads(resp.read().decode("utf-8", "replace"))
+    except urllib.error.HTTPError as e:     # keep the provider's reason, not just the code
+        raise RuntimeError("HTTP %s from the endpoint (request %.1f MB): %s"
+                           % (e.code, len(body) / 1e6,
+                              e.read()[:300].decode("utf-8", "replace"))) from None
+    choice = (out.get("choices") or [{}])[0]
+    return (choice.get("message") or {}).get("content") or "", {
+        "usage": out.get("usage"), "finish_reason": choice.get("finish_reason")}
+
+
+PRINT_LOCK = threading.Lock()
+
+
+def run_cell(a, g, cid):
+    """One cell: sample, ask, extract, export. Never raises for a model or endpoint failure;
+    run.json records it."""
+    r = C.resolve(g, cid)
+    cell = os.path.join(a.out, "cells", g, cid)
+    dst = os.path.join(a.out, "answers", g, cid + ".json")
+    # nothing an earlier run of this cell left may be read as this run's result
+    for p in (dst, os.path.join(cell, "run.json"), os.path.join(cell, "reply.txt")):
+        if os.path.isfile(p):
+            os.remove(p)
+    os.makedirs(cell, exist_ok=True)
+    os.makedirs(os.path.dirname(dst), exist_ok=True)
+    fdir = os.path.join(cell, "frames") if a.keep_frames \
+        else tempfile.mkdtemp(prefix="va_frames_")
+    t0 = time.time()
+    rec = {"protocol": "A", "game": g, "case_id": cid, "model": a.model,
+           "root_key": r["root_key"], "tol_s": C.TOL,
+           "sampling": {"target_fps": TARGET_FPS, "max_frames": a.max_frames,
+                        "max_width": MAX_WIDTH, "jpeg_q": a.jpeg_q},
+           "max_tokens": a.max_tokens, "temperature": a.temperature,
+           "reasoning_effort": a.reasoning_effort, "extra_body": a.extra_body}
+    try:
+        paths, ts, fps, dur = sample_frames(r["video"], fdir, a.max_frames, a.jpeg_q)
+        rec.update(n_frames=len(paths), fps=round(fps, 6), duration_s=round(dur, 2),
+                   t1_recall_ceiling=round(C.t1_recall_ceiling(dur, len(paths)), 4))
+        prompt = C.protocol_a_prompt(C.instruction_for("video", r["instruction"]),
+                                     dur, ts, fps, r["root_key"])
+        reply, meta = chat(a.base_url, a.api_key, a.model, prompt, paths,
+                           a.max_tokens, a.temperature, a.timeout,
+                           a.reasoning_effort, a.extra_body)
+        rec.update(meta)
+        with open(os.path.join(cell, "reply.txt"), "w", encoding="utf-8") as fh:
+            fh.write(reply)
+        cands = C.answer_candidates(reply, r["root_key"])
+        rec["n_json_blocks"] = len(cands)
+        try:
+            obj = C.extract_answer(reply, r["root_key"])
+        except ValueError as e:
+            # The model replied without an answer object: its result, scored 0.0
+            # via the empty seed -- not a missing cell.
+            shutil.copyfile(r["answer_seed"], dst)
+            rec.update(status="no_answer", n_rows=0, answer_exported="seed",
+                       error="%s: %s" % (type(e).__name__, str(e)[:400]))
+        else:
+            rows = obj.get(r["root_key"])
+            rec["n_rows"] = len(rows) if isinstance(rows, list) else 0
+            with open(dst, "w", encoding="utf-8") as fh:
+                json.dump(obj, fh, ensure_ascii=False)
+            rec.update(status="ok", answer_exported="reply")
+    except Exception as e:
+        # Record WHY, per cell. A bare 0.0 cannot be told apart from a refusal, a
+        # truncation, or a model that answered in prose -- and those call for
+        # different fixes.
+        rec["status"] = "error"
+        rec["error"] = "%s: %s" % (type(e).__name__, str(e)[:400])
+    finally:
+        if not a.keep_frames:
+            shutil.rmtree(fdir, ignore_errors=True)
+    rec["wall_s"] = round(time.time() - t0, 1)
+    with open(os.path.join(cell, "run.json"), "w", encoding="utf-8") as fh:
+        json.dump(rec, fh, ensure_ascii=False, indent=2)
+    with PRINT_LOCK:
+        print("%-10s %-38s %-9s n_frames=%s n_rows=%s %s"
+              % (g, cid, rec["status"], rec.get("n_frames"), rec.get("n_rows"),
+                 rec.get("error", "")), flush=True)
+    return rec
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--model", required=True, help="model id the endpoint expects")
+    ap.add_argument("--base-url", required=True, help="OpenAI-compatible base, ending in /v1")
+    ap.add_argument("--api-key", default=os.environ.get("VA_API_KEY", ""))
+    ap.add_argument("--game", action="append", required=True,
+                    help="game to run (repeatable), or 'all'")
+    ap.add_argument("--case", default="all", help="case id, or 'all' (default)")
+    ap.add_argument("--limit", type=int, default=0,
+                    help="with --case all: only the first N cases of each game (frozen order)")
+    ap.add_argument("--out", required=True, help="output root; answers land in <out>/answers")
+    ap.add_argument("--max-frames", type=int, default=MAX_FRAMES,
+                    help="degrade the 256-frame cap for a provider that rejects it; "
+                         "recorded in run.json so the cell is readable as degraded")
+    ap.add_argument("--jpeg-q", type=int, default=JPEG_Q,
+                    help="ffmpeg -q:v for the frames (default %d; higher = smaller). Raise it "
+                         "for a provider whose request-size cap rejects the 256-frame grid; "
+                         "recorded in run.json" % JPEG_Q)
+    ap.add_argument("--max-tokens", type=int, default=48000,
+                    help="output budget; a long match needs a large one -- a truncated "
+                         "reply loses the tail of the answer, not just its formatting")
+    ap.add_argument("--temperature", type=float, default=0.0)
+    ap.add_argument("--reasoning-effort", default=None,
+                    help="sent as reasoning_effort when set; the paper uses high for the GPT, "
+                         "Claude and Gemini models and the provider default otherwise")
+    ap.add_argument("--extra-body", type=json.loads, default=None,
+                    help="JSON object merged into the request, e.g. "
+                         "'{\"chat_template_kwargs\": {\"enable_thinking\": true}}' for a "
+                         "Qwen model on vLLM; recorded in run.json")
+    ap.add_argument("--timeout", type=int, default=1800)
+    ap.add_argument("--workers", type=int, default=1,
+                    help="cells run concurrently (default 1; the paper uses 5)")
+    ap.add_argument("--keep-frames", action="store_true", help="keep the sampled JPEGs")
+    a = ap.parse_args()
+
+    if not a.api_key:
+        ap.error("--api-key or VA_API_KEY is required")
+    for tool in (FFMPEG, FFPROBE):
+        if not shutil.which(tool):
+            ap.error("%s not found on PATH (set VA_FFMPEG / VA_FFPROBE)" % tool)
+    games = C.GAMES if "all" in a.game else a.game
+    for g in games:
+        if g not in C.GAMES:
+            ap.error("unknown game %r" % g)
+
+    cells = [(g, cid) for g in games
+             for cid in ((C.case_ids(g)[:a.limit or None]) if a.case == "all"
+                         else [a.case])]
+    with ThreadPoolExecutor(max_workers=max(1, a.workers)) as pool:
+        list(pool.map(lambda gc: run_cell(a, *gc), cells))
+
+    print("\nanswers in %s\n  python tools/score.py --answers %s"
+          % (os.path.join(a.out, "answers"), os.path.join(a.out, "answers")))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tools/run_protocol_b.py

@@ -0,0 +1,410 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""run_protocol_b.py -- minimal Protocol B (agentic) reference runner.
+
+Protocol B hands the WHOLE video to a coding agent in a sandbox folder and lets it work for
+many turns: sample frames however it likes, write its own parsers, and build up `answer.json`
+incrementally. It is the same task as Protocol A and a different capability -- tool use and
+self-directed sampling instead of a fixed frame grid.
+
+This script builds the sandbox and runs YOUR agent in it. It deliberately does not bundle a
+harness: every coding agent has its own CLI, and hardcoding one would make the reference
+implementation useless for the others. You supply the command; this script supplies the part
+that must not vary between systems -- what is in the sandbox, what the agent is told, and
+what gets collected afterwards.
+
+    python tools/run_protocol_b.py --game chess --case all --out runs/agentX-B \\
+        --agent-cmd "claude -p @PROMPT_FILE@ --max-turns 200" [--workers 3]
+    python tools/score.py --answers runs/agentX-B/answers
+
+Placeholders in --agent-cmd, substituted per cell:
+
+    @PROMPT_FILE@   path to prompt.txt      (the turn-1 user message)
+    @PROMPT@        the prompt text itself, for a CLI that takes it inline
+    @SANDBOX@       the sandbox folder       (also the command's working directory)
+
+--agent-cmd is split with POSIX quoting on every OS ("a b" is one argument, the quotes are
+removed); on Windows a backslash is literal, so C:\\tools\\agent.exe needs no escaping.
+
+Prefer @PROMPT_FILE@. A multi-line prompt passed as one argv element is truncated at the
+first newline by several shells and batch shims, and a truncated prompt still SCORES -- the
+agent re-derives the task from instruction.md and the cell looks like a valid measurement.
+
+THE SANDBOX -- a fresh folder with a random name under the system temp dir (or
+--sandbox-root), outside the repo and never reused, holding exactly these files:
+
+    match.mp4         the video, the only input (renamed, so the case id is not a hint)
+    instruction.md    the task, rendered for Protocol B
+    answer.json       a BYTE-FOR-BYTE copy of answer_seed.json: the root key, empty list
+
+The sandbox is outside the repo so the ground truth is not a relative path away and the
+folder name does not spell the case id; prompt.txt sits next to the sandbox, not in it.
+An agent with full-disk access can still go looking for the repo -- that is caught by the
+transcript audit below, not by the folder layout.
+
+Pre-seeding rather than letting the agent create the file is what makes "it never answered"
+measurable: if the final bytes still hash to the seed, the agent never wrote an answer, and
+that is a different result from an answer that scored 0.0. It is still SCORED 0.0 -- the
+runner exports the untouched seed for a never_wrote or deleted answer, so the cell stays in
+the mean (leaving it out would let an agent that never answers post a higher mean than one
+that answers badly) -- and run.json records which of the three happened.
+
+A re-run of a cell first deletes the answer, run.json and logs an earlier run left, so a run
+that dies early can never be scored on its predecessor's answer. On timeout the agent's whole
+process tree is killed, not just the command you gave: an agent CLI is a launcher, and its
+children would otherwise keep running -- and keep writing -- after the cell was collected.
+
+WHAT THIS DOES NOT DO: enforce the no-network rule. The agent's own brain is an HTTPS call,
+so there is no configuration where the sandbox is offline and the run still happens. The
+prompt states the rule, and a serious evaluation AUDITS the agent's transcript afterwards
+for package installs, downloads, and lookups of the match. An audit is the honest mechanism
+here; a claim of isolation would not be true. Your harness's transcript format is your own,
+so the audit lives in your harness -- not here.
+"""
+import argparse
+import hashlib
+import json
+import os
+import shlex
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import va_core as C  # noqa: E402
+
+# The turn-1 message. It carries only the DELIVERY contract -- the task itself is
+# instruction.md, which the agent is told to read. Deliberately identical across systems
+# except for the one budget sentence, which is a harness fact rather than a wording choice:
+# a harness that cannot count turns must not be made to claim a turn cap.
+PROMPT = """You are a HEADLESS autonomous agent -- there is no human to talk to.
+Communicate ONLY by calling tools (running commands, reading and writing files); a text
+reply is not an answer. Your one deliverable is the file `answer.json` in this folder.
+
+Read `instruction.md` in this folder for the task and the exact `answer.json` schema. The
+only input is the video `match.mp4` in this folder. The video plays at 1:1 real speed;
+`instruction.md` says exactly which clock each time field you report is on.
+
+Solve it yourself, from the video. Do not use the network for anything: no downloading or
+installing packages, models or weights, no calls to any external service, API or model, and
+no looking this match up. The shell, the Python already installed, and the video tools
+already on this machine are your only tools. Any network use voids the run, which is then
+scored zero whatever `answer.json` contains.
+
+`answer.json` is already in this folder -- it was created before your first turn, with the
+schema's root key and an empty list. Do not delete it, do not rename it, and do not change
+the root key. Overwrite it in place -- in full, valid JSON every time -- as soon as you have
+something to put in it, and keep overwriting it as you learn more. It must be valid JSON at
+every moment: rewrite it in full each time (read -> add -> write back), never leave it
+half-written. Each rewrite should contain everything the previous one had, plus the new rows;
+if you are deep into the video and the file is not getting longer, you are overwriting
+instead of appending.
+
+Whatever is in `answer.json` when the run stops is what gets scored. If you are cut off,
+every row already written still counts; rows kept only in your reasoning, to be written out
+at the end, score zero.
+
+{budget} Everything else -- including how you sample the video -- is up to you."""
+
+
+def build_prompt(max_turns, timeout_s):
+    minutes = round(timeout_s / 60)
+    if max_turns:
+        budget = ("You have at most %d tool-call turns and about %d minutes of wall-clock "
+                  "time. When either limit is reached you are stopped immediately."
+                  % (max_turns, minutes))
+    else:
+        budget = ("You have about %d minutes of wall-clock time. When that limit is reached "
+                  "you are stopped immediately." % minutes)
+    return PROMPT.format(budget=budget)
+
+
+def seed_answer(sandbox, game, root_key):
+    """Copy answer_seed.json into the sandbox as answer.json, byte for byte.
+
+    Byte-for-byte rather than json.dump: a driver that re-serializes the seed can get the
+    root key wrong, and the resulting 0.0 looks exactly like a model that cannot write JSON.
+    Fails closed on a seed that is missing, unparseable, keyed differently from the judge, or
+    carries a row -- each of those would be charged to the agent.
+    """
+    src = C.resolve(game, "_")["answer_seed"]
+    with open(src, "rb") as fh:
+        raw = fh.read()
+    seed = json.loads(raw.decode("utf-8"))
+    if root_key not in seed:
+        raise ValueError("%s: seed keys %s do not include the judge's root key %r"
+                         % (game, list(seed), root_key))
+    for k, v in seed.items():
+        if isinstance(v, list) and v:
+            raise ValueError("%s: seed key %r is not empty -- a seeded row is part of the "
+                             "answer" % (game, k))
+    dst = os.path.join(sandbox, "answer.json")
+    shutil.copyfile(src, dst)
+    st = os.stat(dst)
+    return {"seed_sha256": hashlib.sha256(raw).hexdigest(), "seeded_size": st.st_size}
+
+
+def answer_state(sandbox, baseline):
+    """Three outcomes, told apart by the digest rather than by the score:
+
+      deleted       the agent removed or renamed the file (the prompt says not to)
+      never_wrote   still byte-identical to the seed: the agent never answered, which is a
+                    budget or behaviour failure, not "answered and scored 0"
+      wrote         the bytes changed, so score whatever is in there
+
+    The first two both score 0.0 (the runner exports the seed for them); this field is what
+    tells them apart afterwards. The digest decides, not mtime or size: rewriting the seed
+    with identical content is still not an answer.
+    """
+    p = os.path.join(sandbox, "answer.json")
+    if not os.path.isfile(p):
+        return {"state": "deleted", "final_sha256": None, "final_size": None}
+    with open(p, "rb") as fh:
+        raw = fh.read()
+    dig = hashlib.sha256(raw).hexdigest()
+    return {"state": "never_wrote" if dig == baseline["seed_sha256"] else "wrote",
+            "final_sha256": dig, "final_size": len(raw)}
+
+
+def split_cmd(cmd):
+    """--agent-cmd -> argv, with POSIX quoting on every OS. shlex's Windows mode
+    (posix=False) keeps the quote characters INSIDE the token, so `--system "be terse"`
+    reached the agent as two arguments `"be` and `terse"`. Backslash is literal on Windows,
+    so a path like C:\\tools\\agent.exe survives unescaped."""
+    lex = shlex.shlex(cmd, posix=True)
+    lex.whitespace_split = True
+    lex.commenters = ""
+    if os.name == "nt":
+        lex.escape = ""
+    return list(lex)
+
+
+def kill_tree(p):
+    """Kill `p` AND everything it started. subprocess.run(timeout=) kills only the direct
+    child, and an agent CLI is a launcher: the model loop, its shell and that shell's ffmpeg
+    are descendants, and they kept running -- and kept writing answer.json -- after the cell
+    had been collected."""
+    if os.name == "nt":
+        subprocess.run(["taskkill", "/PID", str(p.pid), "/T", "/F"],
+                       stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    else:
+        try:
+            os.killpg(p.pid, signal.SIGKILL)        # start_new_session: pgid == pid
+        except (ProcessLookupError, PermissionError):
+            pass
+    try:
+        p.kill()
+    except OSError:
+        pass
+    p.wait()
+
+
+def run_agent(cmd, cwd, stdout, stderr, timeout_s):
+    """Run the agent as the root of its own process tree and return its exit code. On
+    timeout -- or anything else that interrupts this script, Ctrl-C included -- the whole
+    tree is killed before the exception propagates."""
+    kw = {} if os.name == "nt" else {"start_new_session": True}
+    p = subprocess.Popen(cmd, cwd=cwd, stdout=stdout, stderr=stderr, **kw)
+    try:
+        return p.wait(timeout=timeout_s)
+    except BaseException:
+        kill_tree(p)
+        raise
+
+
+def clear_cell(cell, answer):
+    """Delete what an earlier run of this cell left behind, so nothing stale can be read
+    as this run's result: a re-run that dies before collecting would otherwise leave the
+    PREVIOUS answer in answers/ to be scored, next to a run.json that does not describe it."""
+    for p in (answer, os.path.join(cell, "run.json"), os.path.join(cell, "prompt.txt"),
+              os.path.join(cell, "agent_stdout.txt"), os.path.join(cell, "agent_stderr.txt")):
+        if os.path.isfile(p):
+            os.remove(p)
+    shutil.rmtree(os.path.join(cell, "sandbox"), ignore_errors=True)
+
+
+def remove_tree(path):
+    """rmtree that waits out Windows releasing a killed process's file handles."""
+    for _ in range(10):
+        shutil.rmtree(path, ignore_errors=True)
+        if not os.path.exists(path):
+            return True
+        time.sleep(1)
+    return False
+
+
+def collect(sandbox, rec, seed_path, dst, root_key):
+    """Export the cell's answer to answers/ and fill rec: exported / n_rows / unparseable.
+
+      wrote                    the agent's file, as-is -- even if it does not parse (score.py
+                               then scores it 0.0 and tallies it as unparseable; withholding
+                               it would turn "left a broken file" into "missing", which drops
+                               the cell from the mean)
+      never_wrote / deleted    the untouched seed -> 0.0, still in the denominator
+      the agent never started  (stop_reason harness_error, or no sandbox) nothing: the cell
+                               did not measure the model, so it stays missing
+    """
+    rec["exported"] = None
+    rec["n_rows"] = None
+    state = rec.get("state")
+    src = os.path.join(sandbox, "answer.json")
+    if state == "wrote":
+        shutil.copyfile(src, dst)
+        rec["exported"] = "answer"
+        try:
+            with open(src, encoding="utf-8-sig") as fh:
+                obj = json.load(fh)
+            rows = obj.get(root_key) if isinstance(obj, dict) else obj
+            rec["n_rows"] = len(rows) if isinstance(rows, list) else 0
+        except Exception as e:
+            rec["unparseable"] = "%s: %s" % (type(e).__name__, str(e)[:200])
+    elif state in ("never_wrote", "deleted") and rec.get("stop_reason") != "harness_error":
+        shutil.copyfile(seed_path, dst)
+        rec["exported"] = "seed"
+        rec["n_rows"] = 0
+
+
+PRINT_LOCK = threading.Lock()
+
+
+def run_cell(a, g, cid, prompt, argv, sandbox_root, timeout_s):
+    """One cell: build the sandbox, run the agent, collect. Returns the run.json record."""
+    r = C.resolve(g, cid)
+    cell = os.path.join(a.out, "cells", g, cid)
+    dst = os.path.join(a.out, "answers", g, cid + ".json")
+    clear_cell(cell, dst)
+    os.makedirs(cell, exist_ok=True)
+    os.makedirs(os.path.dirname(dst), exist_ok=True)
+    # A fresh, randomly named folder per cell, outside the repo: no case id in the
+    # agent's working directory, no relative path back to the ground truth, and
+    # nothing left over from another cell or an earlier run of this one.
+    work = tempfile.mkdtemp(prefix="va_", dir=sandbox_root)
+    sandbox = os.path.join(work, "sandbox")
+    t0 = time.time()
+    # `sandbox` is recorded for the transcript audit: it is the one directory the
+    # agent had any business reading.
+    rec = {"protocol": "B", "game": g, "case_id": cid, "root_key": r["root_key"],
+           "tol_s": C.TOL, "max_turns": a.max_turns or None,
+           "timeout_min": a.timeout_min, "agent_cmd": a.agent_cmd,
+           "sandbox": sandbox}
+    try:
+        try:
+            # the sandbox: video (renamed), Protocol-B instruction, pre-seeded answer
+            os.makedirs(sandbox)
+            shutil.copyfile(r["video"], os.path.join(sandbox, "match.mp4"))
+            with open(os.path.join(sandbox, "instruction.md"), "w",
+                      encoding="utf-8", newline="\n") as fh:
+                fh.write(C.instruction_for("agentic", r["instruction"]))
+            baseline = seed_answer(sandbox, g, r["root_key"])
+            rec.update(baseline)
+            # next to the sandbox (not in it); a copy stays with the cell's records
+            prompt_file = os.path.join(work, "prompt.txt")
+            for pf in (prompt_file, os.path.join(cell, "prompt.txt")):
+                with open(pf, "w", encoding="utf-8", newline="\n") as fh:
+                    fh.write(prompt)
+            rec["prompt_sha256"] = hashlib.sha256(prompt.encode("utf-8")).hexdigest()
+
+            cmd = [w.replace("@PROMPT_FILE@", prompt_file)
+                    .replace("@PROMPT@", prompt)
+                    .replace("@SANDBOX@", sandbox)
+                   for w in argv]
+            with open(os.path.join(cell, "agent_stdout.txt"), "wb") as so, \
+                    open(os.path.join(cell, "agent_stderr.txt"), "wb") as se:
+                rc = run_agent(cmd, sandbox, so, se, timeout_s)
+            rec["exit_code"] = rc
+            rec["stop_reason"] = "ok" if rc == 0 else "error"
+        except subprocess.TimeoutExpired:
+            rec["exit_code"] = None
+            rec["stop_reason"] = "timeout"
+        except Exception as e:
+            rec["stop_reason"] = "harness_error"
+            rec["error"] = "%s: %s" % (type(e).__name__, str(e)[:400])
+
+        # Collect whatever the agent left, whether it finished, timed out, or
+        # crashed -- a cut-off run's already-written rows still count.
+        st = (answer_state(sandbox, rec) if "seed_sha256" in rec
+              else {"state": "no_sandbox"})
+        rec.update(st)
+        try:
+            collect(sandbox, rec, r["answer_seed"], dst, r["root_key"])
+        except OSError as e:
+            rec["collect_error"] = "%s: %s" % (type(e).__name__, str(e)[:200])
+        if a.keep_sandbox and os.path.isdir(sandbox):
+            shutil.copytree(sandbox, os.path.join(cell, "sandbox"))
+    finally:
+        if not remove_tree(work):
+            rec["sandbox_not_removed"] = work
+    rec["wall_s"] = round(time.time() - t0, 1)
+    with open(os.path.join(cell, "run.json"), "w", encoding="utf-8") as fh:
+        json.dump(rec, fh, ensure_ascii=False, indent=2)
+    with PRINT_LOCK:
+        print("%-10s %-38s %-13s %-11s export=%-6s n_rows=%s %s"
+              % (g, cid, rec.get("stop_reason"), rec.get("state"), rec.get("exported"),
+                 rec.get("n_rows"),
+                 rec.get("error", rec.get("unparseable", rec.get("collect_error", "")))),
+              flush=True)
+    return rec
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--agent-cmd", required=True,
+                    help="command to run in the sandbox; see the placeholders above")
+    ap.add_argument("--game", action="append", required=True, help="game (repeatable) or 'all'")
+    ap.add_argument("--case", default="all", help="case id, or 'all' (default)")
+    ap.add_argument("--limit", type=int, default=0,
+                    help="with --case all: only the first N cases of each game (frozen order)")
+    ap.add_argument("--out", required=True, help="output root; answers land in <out>/answers")
+    ap.add_argument("--max-turns", type=int, default=200,
+                    help="turn cap to STATE in the prompt (default 200); pass 0 for a harness "
+                         "that cannot count turns, so the prompt claims only the wall clock")
+    ap.add_argument("--timeout-min", type=int, default=120,
+                    help="wall-clock cap per cell, in minutes (default 120)")
+    ap.add_argument("--sandbox-root",
+                    help="where the per-cell sandboxes are created (default: the system temp "
+                         "dir); must be outside the repo")
+    ap.add_argument("--workers", type=int, default=1,
+                    help="cells run concurrently, each in its own sandbox (default 1; the "
+                         "paper uses 3)")
+    ap.add_argument("--keep-sandbox", action="store_true",
+                    help="copy the sandbox into the cell folder afterwards (video included -- "
+                         "about 60MB..500MB per cell)")
+    a = ap.parse_args()
+
+    games = C.GAMES if "all" in a.game else a.game
+    for g in games:
+        if g not in C.GAMES:
+            ap.error("unknown game %r" % g)
+    sandbox_root = os.path.realpath(a.sandbox_root or tempfile.gettempdir())
+    repo = os.path.realpath(C.ROOT)
+    try:
+        inside = os.path.commonpath([sandbox_root, repo]) == repo
+    except ValueError:                                  # different drives
+        inside = False
+    if inside:
+        ap.error("--sandbox-root %s is inside the repo: the agent could reach tasks/*/gt/"
+                 % sandbox_root)
+    timeout_s = a.timeout_min * 60
+    prompt = build_prompt(a.max_turns or None, timeout_s)
+    argv = split_cmd(a.agent_cmd)
+
+    cells = [(g, cid) for g in games
+             for cid in ((C.case_ids(g)[:a.limit or None]) if a.case == "all"
+                         else [a.case])]
+    with ThreadPoolExecutor(max_workers=max(1, a.workers)) as pool:
+        list(pool.map(lambda gc: run_cell(a, gc[0], gc[1], prompt, argv, sandbox_root,
+                                          timeout_s), cells))
+
+    print("\nanswers in %s\n  python tools/score.py --answers %s"
+          % (os.path.join(a.out, "answers"), os.path.join(a.out, "answers")))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tools/score.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""score.py -- score a directory of answers against Video-Arena and print the table.
+
+    python tools/score.py --answers runs/my-model
+    python tools/score.py --answers runs/my-model --game cs2 --per-case
+    python tools/score.py --oracle                        # feed GT back in: every cell 1.0
+    python tools/score.py --empty                         # empty answers: every cell 0.0
+
+The answers directory mirrors the corpus:
+
+    <answers>/<game>/<case_id>.json          one answer per case
+
+Each file is the object the instruction asks for -- {"events": [...]}, the same root key in
+every one of the nine games. A MISSING file is reported as missing and left out of the mean:
+"did not run" is not a measurement of the model. A file that EXISTS is always scored, whatever
+is in it -- an answer with no rows (the untouched seed a runner exports for a Protocol B agent
+that never wrote or deleted its answer), or one that is not valid JSON at all, scores 0.0. Those
+are things the model did, and dropping them would let a worse agent post a higher mean. Both are
+tallied per game (`empty`, `unparseable`) so a 0.0 that came from no answer stays visible.
+
+Reported per game and overall:
+
+    F1_strict   the headline: fraction of fully-correct event tuples (all non-temporal
+                fields exact, |dt| <= 3s, maximum 1:1) -- the mean over scored cases
+    T1          event localization F1        (perceive)
+    T2          state-update accuracy        (interpret)
+    T3          resulting-state accuracy     (track)
+
+Means are over the cases that actually produced a reward, and the denominator is printed
+next to every number. A mean over 17 of 20 cases is a different quantity from a mean over
+20, and the only way to keep that readable is to say n.
+"""
+import argparse
+import json
+import os
+import shutil
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import va_core as C  # noqa: E402
+
+
+def mean(xs):
+    xs = [x for x in xs if x is not None]
+    return (sum(xs) / len(xs)) if xs else None
+
+
+def fmt(x, w=6):
+    return ("%*.*f" % (w, 4, x)) if isinstance(x, (int, float)) else ("%*s" % (w, "--"))
+
+
+def oracle_answer(game, gt):
+    """GT re-expressed as an answer, for --oracle. Answers carry only the fields a model is
+    asked for, so this is a projection of GT onto the answer schema -- which is exactly what
+    makes it a real end-to-end check of the whole scoring path rather than of the judge alone.
+    """
+    rk = C.ROOT_KEY[game]
+    if rk not in gt:
+        raise KeyError("%s GT has no %r key" % (game, rk))
+    out = {rk: gt[rk]}
+    # dota2 accepts OPTIONAL dense tier blocks alongside the event list. They are not part of
+    # the headline, but --oracle has to exercise the paths that read them, so the projection
+    # carries them when the GT has them. (cs2 reads T2/T3 ONLY from the event rows, so its
+    # GT-side `t2_round_winners` must not ride along: it would be ignored at best.)
+    for k in ("t2_leader_track", "t3_outcome"):
+        if k in gt:
+            out[k] = gt[k]
+    return out
+
+
+def answer_state(game, path):
+    """"rows" / "empty" (parses, but no rows under the root key) / "unparseable"."""
+    try:
+        with open(path, encoding="utf-8-sig") as fh:
+            obj = json.load(fh)
+    except Exception:
+        return "unparseable"
+    rows = obj.get(C.ROOT_KEY[game]) if isinstance(obj, dict) else obj
+    return "rows" if isinstance(rows, list) and rows else "empty"
+
+
+def score_case(game, cid, answers_dir, work, mode):
+    """Score one case; return (subscores_dict, status, answer_state). status is "ok" or why
+    not; answer_state is "rows" / "empty" / "unparseable" for a scored cell."""
+    r = C.resolve(game, cid)
+    ans_path = os.path.join(answers_dir, game, cid + ".json") if answers_dir else None
+
+    if mode == "oracle":
+        with open(r["gt"], encoding="utf-8") as fh:
+            payload = oracle_answer(game, json.load(fh))
+        ans_path = os.path.join(work, "answer.json")
+        with open(ans_path, "w", encoding="utf-8") as fh:
+            json.dump(payload, fh, ensure_ascii=False)
+    elif mode == "empty":
+        ans_path = os.path.join(work, "answer.json")
+        shutil.copyfile(r["answer_seed"], ans_path)
+    else:
+        if not os.path.isfile(ans_path):
+            return None, "missing", None
+    state = answer_state(game, ans_path)
+    if state == "unparseable":
+        # Scored as the empty seed -- 0.0 by construction -- rather than handed to the judge,
+        # so the zero does not depend on each judge's tolerance for garbage input.
+        ans_path = os.path.join(work, "answer.json")
+        shutil.copyfile(r["answer_seed"], ans_path)
+
+    out = os.path.join(work, "reward.json")
+    try:
+        reward = C.run_judge(game, ans_path, r["gt"], out, tol=C.TOL)
+    except Exception as e:
+        detail = getattr(e, "stderr", "") or str(e)
+        return None, "judge failed: %s" % detail.strip().splitlines()[-1][:120], None
+    return C.subscores(reward), "ok", state
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--answers", help="directory of <game>/<case_id>.json answer files")
+    ap.add_argument("--oracle", action="store_true",
+                    help="score GT against itself; every cell must be 1.0")
+    ap.add_argument("--empty", action="store_true",
+                    help="score the empty answer seeds; every cell must be 0.0")
+    ap.add_argument("--game", action="append",
+                    help="restrict to this game (repeatable); default all nine")
+    ap.add_argument("--per-case", action="store_true", help="print every case, not just means")
+    ap.add_argument("--json-out", help="write the full result table here")
+    a = ap.parse_args()
+
+    mode = "oracle" if a.oracle else ("empty" if a.empty else "answers")
+    if mode == "answers" and not a.answers:
+        ap.error("one of --answers / --oracle / --empty is required")
+    games = a.game or C.GAMES
+    for g in games:
+        if g not in C.GAMES:
+            ap.error("unknown game %r (known: %s)" % (g, ", ".join(C.GAMES)))
+
+    work = tempfile.mkdtemp(prefix="va_score_")
+    rows = []
+    per_game = []
+    try:
+        for g in games:
+            got = []
+            notes = []
+            states = {"empty": 0, "unparseable": 0}
+            for cid in C.case_ids(g):
+                s, status, state = score_case(g, cid, a.answers, work, mode)
+                rows.append({"game": g, "case_id": cid, "status": status,
+                             "answer_state": state,
+                             **(s or {"reward": None, "t1_f1": None,
+                                      "t2_macro_acc": None, "t3_macro_acc": None})})
+                if status == "ok":
+                    got.append(s)
+                    if state in states:
+                        states[state] += 1
+                else:
+                    notes.append("%s: %s" % (cid, status))
+                if a.per_case:
+                    print("  %-10s %-38s %s %s %s %s  %s"
+                          % (g, cid, fmt((s or {}).get("reward")),
+                             fmt((s or {}).get("t1_f1")),
+                             fmt((s or {}).get("t2_macro_acc")),
+                             fmt((s or {}).get("t3_macro_acc")),
+                             status if status != "ok"
+                             else ("" if state == "rows" else state + " -> 0")))
+            per_game.append({
+                "game": g, "n_scored": len(got), "n_cases": len(C.case_ids(g)),
+                "n_empty": states["empty"], "n_unparseable": states["unparseable"],
+                "f1_strict": mean([x["reward"] for x in got]),
+                "t1_f1": mean([x["t1_f1"] for x in got]),
+                "t2_macro_acc": mean([x["t2_macro_acc"] for x in got]),
+                "t3_macro_acc": mean([x["t3_macro_acc"] for x in got]),
+                "not_scored": notes,
+            })
+    finally:
+        shutil.rmtree(work, ignore_errors=True)
+
+    print()
+    print("Video-Arena  mode=%s  tol=%.1fs  metric=strict tuple F1" % (mode, C.TOL))
+    # `0-row` = scored cells whose answer had no rows or did not parse (both score 0.0 and
+    # are IN the mean); the n column's shortfall is the missing / judge-failed cells, which
+    # are not.
+    print("%-10s %-7s %6s %6s %6s %6s %6s   %s"
+          % ("game", "n", "F1", "T1", "T2", "T3", "0-row", "regime"))
+    print("-" * 69)
+    for r in per_game:
+        print("%-10s %2d/%-4d %s %s %s %s %6d   %s"
+              % (r["game"], r["n_scored"], r["n_cases"], fmt(r["f1_strict"]), fmt(r["t1_f1"]),
+                 fmt(r["t2_macro_acc"]), fmt(r["t3_macro_acc"]),
+                 r["n_empty"] + r["n_unparseable"], C.REGIME[r["game"]]))
+    print("-" * 69)
+    ok = [r for r in per_game if r["n_scored"]]
+    n_scored = sum(r["n_scored"] for r in per_game)
+    n_total = sum(r["n_cases"] for r in per_game)
+    n_empty = sum(r["n_empty"] for r in per_game)
+    n_unparse = sum(r["n_unparseable"] for r in per_game)
+    # The overall number is the mean of the ENVIRONMENT means, not of the 180 cases: the
+    # per-game case counts are equal today, but an unscored cell must not silently reweight
+    # the games against each other.
+    print("%-10s %2d/%-4d %s %s %s %s %6d   mean of %d env means"
+          % ("ALL", n_scored, n_total,
+             fmt(mean([r["f1_strict"] for r in ok])), fmt(mean([r["t1_f1"] for r in ok])),
+             fmt(mean([r["t2_macro_acc"] for r in ok])), fmt(mean([r["t3_macro_acc"] for r in ok])),
+             n_empty + n_unparse, len(ok)))
+    if n_empty or n_unparse:
+        print("scored as 0.0 with no usable answer: %d empty, %d unparseable"
+              % (n_empty, n_unparse))
+    missing = [(r["game"], n) for r in per_game for n in r["not_scored"]]
+    if missing:
+        print()
+        print("not scored (%d):" % len(missing))
+        for g, n in missing[:40]:
+            print("  %-10s %s" % (g, n))
+        if len(missing) > 40:
+            print("  ... and %d more" % (len(missing) - 40))
+
+    if a.json_out:
+        with open(a.json_out, "w", encoding="utf-8") as fh:
+            json.dump({"mode": mode, "tol": C.TOL, "per_game": per_game, "cases": rows},
+                      fh, ensure_ascii=False, indent=2)
+        print("\nwrote %s" % a.json_out)
+
+    # --oracle and --empty are assertions, not reports: they must hit their fixed point on
+    # every scored cell, and the exit code is what a CI run reads.
+    if mode in ("oracle", "empty"):
+        want = 1.0 if mode == "oracle" else 0.0
+        bad = [r for r in rows if r["status"] != "ok" or r["reward"] != want]
+        print("\n%s self-check: %d/%d cells at %.1f -> %s"
+              % (mode, len(rows) - len(bad), len(rows), want, "PASS" if not bad else "FAIL"))
+        for r in bad[:10]:
+            print("  %-10s %-38s reward=%s %s"
+                  % (r["game"], r["case_id"], r["reward"],
+                     "" if r["status"] == "ok" else r["status"]))
+        return 1 if bad else 0
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tools/va_core.py

@@ -0,0 +1,390 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""va_core.py -- the Video-Arena corpus contract: what a case is, and how it is scored.
+
+Everything a driver needs is here and nothing else is. Four pieces:
+
+  1. resolve(game, case_id)   -- the files that make up a case.
+  2. instruction_for(...)     -- the task text for ONE protocol (see the marker note below).
+  3. extract_answer(...)      -- pull the answer object out of a Protocol A chat reply.
+  4. run_judge(...)           -- invoke the game's judge as a subprocess, read reward.json.
+
+Pure standard library. No network, no model, no credentials: this module is about the
+corpus, and it must be importable on a machine that has never seen an API key.
+
+GT never reaches the model. resolve() returns the GT path because the OFFLINE scorer needs
+it; a driver that hands r["gt"] to a prompt or into a sandbox has broken the benchmark, not
+this module.
+"""
+import json
+import os
+import re
+import subprocess
+import sys
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+TASKS = os.path.join(ROOT, "tasks")
+
+# ---- the scoring contract ------------------------------------------------------------
+# The nine games share one layout, one headline metric, and ONE answer root key. They differ
+# only in which judge computes it, and the two judges differ only in their CLI and in where
+# they put the tier decomposition:
+#
+#   F1  judge.py --answer/--gt/--out/--tol --primary strict
+#       tier decomposition under reward["tiers"]
+#   F2  the same CLI WITHOUT --primary (its headline is always the single coupled F1)
+#       tier decomposition under reward["detail"]
+#
+# TOL is the +/- seconds a predicted event time may differ from the reference and still
+# match. It is 3.0 for every game; a run at another tolerance is a diagnostic, not a
+# benchmark score.
+TOL = 3.0
+
+GAMES = ["go", "chess", "gomoku", "doudizhu", "cs2", "dota2", "sc2", "gfootball", "badminton"]
+
+# ONE root key, every game: {"events": [ ...one complete tuple per row... ]}. A wrong root key is
+# scored as an empty answer, indistinguishable from a model that saw nothing. Kept as a name
+# rather than inlined because the runners record it per cell.
+ROOT_KEY = {g: "events" for g in GAMES}
+
+# The two judge families differ in where the tier block lands in reward.json and whether the
+# judge accepts --primary. This is a property of the SCORER, not of the answer, so it is
+# declared here rather than derived from the root key.
+FAMILY = {"go": "F1", "chess": "F1", "gomoku": "F1", "doudizhu": "F1",
+          "gfootball": "F1", "badminton": "F1",
+          "cs2": "F2", "dota2": "F2", "sc2": "F2"}
+REGIME = {"go": "board", "chess": "board", "gomoku": "board", "doudizhu": "card",
+          "cs2": "fps", "dota2": "moba", "sc2": "rts",
+          "gfootball": "sports", "badminton": "sports"}
+
+
+def case_ids(game):
+    """The published 20 case ids for `game`, in the frozen order of cases.json."""
+    with open(os.path.join(TASKS, game, "cases.json"), encoding="utf-8") as fh:
+        return list(json.load(fh)["case_ids"])
+
+
+def resolve(game, case_id):
+    """The files of one case. `video` and `instruction` are the ONLY model inputs."""
+    d = os.path.join(TASKS, game)
+    return {
+        "game": game,
+        "case_id": case_id,
+        "video": os.path.join(d, "media", case_id + ".mp4"),
+        "gt": os.path.join(d, "gt", case_id + "_gt.json"),        # offline scorer only
+        "instruction": os.path.join(d, "instruction.md"),
+        "answer_seed": os.path.join(d, "answer_seed.json"),
+        "judge": os.path.join(d, "judge.py"),
+        "root_key": ROOT_KEY[game],
+        "family": FAMILY[game],
+        "tol": TOL,
+        "primary": None if FAMILY[game] == "F2" else "strict",
+    }
+
+
+# ---- protocol-specific instruction text ----------------------------------------------
+# One instruction.md per game serves both protocols, because the TASK is identical and only
+# the DELIVERY differs: Protocol B writes answer.json in a sandbox over many turns, Protocol
+# A returns one JSON object in one chat reply. The parts that differ are marked in the file:
+#
+#   <!-- B-ONLY:START -->  ... whole lines ...  <!-- B-ONLY:END -->      agentic only
+#   <!-- A-ONLY:START -->  ... whole lines ...  <!-- A-ONLY:END -->      video only
+#   <!--B-->inline span<!--/B-->        <!--A-->inline span<!--/A-->
+#
+# Marking rather than shipping two files is what keeps the protocols provably the same task:
+# the per-game guidance lives once, and a change to the task reaches both protocols or
+# neither. Always send instruction_for(protocol, path), never the raw file -- the raw file
+# tells a model with no filesystem to write a file, and vice versa.
+_MARK_RE = re.compile(r"<!--\s*/?[AB](?:-ONLY:(?:START|END))?\s*-->")
+_KEEP = {"agentic": ("B", "A"), "video": ("A", "B"), "B": ("B", "A"), "A": ("A", "B")}
+
+
+def instruction_for(protocol, path):
+    """Instruction text for ONE protocol: "agentic"/"B" or "video"/"A".
+
+    Fails closed. A surviving marker means the file is malformed (unbalanced or mistyped),
+    and raising is strictly better than sending the other protocol's delivery text -- or a
+    raw HTML comment -- to a model.
+    """
+    keep, drop = _KEEP[protocol]
+    with open(path, "rb") as fh:
+        t = fh.read().decode("utf-8")
+    t = re.sub(r"(?ms)^<!-- " + drop + r"-ONLY:START -->\r?\n.*?^<!-- " + drop
+               + r"-ONLY:END -->\r?\n?", "", t)
+    t = re.sub(r"(?s)<!--" + drop + r"-->.*?<!--/" + drop + r"-->", "", t)
+    t = re.sub(r"(?m)^<!-- " + keep + r"-ONLY:(?:START|END) -->\r?\n", "", t)
+    t = re.sub(r"<!--" + keep + r"-->|<!--/" + keep + r"-->", "", t)
+    left = _MARK_RE.findall(t)
+    if left:
+        raise ValueError("%s: unbalanced protocol marker(s) survived: %s" % (path, left[:4]))
+    return t
+
+
+# ---- answer extraction (Protocol A) --------------------------------------------------
+def _balanced_objects(text):
+    """Yield (offset, source) for every TOP-LEVEL balanced {...}, ignoring braces inside
+    strings. Top-level only, so a single answer ROW that happens to carry the root key
+    cannot masquerade as the whole answer; an object left unclosed by a truncated response
+    is never yielded at all."""
+    depth = 0
+    start = -1
+    in_str = False
+    esc = False
+    for i, ch in enumerate(text):
+        if in_str:
+            if esc:
+                esc = False
+            elif ch == "\\":
+                esc = True
+            elif ch == '"':
+                in_str = False
+            continue
+        if ch == '"':
+            in_str = True
+        elif ch == "{":
+            if depth == 0:
+                start = i
+            depth += 1
+        elif ch == "}" and depth:
+            depth -= 1
+            if depth == 0:
+                yield start, text[start:i + 1]
+
+
+def answer_candidates(text, root_key="events"):
+    """Every parseable top-level JSON object in `text` carrying `root_key`, in order.
+
+    More than one is worth recording: the Protocol A prompt asks for exactly one object, so
+    a second candidate means the reply held a schema sketch, a per-segment dump, or the same
+    answer twice.
+    """
+    out = []
+    for start, src in _balanced_objects(text or ""):
+        try:
+            obj = json.loads(src)
+        except Exception:
+            continue
+        if isinstance(obj, dict) and root_key in obj:
+            rows = obj[root_key]
+            out.append({"start": start, "obj": obj,
+                        "n_rows": len(rows) if isinstance(rows, (list, dict)) else 0})
+    return out
+
+
+def extract_answer(text, root_key="events"):
+    """Pull the answer object out of a chat reply: a fenced json block, a bare object with
+    `root_key`, or a bare list (wrapped under it).
+
+    Among all top-level objects carrying `root_key`, take the one with the MOST rows; ties
+    go to the one appearing LAST. A model that prints a one-row schema sketch before its
+    real answer must not be scored on the sketch, and a model that emits several fences must
+    not be scored on an empty early one.
+    """
+    if not text:
+        raise ValueError("empty model response")
+    cands = answer_candidates(text, root_key)
+    if cands:
+        return max(cands, key=lambda c: (c["n_rows"], c["start"]))["obj"]
+    try:
+        obj = json.loads(text)
+        if isinstance(obj, dict) and root_key in obj:
+            return obj
+        if isinstance(obj, list):
+            return {root_key: obj}
+    except Exception:
+        pass
+    raise ValueError("no JSON object with a %r key found in response" % root_key)
+
+
+# ---- Protocol A delivery ---------------------------------------------------------------
+# The single-reply tail appended to the A-rendered instruction, verbatim from the paper's
+# Protocol A prompt (appendix, "the frozen prompts"). The native runner and the Harbor agent
+# both build their prompt here, so the two paths send the same text.
+A_TAIL_HEAD = "---\nYou are given the match as "
+_A_TAIL = A_TAIL_HEAD + """{n} frames, uniformly sampled from a {dur}-second video \
+(one frame every {dt} video-seconds). Frame k (0-indexed) is at video_ts[k], in seconds:
+video_ts = [{ts}]. Use these exact values for timestamps; do not recompute them.
+
+This is one reply and there are no tools: no sandbox, no file to write, no second turn, \
+and nothing runs after you stop. You may reason here first if it helps.
+
+Your answer is the LAST ```json fenced block in this reply. It must hold the COMPLETE JSON
+object with the single `{root_key}` key -- every row you want scored, in that one block.
+Print no other JSON anywhere in the reply: no schema sketch, no partial dump, no repeat of
+the answer. Nothing outside that last block is read.
+"""
+_CANARY_RE = re.compile(r"\n*<!-- CANARY:[^\n]*-->\s*$")     # a file marker, not prompt text
+_AGENTIC_TEXT = ("answer.json", "match.mp4", "ffmpeg", "ffprobe", "sandbox")
+
+
+def protocol_a_prompt(instruction, duration_s, ts, fps, root_key="events"):
+    """The whole Protocol A text: the A-rendered instruction (instruction_for("video", ...)),
+    then the single-reply tail carrying the grid's explicit video_ts array. It passes
+    check_protocol_a_prompt() before it is returned."""
+    tail = _A_TAIL.format(n=len(ts), dur="%.1f" % duration_s, dt="%.2f" % (1.0 / fps),
+                          ts=", ".join("%.2f" % t for t in ts), root_key=root_key)
+    body = _CANARY_RE.sub("", instruction.replace("\r\n", "\n")).rstrip("\n")
+    prompt = body + "\n\n" + tail
+    check_protocol_a_prompt(prompt, root_key)
+    return prompt
+
+
+def check_protocol_a_prompt(prompt, root_key="events"):
+    """The pre-flight check, run before any tokens are spent: reject a Protocol A prompt that
+    still carries agentic delivery text, lacks the single-reply tail, or whose tail does not
+    name the schema's root key."""
+    body, head, tail = prompt.rpartition(A_TAIL_HEAD)
+    if not head:
+        raise ValueError("Protocol A prompt has no single-reply tail")
+    leaked = [w for w in _AGENTIC_TEXT if w in body]
+    if leaked:
+        raise ValueError("Protocol A prompt carries agentic delivery text: %s" % leaked)
+    if "This is one reply and there are no tools" not in tail \
+            or "`%s`" % root_key not in tail:
+        raise ValueError("Protocol A tail is incomplete or does not name the root key %r"
+                         % root_key)
+
+
+# ---- scoring -------------------------------------------------------------------------
+def run_judge(game, answer_path, gt_path, out_path, tol=TOL):
+    """Score one case: run the game's judge as a SUBPROCESS and return the reward dict.
+
+    A subprocess, not an import: the judges are nine independent single-file programs that
+    share module names, and invoking them exactly the way their CLI documents them is what
+    lets anyone reproduce a published number by hand.
+    """
+    meta = resolve(game, "_")
+    cmd = [sys.executable, meta["judge"], "--answer", answer_path, "--gt", gt_path,
+           "--out", out_path, "--tol", str(tol)]
+    if meta["primary"]:
+        cmd += ["--primary", meta["primary"]]
+    subprocess.run(cmd, check=True, capture_output=True, text=True,
+                   encoding="utf-8", errors="replace")
+    with open(out_path, encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+def subscores(reward):
+    """Headline + per-tier diagnostics out of a reward.json, across both judge families.
+
+    The headline is always reward["reward"] (strict tuple F1). The tier keys are NOT
+    uniform, and guessing wrong would blank a column -- and a blank reads as "not measured"
+    rather than "we looked in the wrong place". So: try F1's `tiers` block, fall back to
+    F2's `detail`, and inside each accept every key a shipped judge actually writes.
+
+    T3's metric varies by game: board / card / MOBA / RTS score a class label (macro
+    accuracy over {A, B, equal}); badminton and gfootball score an exact integer score pair
+    (exact_pair_acc); cs2 scores the exact cumulative pair (exact_frac). All three live in
+    the same column because all three answer "did it track the state".
+    """
+    t = reward.get("tiers")
+    if t:
+        t3 = t.get("t3_situation") or t.get("t3_score") or {}
+        t3v = t3.get("macro_acc")
+        if t3v is None:
+            t3v = t3.get("exact_pair_acc")
+        return {"reward": reward.get("reward"),
+                "t1_f1": (t.get("t1_localization") or {}).get("f1"),
+                "t2_macro_acc": (t.get("t2_impact") or {}).get("macro_acc"),
+                "t3_macro_acc": t3v}
+    d = reward.get("detail", {})
+    t2 = d.get("t2_round_winner") or d.get("t2_minute_gain_event") or d.get("t2_impact") or {}
+    t3 = (d.get("t3_score_track") or d.get("t3_leader_after_event")
+          or d.get("t3_situation") or {})
+    t3v = t3.get("exact_frac")
+    if t3v is None:
+        t3v = t3.get("macro_acc")
+    return {"reward": reward.get("reward"),
+            "t1_f1": (d.get("t1_localization") or {}).get("f1"),
+            "t2_macro_acc": t2.get("macro_acc"),
+            "t3_macro_acc": t3v}
+
+
+def t1_recall_ceiling(duration_s, n_frames, tol=TOL):
+    """Highest T1 recall a uniform `n_frames` grid can reach on a `duration_s` video.
+
+    With frame spacing d = duration / n_frames, an event lies within `tol` of some sampled
+    frame at most min(1, 2*tol/d) of the time. Protocol A on a long match is therefore
+    capped BELOW 1 by its own sampling grid, and recording that alongside the score is what
+    separates "the model missed the event" from "no frame was close enough to it".
+    """
+    if not n_frames or duration_s <= 0:
+        return 0.0
+    d = float(duration_s) / float(n_frames)
+    return min(1.0, 2.0 * float(tol) / d) if d > 0 else 1.0
+
+
+def case_meta(game):
+    """The build-time tags of every case of `game`, keyed by case id (CASE_TYPES.json).
+
+    Read-only passthrough: the generation scripts use it for task metadata and nothing in the
+    scoring path touches it. The id key is `id` for the four games whose cases.json carries it
+    and `case_id` for the rest.
+    """
+    path = os.path.join(TASKS, game, "CASE_TYPES.json")
+    if not os.path.isfile(path):
+        return {}
+    with open(path, encoding="utf-8") as fh:
+        doc = json.load(fh)
+    out = {}
+    for row in doc.get("cases", []):
+        key = row.get("id", row.get("case_id"))
+        if key:
+            out[key] = row
+    return out
+
+
+def build_harbor_prompt(max_turns=200, timeout_s=7200):
+    """Protocol B's turn-1 prompt, written for the Harbor sandbox (working directory /app).
+
+    Same contract as tools/run_protocol_b.py: one deliverable, `answer.json`, filled in as the
+    run goes; a text reply is not an answer. State it with the sandbox's own paths so the agent
+    never has to guess where `instruction.md` and `match.mp4` are, and so the no-network rule is
+    stated where it can be obeyed.
+    """
+    minutes = round(timeout_s / 60)
+    budget = ("You have at most %d tool-call turns and about %d minutes of wall-clock time. "
+              "When either limit is reached you are stopped immediately." % (max_turns, minutes))
+    return """You are a HEADLESS autonomous agent -- there is no human to talk to. Communicate ONLY by
+calling tools (running commands, reading and writing files); a text reply is not an answer. Your
+one deliverable is the file `answer.json` in `/app`.
+
+Read `/app/instruction.md` for the task and the exact `answer.json` schema. Your only input is the
+video `/app/match.mp4`. The video plays at 1:1 real speed; `instruction.md` says exactly which
+clock each time field you report is on.
+
+Solve it yourself, from the video. Do not use the network for anything, and there is none: no
+downloading or installing packages, models or weights, no calls to any external service, API or
+model, and no looking this match up. Everything you need is already installed -- ffmpeg and
+ffprobe, Python with numpy/OpenCV/Pillow and the usual numeric stack, tesseract for on-screen
+text. The shell, that Python, and those video tools are your only tools.
+
+`answer.json` already exists in `/app` -- created before your first turn, holding the schema's
+root key and an empty list. Do not delete it, do not rename it, and do not change the root key.
+Overwrite it in place -- in full, valid JSON every time -- as soon as you have something to put
+in it, and keep overwriting it as you learn more. It must be valid JSON at every moment: rewrite
+it in full each time (read -> add -> write back), never leave it half-written. Each rewrite should
+contain everything the previous one had, plus the new rows; if you are deep into the video and the
+file is not getting longer, you are overwriting instead of appending.
+
+Whatever is in `answer.json` when the run stops is what gets scored. If you are cut off, every row
+already written still counts; rows kept only in your reasoning, to be written out at the end,
+score zero.
+
+%s Everything else -- including how you sample the video -- is up to you.""" % budget
+
+
+if __name__ == "__main__":
+    # Self-check: enumerate every case and confirm each of its files is on disk.
+    missing = 0
+    for g in GAMES:
+        ids = case_ids(g)
+        for cid in ids:
+            r = resolve(g, cid)
+            for k in ("video", "gt", "instruction", "judge", "answer_seed"):
+                if not os.path.isfile(r[k]):
+                    print("MISSING %s/%s %s: %s" % (g, cid, k, r[k]))
+                    missing += 1
+        print("%-10s %2d cases  family=%s  root_key=%s" % (g, len(ids), FAMILY[g], ROOT_KEY[g]))
+    print("missing files: %d" % missing)
+    raise SystemExit(1 if missing else 0)