tasks/gomoku/instruction.md

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. Write answer.json:The answer is one JSON object:

{
  "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.

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:

{"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.

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.
• Output only answer.json.

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.

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.