RailSimEnv v1: OpenEnv server, eval explorer, 3D replay and train graph

README.md

@@ -1,13 +1,97 @@
 ---
-title: RailSimEnv
-emoji: ⚡
+title: RailSimEnv v1
+emoji: 🚆
 colorFrom: blue
-colorTo: purple
+colorTo: gray
 sdk: gradio
 sdk_version: 6.29.1
-python_version: '3.12'
+python_version: "3.12"
 app_file: app.py
 pinned: false
+short_description: Dispatch trains on a real single-track Dutch line
+tags: [openenv, simulation, rl-environment, railway, scheduling, operations-research]
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# RailSimEnv v1 · OpenEnv
+
+Dispatch Arriva's trains on the single-track Groningen – Leeuwarden line (Netherlands) after a real 2025 disruption:
+a broken-down train, a collision at a level crossing, a signal or points failure, on its real day and time, with every
+train where it really was. Hold, short-turn and cancel trains so opposing trains cross safely. One graded submit per
+episode against the proven CP-SAT optimum. Serves the rail-v1 packs: 45 eval tasks chosen for hardness and 159 train
+tasks on other days.
+
+| page | what |
+|---|---|
+| `/web` | OpenEnv's web UI. **Explore**: the eval explorer, the 3D replay and the train graph. **Playground**: reset, step and the MCP tools by hand |
+| `/explorer/` | the leaderboard and every model's plan on every eval task; pick one to watch it |
+| `/twin/` | the 3D replay: any plan on the line's real track from OpenStreetMap, signals, level crossings, closures, the train graph and the cost as it accrues |
+| `/viewer/` | the train graph (time across, distance down) of any plan, with the plan's holds, short-turns and rule breaks |
+| `/reset`, `/step`, `/state`, `/ws`, `/mcp` | OpenEnv |
+| `/rail_ops/...` | OpenEnv Task API (`splits`, `num_tasks`, `task`, `task_range`) |
+| `/api/...` | read-only JSON for the pages |
+
+## Tools
+
+| tool | returns |
+|---|---|
+| `get_situation()` | the line, the closures, every train's timetable and position, the train sets and their chains of runs |
+| `check_plan(plan)` | simulates a draft: every train's times, delay and lost stops, every rule broken, the cost; 10 per episode |
+| `submit_plan(plan)` | ends the episode with one grade |
+
+`plan` lists only the trains you change: `[{"train": "37413", "to": "HDG"}, {"train": "37324", "from": "HDG"},
+{"train": "37419", "hold": {"GK": "08:36"}}, {"train": "37330", "cancel": true}]`. Trains left alone run as early as
+the physics allow, never ahead of the timetable. `reset(task_id=...)`, `reset(split=..., index=...)` or
+`reset(seed=...)`.
+
+**Rules:** no two opposing trains in a single-track section at once; 3-minute headways for trains going the same way;
+never more trains at a station than tracks; no train in a closed section; runs start where their train set is, and
+every set ends the window where its next run leaves; no stop more than 2 hours late.
+
+**Cost**, in stop-minutes: every minute of delay at every stop served, 30 per stop not served, and lateness handed on
+to the next window.
+
+## Reward
+
+Graded once, on `submit_plan`, by `RailPlanRubric` (every other action scores 0.0). A plan that breaks any rule scores
+0.2 × the share of runs it leaves clean. A legal plan scores 0.2 + 0.8 × exp(−gap / 0.5), with
+gap = (cost − optimum) / (optimum − floor + 100), so the proven CP-SAT optimum scores 1.0. No submission scores 0. The
+children `runs_clean` and `cost_quality` are reported in the final observation's `metadata.rubric`.
+
+## Results on the 45 eval tasks
+
+One rollout per model, the same rules for every model (12 turns, 64k output tokens per turn):
+
+| model | mean reward (95% CI) | legal plans | at the optimum |
+|---|---|---:|---:|
+| Qwen3.8-2.4T-A95B | **0.556** (0.452-0.665) | 39 | 12 |
+| DeepSeek-V4.1-Flash | **0.534** (0.427-0.643) | 33 | 12 |
+| Claude Sonnet 5.5 | **0.467** (0.384-0.553) | 45 | 4 |
+| GLM-5.3-Flash | **0.360** (0.251-0.477) | 24 | 6 |
+| the real dispatchers (real tier, scored as if legal) | 0.502 | | |
+| greedy dispatcher | 0.180 | | |
+| change nothing | 0.105 | 0 | 0 |
+
+Every plan is in the eval explorer, and replays in 3D exactly as it was graded.
+
+## Connect an agent
+
+```python
+from openenv.core.env_server.mcp_types import CallToolAction
+from openenv.core.mcp_client import MCPToolClient
+
+env = MCPToolClient("https://bphigh-railsimenv.hf.space").sync()
+obs = env.reset(split="eval", index=0)
+rules = obs.observation.metadata["instructions"]          # the system prompt
+situation = env.step(CallToolAction(tool_name="get_situation", arguments={}))
+plan = [{"train": "37413", "to": "HDG"}, {"train": "37324", "from": "HDG"}]
+print(env.step(CallToolAction(tool_name="check_plan", arguments={"plan": plan})).observation)
+```
+
+## Data and licences
+
+| data | source | licence |
+|---|---|---|
+| trains, timetables, delays, cancellations, platforms; disruptions | [Rijden de Treinen](https://www.rijdendetreinen.nl/en/open-data) open data | CC BY 4.0 ("Rijden de Treinen") |
+| track layout; the 3D replay's map (track, platforms, buildings, land cover, water, roads) | © OpenStreetMap contributors | ODbL 1.0 |
+
+The rolling-stock circulation, the disruption effects by cause and the cost weights are modelling choices.

app.py

@@ -0,0 +1,52 @@
+"""RailSimEnv v1 on a Hugging Face Space: the OpenEnv server (reset, step, state, the MCP tools, the Task API and the
+web UI at /web), the eval explorer (/explorer/), the 3D replay (/twin/) and the train graph (/viewer/), on one port.
+
+The Space runs on ZeroGPU hardware but never asks for a GPU: the environment is plain Python and the grader re-simulates
+a plan in milliseconds. ZeroGPU wants one decorated function, so `_noop` exists and is never called.
+
+    python app.py            # http://127.0.0.1:7860/web/ (the Space's page), /explorer/, /twin/, /viewer/
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+sys.path[:0] = [str(ROOT / "core"), str(ROOT / "openenv")]
+os.environ.setdefault("RAIL_TASKS_DIR", f"{ROOT / 'tasks' / 'rail-v1-eval'}:{ROOT / 'tasks' / 'rail-v1-train'}")
+os.environ.setdefault("RAIL_RUNS_DIR", str(ROOT / "runs"))
+os.environ.setdefault("ENABLE_WEB_INTERFACE", "true")
+
+# The web UI shows a README: this card, without its front matter.
+card = (ROOT / "README.md").read_text(encoding="utf-8")
+if card.startswith("---"):
+    card = card.split("---", 2)[2].lstrip()
+readme = Path(os.environ.get("TMPDIR", "/tmp")) / "railsim_readme.md"
+readme.write_text(card, encoding="utf-8")
+os.environ.setdefault("ENV_README_PATH", str(readme))
+
+try:
+    import spaces
+except ImportError:  # running elsewhere
+    spaces = None
+
+if spaces is not None:
+    @spaces.GPU(duration=1)
+    def _noop():  # ZeroGPU requires one decorated function; nothing calls it
+        pass
+
+import uvicorn  # noqa: E402
+
+from rail_openenv.server import create_server  # noqa: E402
+
+app = create_server()
+
+if __name__ == "__main__":
+    if spaces is not None:
+        from spaces import zero
+
+        zero.startup()
+    uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", "7860")), ws_ping_interval=60,
+                ws_ping_timeout=600)

core/rail_core/__init__.py

@@ -0,0 +1,14 @@
+"""Rail dispatch on the single-track Groningen - Leeuwarden line: tasks from Arriva's real 2025 days, the physics and
+checker, CP-SAT references, a reward."""
+
+from .check import PlanResult, evaluate, simulate
+from .model import (RULES, Closure, Order, Plan, PlanError, Run, Task, Unit, hhmm, parse_plan, parse_time,
+                    plan_from_list, plan_to_list)
+from .pack import TaskPack, load_pack
+from .prompts import PROMPT_VERSION, brief, rules, situation
+from .report import plan_report
+from .reward import Grade, grade, score
+
+__all__ = ["Closure", "Grade", "Order", "PROMPT_VERSION", "Plan", "PlanError", "PlanResult", "RULES", "Run", "Task",
+           "TaskPack", "Unit", "brief", "evaluate", "grade", "hhmm", "load_pack", "parse_plan", "parse_time",
+           "plan_from_list", "plan_report", "plan_to_list", "rules", "score", "simulate", "situation"]

core/rail_core/baselines.py

@@ -0,0 +1,263 @@
+"""Cheap dispatching policies: the lazy bounds a task must stay hard against, and the solver's starting point.
+
+    naive     change nothing: every train runs as scheduled and as early as it can (usually breaks the rules)
+    greedy    first come, first served: trains are planned one at a time in the order they are ready to leave; each
+              takes the earliest times that clear every train already planned (holding at its scheduled stops), and
+              a train whose path is closed for more than `turn_after` minutes is short-turned at the last turn point
+              before the closure, its train starting back from there. This is how a dispatcher works by rule of
+              thumb; it never cancels and never makes a train wait to let a later one through.
+    greedy_fast   the same, but fast trains (Sneltrein) are planned before stopping trains that are ready at the
+              same time (within 10 minutes): priority to the fast service
+"""
+
+from __future__ import annotations
+
+import heapq
+from collections import defaultdict
+
+from .check import evaluate, network, run_dir
+from .model import Order, Plan, Run, Task
+
+MAXWAIT = 240
+STEP_BUDGET = 60_000    # departure times tried per run before the greedy gives up on it
+
+
+class _Book:
+    """What is already planned: section occupancies and station presences."""
+
+    def __init__(self, task: Task):
+        self.task = task
+        self.net = network(task)
+        self.sec: dict[int, list] = defaultdict(list)       # (dir, enter, exit)
+        self.pres: dict[str, list] = defaultdict(list)      # (dir, t0, t1)
+        self.hf, self.ho = task.rule("h_follow"), task.rule("h_opp")
+        self.closed = [c for c in task.closures if c.kind == "closed"]
+        self.tracks_out = [c for c in task.closures if c.kind == "track"]
+        self.slow = [c for c in task.closures if c.kind == "slow"]
+
+    def section_ok(self, sec: int, d: int, t0: int, t1: int, history: bool = False) -> bool:
+        s = self.net.sections[sec]
+        for dd, a, b in self.sec[sec]:
+            if dd == d:
+                if (t0 >= a and (t0 - a < self.hf or t1 - b < self.hf)) or \
+                   (t0 < a and (a - t0 < self.hf or b - t1 < self.hf)):
+                    return False
+            elif s.single and not (b + self.ho <= t0 or t1 + self.ho <= a):
+                return False
+        if not history:
+            for c in self.closed:
+                lo, hi = sorted((self.net.index[c.where[0]], self.net.index[c.where[-1]]))
+                if lo <= sec < hi and t0 < c.end and t1 > c.start:
+                    return False
+        return True
+
+    def station_ok(self, code: str, d: int, t0: int, t1: int) -> bool:
+        p = self.net.by_code[code]
+        if p.tracks is None or p.kind == "junction":
+            return True
+        others = [(dd, a, b) for dd, a, b in self.pres[code] if not (b < t0 or a > t1)]
+        if p.directional:
+            return not any(dd in (d, 0) for dd, _, _ in others)
+        # peak count over [t0, t1] including this train
+        times = sorted({t0} | {a for _, a, _ in others if t0 <= a <= t1} |
+                       {c.start for c in self.tracks_out if c.where[0] == code and t0 <= c.start <= t1})
+        for t in times:
+            n = 1 + sum(1 for _, a, b in others if a <= t <= b)
+            cap = p.tracks - sum(1 for c in self.tracks_out if c.where[0] == code and c.start <= t < c.end)
+            if n > cap:
+                return False
+        return True
+
+    def slow_extra(self, sec: int, t: int) -> int:
+        x = 0
+        for c in self.slow:
+            lo, hi = sorted((self.net.index[c.where[0]], self.net.index[c.where[-1]]))
+            if lo <= sec < hi and c.start <= t < c.end:
+                x = max(x, c.extra)
+        return x
+
+
+def _closure_wait(book: _Book, r: Run, i: int, t: int) -> int:
+    """Minutes a train entering route[i] -> route[i+1] at t would wait for a closure."""
+    sec = book.net.section(r.route[i], r.route[i + 1])
+    w = 0
+    for c in book.closed:
+        lo, hi = sorted((book.net.index[c.where[0]], book.net.index[c.where[-1]]))
+        if lo <= sec < hi and c.start <= t + r.seg[i] and t < c.end:
+            w = max(w, c.end - t)
+    return w
+
+
+def _path(book: _Book, r: Run, first: int, last: int, a0: int | None, ready: int, wait_from: int | None):
+    """Earliest conflict-free times for one run over route[first..last] given what is booked: (arr, dep, stopped)
+    or None. a0: the fixed arrival at `first` of a run already moving (else the run starts at `first`, where its
+    train has stood since `wait_from` if that is a station with few tracks)."""
+    net, task = book.net, book.task
+    L = task.rule("stop_loss")
+    d = run_dir(net, r)
+    fail: set = set()
+    steps = [0]
+    arr: dict[int, int] = {}
+    dep: dict[int, int] = {}
+    stopped: dict[int, bool] = {}
+
+    def go(i: int, a: int) -> bool:
+        if i == last:
+            arr[i], stopped[i] = a, True
+            return True
+        if (i, a) in fail:
+            return False
+        code = r.route[i]
+        p = net.by_code[code]
+        starting = i == first and a0 is None
+        if starting:
+            d0 = max(ready, r.dep[i])
+        elif r.stops[i]:
+            d0 = max(a, r.dep[i])
+        else:
+            d0 = a
+        if i == first and a0 is not None:
+            d0 = max(d0, task.start)
+        sec = net.section(code, r.route[i + 1])
+        for t in range(d0, d0 + MAXWAIT):
+            steps[0] += 1
+            if steps[0] > STEP_BUDGET:
+                return False
+            if starting:
+                a_here, acc, halt, t0 = None, (0 if r.stops[i] else L), True, wait_from
+            elif r.stops[i] or (i == first and a0 is not None and t > a and False):
+                a_here, acc, halt, t0 = a, 0, True, a
+            elif t == a:
+                a_here, acc, halt, t0 = a, 0, False, a
+            else:
+                break                           # greedy only waits where the train has a scheduled stop
+            if t0 is not None and not book.station_ok(code, d, t0, t):
+                if halt:
+                    break                       # a longer wait here only makes it worse
+                continue
+            nxt = t + r.seg[i] + acc + book.slow_extra(sec, t)
+            if r.arr[i + 1] is not None:
+                nxt = max(nxt, r.arr[i + 1])
+            if i + 1 == last and not r.stops[last]:
+                nxt += L
+            if not book.section_ok(sec, d, t, nxt):
+                continue
+            if a_here is not None:
+                arr[i] = a_here
+            dep[i], stopped[i] = t, halt
+            if go(i + 1, nxt):
+                return True
+        fail.add((i, a))
+        return False
+
+    if not go(first, a0 if a0 is not None else 0):
+        return None
+    return arr, dep, stopped
+
+
+def greedy(task: Task, fast_first: bool = False, turn_after: int = 20) -> Plan:
+    book = _Book(task)
+    net = book.net
+    runs = task.run_map
+    turn = task.rule("turn_min")
+    plan: Plan = {}
+    for r in task.runs:               # trains between points when the task starts
+        if r.started and r.fixed_from is not None:
+            k = r.fixed_to
+            book.sec[net.section(r.route[k - 1], r.route[k])].append((run_dir(net, r), r.fixed_from, r.fixed_arr))
+    state = {}
+    for u in task.units:
+        finite = u.at is not None and net.by_code[u.at].tracks is not None
+        state[u.id] = {"k": 0, "ready": u.ready, "wait_from": task.start if finite else None, "start_at": None,
+                       "park": None}
+        if finite:
+            stay = (0, task.start, task.end + 1440)
+            book.pres[u.at].append(stay)
+            state[u.id]["park"] = (u.at, stay)
+    heap = []
+    units = {u.id: u for u in task.units}
+
+    def push(u):
+        s = state[u.id]
+        if s["k"] >= len(u.runs):
+            return
+        r = runs[u.runs[s["k"]]]
+        t = r.fixed_arr if r.started else max(s["ready"] or 0, r.dep[0])
+        pri = (t // 10, 0 if r.kind == "fast" else 1, t) if fast_first else (t, 0, 0)
+        heapq.heappush(heap, (pri, u.id))
+
+    for u in task.units:
+        push(u)
+    while heap:
+        _, uid = heapq.heappop(heap)
+        u = units[uid]
+        s = state[uid]
+        r = runs[u.runs[s["k"]]]
+        if s["park"]:                 # its provisional stay is replaced by the real one below
+            code, stay = s["park"]
+            book.pres[code].remove(stay)
+            s["park"] = None
+        has_next = s["k"] + 1 < len(u.runs)
+        first = r.fixed_to if r.started else (r.idx(s["start_at"]) if s["start_at"] else 0)
+        last = len(r.route) - 1
+        if has_next:                  # short-turn before a long closure, if its train has a run to come back on
+            nxt = runs[u.runs[s["k"] + 1]]
+            t = r.fixed_arr if r.started else max(s["ready"] or 0, r.dep[first])
+            for i in range(first, last):
+                if i > first and r.stops[i]:
+                    t = max(t, r.dep[i])
+                if _closure_wait(book, r, i, t) > turn_after:
+                    lo = first if r.started else first + 1
+                    # only where the next run can start (some runs work part of the line, e.g. Groningen - Zuidhorn)
+                    cands = [j for j in range(lo, i + 1) if net.by_code[r.route[j]].turn
+                             and r.route[j] in nxt.route[:-1]]
+                    if cands:
+                        last = cands[-1]
+                    break
+                t += r.seg[i]
+        a0 = r.fixed_arr if r.started else None
+        wait_from = None if r.started else s["wait_from"]
+        res = _path(book, r, first, last, a0, s["ready"] or 0, wait_from)
+        if res is None and last != len(r.route) - 1:
+            last = len(r.route) - 1
+            res = _path(book, r, first, last, a0, s["ready"] or 0, wait_from)
+        if res is None:
+            plan[r.id] = Order(start=r.route[first] if (not r.started and first > 0) else None)
+            s["k"] += 1
+            s["ready"], s["wait_from"], s["start_at"] = None, None, None
+            push(u)
+            continue
+        arr, dep, stopped = res
+        d = run_dir(net, r)
+        if wait_from is not None:
+            book.pres[r.route[first]].append((d, wait_from, dep[first]))
+        for i in range(first, last):
+            book.sec[net.section(r.route[i], r.route[i + 1])].append((d, dep[i], arr[i + 1]))
+            if (i > first or r.started) and net.by_code[r.route[i]].tracks is not None:
+                book.pres[r.route[i]].append((d, arr[i], dep[i]))
+        plan[r.id] = Order(start=r.route[first] if (not r.started and first > 0) else None,
+                           end=r.route[last] if last < len(r.route) - 1 else None,
+                           hold={r.route[i]: dep[i] for i in range(first, last)
+                                 if net.by_code[r.route[i]].kind != "junction"})
+        end_code = r.route[last]
+        s["k"] += 1
+        s["ready"] = arr[last] + turn
+        s["start_at"] = end_code if last < len(r.route) - 1 else None
+        p_end = net.by_code[end_code]
+        if p_end.tracks is not None and p_end.kind != "junction":
+            s["wait_from"] = arr[last]
+            stay = (0, arr[last], task.end + 1440)
+            book.pres[end_code].append(stay)
+            s["park"] = (end_code, stay)
+        else:
+            s["wait_from"] = None
+        push(u)
+    from .solve import _tidy
+    return _tidy(task, plan)
+
+
+def naive(task: Task) -> Plan:
+    return {}
+
+
+POLICIES = {"naive": naive, "greedy": greedy, "greedy_fast": lambda t: greedy(t, fast_first=True)}

core/rail_core/build.py

@@ -0,0 +1,243 @@
+"""Build task packs (candidates -> references -> filters), resumable, deterministic for the same data and arguments.
+
+    python -m rail_core.build --split eval --out ../tasks/pool-eval --n 400      # a candidate pool, every tier
+    python -m rail_core.build --split train --out ../tasks/rail-v1-train --n 300
+
+Candidates: the record's own disruptions on their own days (tier `real`), then seeded tiers (`ops.TIERS`) on every
+day of the split at peak-hour starts, cycling seeds. A candidate is kept when:
+    the window can be rebuilt from the record (generate.build_task) and has at least MIN_RUNS runs
+    CP-SAT's plan is within 1 % of its proven bound, measured on the avoidable cost (cost - floor + gap_k)
+    the naive plan (change nothing) scores at most MAX_NAIVE_REWARD and the greedy dispatchers at most
+    MAX_GREEDY_REWARD
+Every candidate and why it was dropped goes to build_log.jsonl, with the hardness features of every kept task
+(`hardness.features`). Choosing the eval set from a pool is `rail_core.select`.
+"""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import hashlib
+import json
+import random
+import time
+from concurrent.futures import ProcessPoolExecutor
+from pathlib import Path
+
+from .generate import build_task
+from .hardness import features
+from .model import Closure, hhmm
+from .network import load_network
+from .ops import (LATE_CAUSES, PEAKS, TIERS, candidate_id, closures_for, real_disruptions, seeded_closures,
+                  split_days)
+from .reference import add_reference
+
+MIN_RUNS = 15
+MAX_NAIVE_REWARD = 0.6
+MAX_GREEDY_REWARD = 0.85
+MAX_GAP = 0.01
+
+
+def _rng(cid: str) -> random.Random:
+    return random.Random(int(hashlib.sha256(cid.encode()).hexdigest()[:12], 16))
+
+
+def make_candidate(day: str, start: int, window: int, tier: str, seed: int, split: str,
+                   real: dict | None = None):
+    """The task for one candidate (no reference yet), or (None, reason)."""
+    net = load_network()
+    cid = candidate_id(day, start, window, tier, seed)
+    rng = _rng(cid)
+    notices: list[str] = []
+    why: list[str] = []
+    task = None
+    if tier == "real":
+        # The record's start is when the disruption was announced; dispatchers have often cut trains short a few
+        # minutes before. Start the window (and the disruption) earlier until no train was cut before it.
+        for early in (0, 5, 10, 15, 20, 30, 45):
+            s0 = real["start"] - early
+            closures = closures_for(net, real["cause"], real["stations"], s0, real["end"], _rng(cid), real=True)
+            why = []
+            task = build_task(day, s0, s0 + window, closures, task_id=cid, split=split, difficulty=tier,
+                              notices=notices, why=why)
+            if task is not None or "cut short" not in (why[0] if why else ""):
+                break
+        if task is not None and early:
+            task.notices.append(f"The record announces this disruption at {hhmm(real['start'])}; trains were already "
+                                f"being cut short, so it starts here at {hhmm(task.start)}.")
+    else:
+        closures, notices = seeded_closures(net, tier, start, window, rng)
+        task = build_task(day, start, start + window, closures, task_id=cid, split=split, difficulty=tier,
+                          notices=notices, why=why)
+    if task is None:
+        return None, "rebuild: " + (why[0] if why else "?")
+    lo, hi = TIERS[tier].get("late", (0, 0)) if isinstance(TIERS[tier].get("late"), tuple) else (0, 0)
+    waiting = [u for u in task.units if u.at and not task.run(u.runs[0]).started]
+    for u in rng.sample(waiting, min(len(waiting), rng.randint(lo, hi))):
+        extra = rng.choice((10, 15, 20, 25, 30))
+        first = task.run(u.runs[0])
+        u.ready = max(u.ready or start, first.dep[0]) + extra
+        task.notices.append(f"Train set {u.id} at {u.at} is held for {rng.choice(LATE_CAUSES)}: it cannot leave "
+                            f"before {hhmm(u.ready)} (its next run {first.id} is due at {hhmm(first.dep[0])}).")
+    if len(task.runs) < MIN_RUNS:
+        return None, f"too small: {len(task.runs)} runs"
+    maxd = task.rule("max_delay")
+    for r in task.runs:
+        if r.started and r.arr[r.fixed_to] is not None and r.fixed_arr - r.arr[r.fixed_to] > maxd - 30:
+            return None, f"{r.id} is already {r.fixed_arr - r.arr[r.fixed_to]} min late"
+    return task, ""
+
+
+def _one(args):
+    day, start, window, tier, seed, split, real, limit, workers = args
+    t0 = time.time()
+    stats = {"day": day, "start": start, "window": window, "tier": tier, "seed": seed}
+    try:
+        task, reason = make_candidate(day, start, window, tier, seed, split, real)
+        if task is None:
+            stats["reason"] = reason
+            return None, stats
+        ref = add_reference(task, time_limit=limit, workers=workers)
+        gap = (ref["optimal_cost"] - ref["lower_bound"]) / (ref["optimal_cost"] - ref["floor_cost"] + task.rule("gap_k"))
+        stats.update(task_id=task.task_id, runs=len(task.runs), optimal=ref["optimal_cost"], bound=ref["lower_bound"],
+                     floor=ref["floor_cost"], proven=ref["proven_optimal"], naive=ref["naive_reward"],
+                     greedy=ref["greedy_reward"], greedy_fast=ref["greedy_fast_reward"],
+                     real_cost=ref.get("real", {}).get("cost"))
+        if gap > MAX_GAP:
+            stats["reason"] = f"not solved within 1% ({gap:.3f})"
+            return None, stats
+        if ref["naive_reward"] > MAX_NAIVE_REWARD:
+            stats["reason"] = f"too easy: naive {ref['naive_reward']}"
+            return None, stats
+        if max(ref["greedy_reward"], ref["greedy_fast_reward"]) > MAX_GREEDY_REWARD:
+            stats["reason"] = f"too easy: greedy {max(ref['greedy_reward'], ref['greedy_fast_reward'])}"
+            return None, stats
+        ref["hardness"] = features(task)
+        stats["hardness"] = ref["hardness"]
+        stats["reason"] = "kept"
+        return task.to_dict(), stats
+    except ValueError as e:
+        if "no feasible plan" in str(e):   # the record's state at `start` already breaks a rule (e.g. two trains
+            stats["reason"] = "infeasible: no legal plan from the rebuilt state"   # stuck head-on)
+        else:
+            stats["reason"] = f"error {type(e).__name__}: {e}"
+        return None, stats
+    except Exception as e:      # a generator or solver bug on one candidate is logged, not fatal
+        stats["reason"] = f"error {type(e).__name__}: {e}"
+        return None, stats
+    finally:
+        stats["seconds"] = round(time.time() - t0, 1)
+
+
+def candidates(split: str, max_seed: int, tiers: list[str]) -> list[tuple]:
+    out = []
+    if "real" in tiers:
+        for d in real_disruptions(split):
+            for window in (180,):
+                out.append((d["day"], d["start"], window, "real", 0, split, d))
+    seeded = [t for t in tiers if t != "real"]
+    for seed in range(max_seed):
+        batch = []
+        for day in split_days(split):
+            for a, b in PEAKS:
+                for start in range(a, b + 1, 30):
+                    for tier in seeded:
+                        lo, hi = TIERS[tier]["window"]
+                        window = lo + 30 * ((seed + start // 30) % ((hi - lo) // 30 + 1))
+                        batch.append((day, start, window, tier, seed, split, None))
+        key = lambda c: hashlib.sha1(repr(c[:5]).encode()).hexdigest()
+        out += sorted(batch, key=key)
+    return out
+
+
+def write_pack(out: Path, tasks: list[dict], log: list[dict], split: str, extra: dict | None = None):
+    out.mkdir(parents=True, exist_ok=True)
+    body = "".join(json.dumps(t, ensure_ascii=False, separators=(",", ":")) + "\n" for t in tasks).encode()
+    name = "tasks.jsonl"
+    if len(body) > 8_000_000:
+        (out / "tasks.jsonl.gz").write_bytes(gzip.compress(body, mtime=0))
+        (out / "tasks.jsonl").unlink(missing_ok=True)
+        name = "tasks.jsonl.gz"
+    else:
+        (out / name).write_bytes(body)
+        (out / "tasks.jsonl.gz").unlink(missing_ok=True)
+    tiers: dict[str, int] = {}
+    for t in tasks:
+        tiers[t["difficulty"]] = tiers.get(t["difficulty"], 0) + 1
+    manifest = {"name": out.name, "split": split, "tasks": len(tasks), "file": name, "tiers": tiers,
+                "sha256": hashlib.sha256(body).hexdigest(), "candidates": len(log),
+                "days": sorted({t["day"] for t in tasks}),
+                "proven_optimal": sum(bool(t["reference"].get("proven_optimal")) for t in tasks),
+                "runs": [min((len(t["runs"]) for t in tasks), default=0), max((len(t["runs"]) for t in tasks), default=0)],
+                "source": "Rijden de Treinen train archive and disruptions, 2024-2025 (CC BY 4.0); OpenStreetMap "
+                          "(ODbL); see data/gnlw/SOURCE.md", **(extra or {})}
+    (out / "manifest.json").write_text(json.dumps(manifest, indent=2) + "\n")
+    (out / "build_log.jsonl").write_text("".join(json.dumps(s) + "\n" for s in log))
+    return manifest
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--split", required=True, choices=["eval", "train"])
+    ap.add_argument("--n", type=int, required=True, help="tasks to keep")
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--tiers", nargs="*", default=list(TIERS))
+    ap.add_argument("--time-limit", type=float, default=120.0)
+    ap.add_argument("--procs", type=int, default=2)
+    ap.add_argument("--workers", type=int, default=2, help="CP-SAT threads per candidate")
+    ap.add_argument("--max-seed", type=int, default=4)
+    ap.add_argument("--max-candidates", type=int, default=0, help="stop after trying this many (0: no cap)")
+    args = ap.parse_args()
+    out = Path(args.out)
+    part = out / "partial"
+    part.mkdir(parents=True, exist_ok=True)
+    log: list[dict] = []
+    kept: list[dict] = []
+    done = set()
+    if (part / "log.jsonl").is_file():
+        for line in (part / "log.jsonl").read_text().splitlines():
+            st = json.loads(line)
+            log.append(st)
+            done.add((st["day"], st["start"], st["window"], st["tier"], st["seed"]))
+    if (part / "kept.jsonl").is_file():
+        kept = [json.loads(line) for line in (part / "kept.jsonl").read_text().splitlines()]
+    queue = [c for c in candidates(args.split, args.max_seed, args.tiers) if c[:5] not in done]
+    print(f"resuming: {len(log)} tried, {len(kept)} kept, {len(queue)} queued", flush=True)
+    from concurrent.futures import FIRST_COMPLETED, wait
+
+    def more() -> bool:
+        return bool(queue) and len(kept) < args.n and (not args.max_candidates or len(log) + len(running)
+                                                         < args.max_candidates)
+
+    with ProcessPoolExecutor(args.procs) as ex:
+        running = set()
+        while True:
+            while more() and len(running) < args.procs:      # keep every worker busy
+                running.add(ex.submit(_one, queue.pop(0) + (args.time_limit, args.workers)))
+            if not running:
+                break
+            finished, running = wait(running, return_when=FIRST_COMPLETED)
+            for f in finished:
+                task, stats = f.result()
+                log.append(stats)
+                with open(part / "log.jsonl", "a") as fh:
+                    fh.write(json.dumps(stats) + "\n")
+                if task and len(kept) < args.n:
+                    kept.append(task)
+                    with open(part / "kept.jsonl", "a") as fh:
+                        fh.write(json.dumps(task, ensure_ascii=False, separators=(",", ":")) + "\n")
+            reasons: dict[str, int] = {}
+            for s_ in log:
+                k = s_["reason"].split(":")[0].split(" (")[0]
+                reasons[k] = reasons.get(k, 0) + 1
+            print(f"{len(log)} tried, {len(kept)} kept; {reasons}", flush=True)
+            if len(kept) >= args.n:
+                for f in running:
+                    f.cancel()
+                break
+    kept.sort(key=lambda t: (t["difficulty"], t["day"], t["start"], t["task_id"]))
+    print(json.dumps(write_pack(out, kept, log, args.split), indent=2))
+
+
+if __name__ == "__main__":
+    main()

core/rail_core/check.py

@@ -0,0 +1,364 @@
+"""The physics and the grader: a plan in, every train's times, every rule it breaks and its cost out. Pure Python and
+deterministic; nothing here needs a solver.
+
+Physics (`simulate`). Each train set works its runs in order. A run leaves its first point at the latest of: when its
+train is ready there, its scheduled departure (or passing minute), and the plan's hold. It then runs at its minimum
+running times, but never reaches a point before its timetable minute there (drivers run to the timetable; a late
+train makes up time). At a scheduled stop it leaves at the latest of arriving, its scheduled departure and any hold; at a
+point where it has no stop it passes, unless held past its passing minute: then it stops, losing `stop_loss` minutes
+braking and `stop_loss` accelerating. Junctions cannot hold a train. After a run its train is ready again `turn_min`
+minutes after arriving, at the point where the run ended.
+
+Rules (`evaluate`), each broken one is a violation:
+    single track    two trains going opposite ways may not be in a single-track section at once; the second enters
+                    at least h_opp minutes after the first has left
+    headway         trains going the same way keep h_follow minutes apart at both ends of every section, so nothing
+                    overtakes between points
+    platforms       no more trains at a station than it has tracks (minus any out of use); at a directional station
+                    (double track) one per direction
+    closed          no train in a closed section while it is closed (a train already stuck inside waits there)
+    continuity      a run starts where its train is; short-turns only at turn points; a running train cannot be
+                    cancelled or turned behind itself; every train ends the window where its next run leaves from
+    max delay       no stop reached more than max_delay minutes late
+
+Cost, in stop-minutes (lower is better): the arrival delay at every scheduled stop a train serves, plus cancel_cost
+for every scheduled stop it does not serve, plus, for each train set, its lateness for its first run after the
+window times that run's number of stops (delay handed on to the next window).
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass, field
+
+from .model import Order, Plan, Run, Task, hhmm
+from .network import Network
+
+NEG = -10**9
+
+
+@dataclass
+class RunResult:
+    train: str
+    unit: str
+    cancelled: bool = False
+    first: int | None = None              # route index of its first served point
+    last: int | None = None               # route index of its last served point
+    arr: dict[int, int] = field(default_factory=dict)
+    dep: dict[int, int] = field(default_factory=dict)
+    stopped: dict[int, bool] = field(default_factory=dict)
+    delay: int = 0
+    unserved: int = 0
+    max_late: int = 0
+    cost: int = 0
+    problems: list[str] = field(default_factory=list)
+
+
+@dataclass
+class PlanResult:
+    feasible: bool
+    cost: int | None
+    delay_cost: int
+    cancel_cost: int
+    carry_cost: int
+    cancelled: int
+    short_turned: int
+    runs: list[RunResult]
+    violations: list[dict]
+
+
+@dataclass
+class _Occ:      # a train in a section
+    sec: int
+    dir: int
+    enter: int
+    exit: int
+    train: str
+    history: bool = False
+
+
+@dataclass
+class _Pres:     # a train standing at (or passing) a station, minutes inclusive
+    point: str
+    dir: int
+    t0: int
+    t1: int
+    train: str
+
+
+def network(task: Task) -> Network:
+    n = task.__dict__.get("_net")
+    if n is None:
+        n = task.__dict__["_net"] = Network.from_dict(task.network)
+    return n
+
+
+def run_dir(net: Network, r: Run) -> int:
+    return net.direction(r.origin, r.dest)
+
+
+def served_part(task: Task, r: Run, o: Order) -> tuple[int, int, list[str]]:
+    """(first, last, problems) for the part of the route the plan runs."""
+    net = network(task)
+    probs = []
+    s = r.idx(o.start) if o.start else 0
+    e = r.idx(o.end) if o.end else len(r.route) - 1
+    if o.start and o.start != r.origin:
+        if r.started:
+            probs.append(f"{r.id} is already running from {r.origin}: it cannot start at {o.start}")
+            s = 0
+        elif not net.by_code[o.start].turn:
+            probs.append(f"{r.id} cannot start at {o.start}: trains can only be turned at "
+                         + ", ".join(p.code for p in net.points if p.turn))
+    if o.end and o.end != r.dest and not net.by_code[o.end].turn:
+        probs.append(f"{r.id} cannot end at {o.end}: trains can only be turned at "
+                     + ", ".join(p.code for p in net.points if p.turn))
+    if e <= s:
+        probs.append(f"{r.id}: 'to' {r.route[e]} must come after where it starts ({r.route[s]})")
+        e = len(r.route) - 1
+    if r.started and e < r.fixed_to:
+        probs.append(f"{r.id} is already past {r.route[e]}: it can end at {r.route[r.fixed_to]} at the earliest")
+        e = len(r.route) - 1
+    return s, e, probs
+
+
+def simulate(task: Task, plan: Plan):
+    """Times for every run under the plan. Returns (results by train, structural violations, section occupancies,
+    station presences, carry cost per unit)."""
+    net = network(task)
+    loss, turn = task.rule("stop_loss"), task.rule("turn_min")
+    runs = task.run_map
+    results: dict[str, RunResult] = {}
+    viol: list[dict] = []
+    occ: list[_Occ] = []
+    pres: list[_Pres] = []
+    carry: dict[str, int] = {}
+    slow = [c for c in task.closures if c.kind == "slow"]
+
+    def slow_extra(sec: int, t: int) -> int:
+        x = 0
+        for c in slow:
+            lo, hi = sorted((net.index[c.where[0]], net.index[c.where[-1]]))
+            if lo <= sec < hi and c.start <= t < c.end:
+                x = max(x, c.extra)
+        return x
+
+    def finite(code: str) -> bool:
+        p = net.by_code[code]
+        return p.kind != "junction" and p.tracks is not None
+
+    for u in task.units:
+        pos, ready = u.at, u.ready
+        wait_from: int | None = task.start if (u.at and finite(u.at)) else None   # standing at a station at start
+        for rid in u.runs:
+            r = runs[rid]
+            o = plan.get(rid) or Order()
+            res = RunResult(train=rid, unit=u.id)
+            results[rid] = res
+            d = run_dir(net, r)
+            if o.cancel:
+                if r.started:
+                    res.problems.append(f"{rid} is already running: it cannot be cancelled (short-turn it instead)")
+                    o = Order(end=o.end, hold=o.hold)
+                else:
+                    res.cancelled = True
+                    res.unserved = r.n_stops
+                    continue
+            s, e, probs = served_part(task, r, o)
+            res.problems += probs
+            k = r.fixed_to if r.started else s
+            if not r.started and r.route[s] != pos:
+                res.problems.append(f"{rid} would start at {r.route[s]}, but its train ({u.id}) is at {pos}")
+            for code in o.hold:
+                i = r.idx(code)
+                if i < k or i >= e:
+                    res.problems.append(f"{rid}: hold at {code} is outside the part it runs "
+                                        f"({r.route[k]} to {r.route[e]}, holds only where it leaves from)")
+                elif net.by_code[code].kind == "junction":
+                    res.problems.append(f"{rid}: trains cannot be held at the junction {code}")
+            res.first, res.last = s, e
+            arr, dep, stopped = res.arr, res.dep, res.stopped
+            last_occ = None
+            if r.started:
+                arr[k] = r.fixed_arr
+                if r.fixed_from is not None:
+                    last_occ = _Occ(net.section(r.route[k - 1], r.route[k]), d, r.fixed_from, r.fixed_arr, rid, True)
+                    occ.append(last_occ)
+            i = k
+            while True:
+                code = r.route[i]
+                pt = net.by_code[code]
+                h = o.hold.get(code) if s <= i < e else None
+                accel = 0
+                if i == e:
+                    stopped[i] = True
+                    break
+                if i == k and not r.started:                 # where the run starts
+                    t = max(ready if ready is not None else NEG, r.dep[i], h if h is not None else NEG)
+                    stopped[i] = True
+                    accel = 0 if r.stops[i] else loss
+                    if wait_from is not None and finite(code):
+                        pres.append(_Pres(code, d, wait_from, t, rid))
+                elif r.stops[i]:
+                    t = max(arr[i], r.dep[i], h if h is not None else NEG)
+                    stopped[i] = True
+                elif pt.kind != "junction" and h is not None and h > arr[i]:
+                    arr[i] += loss                            # an unscheduled stop: it brakes ...
+                    if last_occ is not None:
+                        last_occ.exit = arr[i]                # ... still in the section it is leaving
+                    t = max(arr[i], h)
+                    stopped[i] = True
+                    accel = loss                              # ... and accelerates again
+                else:
+                    t = arr[i]
+                    stopped[i] = False
+                if r.started and i == k:
+                    t = max(t, task.start)                    # standing there when the task starts
+                dep[i] = t
+                if (i != k or r.started) and finite(code):
+                    pres.append(_Pres(code, d, arr[i], t, rid))
+                sec = net.section(code, r.route[i + 1])
+                nxt = t + r.seg[i] + accel + slow_extra(sec, t)
+                if r.arr[i + 1] is not None:
+                    nxt = max(nxt, r.arr[i + 1])              # never ahead of the timetable
+                if i + 1 == e and not r.stops[e]:
+                    nxt += loss                               # brakes to end where it has no scheduled stop
+                arr[i + 1] = nxt
+                last_occ = _Occ(sec, d, t, nxt, rid)
+                occ.append(last_occ)
+                i += 1
+            # cost
+            for j in range(k if r.started else s + 1, e + 1):
+                if r.stops[j] and r.arr[j] is not None and arr[j] >= task.start:
+                    late = arr[j] - r.arr[j]
+                    res.delay += max(0, late)
+                    res.max_late = max(res.max_late, late)
+            res.unserved = sum(1 for j, st in enumerate(r.stops) if st and not (s <= j <= e))
+            pos, ready = r.route[e], arr[e] + turn
+            wait_from = arr[e] if finite(r.route[e]) else None
+        if wait_from is not None and pos is not None:
+            pres.append(_Pres(pos, 0, wait_from, task.end + 24 * 60, u.id))
+        if u.after:
+            if pos != u.after["station"]:
+                viol.append({"rule": "continuity", "trains": [u.after["run"]], "where": pos,
+                             "detail": f"train set {u.id} ends the window at {pos}, but its next run "
+                                       f"{u.after['run']} leaves {u.after['station']} at {hhmm(u.after['dep'])}"})
+            elif ready is not None:
+                carry[u.id] = max(0, ready - u.after["dep"]) * int(u.after["stops"])
+    return results, viol, occ, pres, carry
+
+
+def evaluate(task: Task, plan: Plan) -> PlanResult:
+    net = network(task)
+    results, viol, occ, pres, carry = simulate(task, plan)
+    hf, ho, maxd = task.rule("h_follow"), task.rule("h_opp"), task.rule("max_delay")
+    bad: dict[str, set] = defaultdict(set)
+
+    def add(rule: str, trains: list[str], where: str, time: int | None, detail: str):
+        viol.append({"rule": rule, "trains": trains, "where": where, "time": hhmm(time), "detail": detail})
+        for t in trains:
+            if t in results:
+                bad[t].add(rule)
+
+    for rid, res in results.items():
+        for p in res.problems:
+            add("continuity", [rid], "", None, p)
+        if res.max_late > maxd:
+            add("max_delay", [rid], "", None, f"{rid} reaches a stop {res.max_late} minutes late (limit {maxd}): "
+                                               f"short-turn or cancel it")
+
+    # sections: headways and single track
+    by_sec: dict[int, list[_Occ]] = defaultdict(list)
+    for o in occ:
+        by_sec[o.sec].append(o)
+    for sec, lst in by_sec.items():
+        s = net.sections[sec]
+        name = f"{s.a}-{s.b}"
+        lst.sort(key=lambda o: (o.enter, o.exit))
+        for i, a in enumerate(lst):
+            for b in lst[i + 1:]:
+                if b.enter > a.exit + max(hf, ho) and b.enter > a.enter + hf:
+                    break
+                if a.train == b.train:
+                    continue
+                if a.dir == b.dir:
+                    if b.enter - a.enter < hf or b.exit - a.exit < hf:
+                        what = "overtakes" if b.exit < a.exit else "follows too closely"
+                        add("headway", [a.train, b.train], name, b.enter,
+                            f"{b.train} {what} {a.train} in {name}: enter {hhmm(a.enter)}/{hhmm(b.enter)}, "
+                            f"leave {hhmm(a.exit)}/{hhmm(b.exit)} (same direction: {hf} min apart at both ends, "
+                            f"no overtaking between points)")
+                elif s.single and not (a.exit + ho <= b.enter or b.exit + ho <= a.enter):
+                    add("single_track", [a.train, b.train], name, b.enter,
+                        f"{a.train} ({hhmm(a.enter)}-{hhmm(a.exit)}) and {b.train} ({hhmm(b.enter)}-{hhmm(b.exit)}) "
+                        f"meet head-on in single-track {name}")
+    # closures
+    for c in task.closures:
+        if c.kind != "closed":
+            continue
+        lo, hi = sorted((net.index[c.where[0]], net.index[c.where[-1]]))
+        for o in occ:
+            if lo <= o.sec < hi and not o.history and o.enter < c.end and o.exit > c.start:
+                s = net.sections[o.sec]
+                add("closed", [o.train], f"{s.a}-{s.b}", o.enter,
+                    f"{o.train} is in {s.a}-{s.b} ({hhmm(o.enter)}-{hhmm(o.exit)}) while it is closed "
+                    f"{hhmm(c.start)}-{hhmm(c.end)} ({c.cause})")
+    # platforms
+    out_of_use: dict[str, list] = defaultdict(list)
+    for c in task.closures:
+        if c.kind == "track":
+            out_of_use[c.where[0]].append((c.start, c.end))
+    by_pt: dict[str, list[_Pres]] = defaultdict(list)
+    for p in pres:
+        by_pt[p.point].append(p)
+    for code, lst in by_pt.items():
+        pt = net.by_code[code]
+        groups = [[p for p in lst if p.dir == d] for d in (1, -1)] if pt.directional else [lst]
+        for g in groups:
+            cap = 1 if pt.directional else pt.tracks
+            events = sorted({p.t0 for p in g} | {a for a, _ in out_of_use.get(code, [])})
+            reported = set()
+            for t in events:
+                here = [p for p in g if p.t0 <= t <= p.t1]
+                c_t = cap - sum(1 for a, b in out_of_use.get(code, []) if a <= t < b)
+                if len(here) > c_t:
+                    key = tuple(sorted(p.train for p in here))
+                    if key in reported:
+                        continue
+                    reported.add(key)
+                    tracks = ("one track each way" if pt.directional else f"{c_t} track" + ("s" if c_t != 1 else ""))
+                    add("platforms", list(key), code, t,
+                        f"{len(here)} trains at {code} at {hhmm(t)} but it has {tracks}: "
+                        + ", ".join(f"{p.train} {hhmm(p.t0)}-{hhmm(p.t1) if p.t1 < task.end + 1440 else 'end'}"
+                                    for p in here))
+
+    delay = sum(r.delay for r in results.values())
+    cancel = task.rule("cancel_cost") * sum(r.unserved for r in results.values())
+    carry_cost = sum(carry.values())
+    for rid, res in results.items():
+        res.cost = res.delay + task.rule("cancel_cost") * res.unserved
+        res.problems = sorted(bad.get(rid, set()))
+    feasible = not viol
+    n_cxl = sum(1 for r in results.values() if r.cancelled)
+    n_st = sum(1 for rid, r in results.items()
+               if not r.cancelled and (r.first != 0 or r.last != len(task.run(rid).route) - 1))
+    return PlanResult(feasible, delay + cancel + carry_cost if feasible else None, delay, cancel, carry_cost, n_cxl,
+                      n_st, list(results.values()), viol)
+
+
+def timetable(task: Task, res: RunResult) -> list[dict]:
+    """The served points of one run with arrival and departure (passing) minutes, for display."""
+    r = task.run(res.train)
+    net = network(task)
+    out = []
+    if res.cancelled:
+        return out
+    for i in sorted(set(res.arr) | set(res.dep)):
+        code = r.route[i]
+        if net.by_code[code].kind == "junction":
+            continue
+        out.append({"at": code, "arr": hhmm(res.arr.get(i)), "dep": hhmm(res.dep.get(i)),
+                    "stop": bool(res.stopped.get(i)), "sched": hhmm(r.arr[i] if r.stops[i] and r.arr[i] is not None
+                                                                   else r.dep[i] if r.stops[i] else None),
+                    "late": (res.arr[i] - r.arr[i]) if (r.stops[i] and r.arr[i] is not None and i in res.arr) else None})
+    return out

core/rail_core/data.py

@@ -0,0 +1,207 @@
+"""The curated record (data/gnlw): every Arriva train between Leeuwarden and Groningen, January-June 2025, with its
+schedule, delays and cancellations; the derived rolling-stock links; the real disruptions; the minimum running times.
+
+`day_runs(day)` turns one service day into model runs: the route through every point (junctions included), the
+scheduled stops, the timetable's passing minutes at the points in between (interpolated by distance) and the
+minimum running time of every section (the calibrated stop-to-stop minimum, split by distance).
+"""
+
+from __future__ import annotations
+
+import csv
+import gzip
+import json
+from dataclasses import dataclass, field
+from functools import lru_cache
+from pathlib import Path
+
+from .model import Run
+from .network import DATA, Network, load_network
+
+LINE_DIR = DATA / "gnlw"
+KIND = {"Stoptrein": "stop", "Sneltrein": "fast"}
+
+
+@dataclass
+class Stop:
+    code: str
+    sa: int | None            # scheduled arrival
+    sd: int | None            # scheduled departure
+    ad: int | None            # arrival delay
+    dd: int | None            # departure delay
+    arr_cxl: bool
+    dep_cxl: bool
+
+    @property
+    def aa(self) -> int | None:          # actual arrival
+        return None if self.sa is None or self.ad is None else self.sa + self.ad
+
+    @property
+    def adep(self) -> int | None:        # actual departure
+        return None if self.sd is None or self.dd is None else self.sd + self.dd
+
+
+@dataclass
+class Service:
+    train: str
+    type: str
+    stops: list[Stop]
+    full_cxl: bool
+    part_cxl: bool
+
+    @property
+    def kind(self) -> str:
+        return KIND.get(self.type, "stop")
+
+
+@dataclass
+class Day:
+    date: str
+    services: dict[str, Service]
+    links: dict[str, str]                 # arriving train -> the train it forms next
+    runs: dict[str, Run] = field(default_factory=dict)
+    chains: list[list[str]] = field(default_factory=list)
+
+
+def _int(x: str) -> int | None:
+    return int(x) if x not in ("", None) else None
+
+
+@lru_cache(maxsize=1)
+def _all_services() -> dict[str, dict[str, Service]]:
+    by_day: dict[str, dict[str, Service]] = {}
+    rows: dict[tuple, list[dict]] = {}
+    with gzip.open(LINE_DIR / "services_2025h1.csv.gz", "rt", encoding="utf-8") as f:
+        for r in csv.DictReader(f):
+            rows.setdefault((r["date"], r["svc"]), []).append(r)
+    for (day, _), rs in rows.items():
+        rs.sort(key=lambda r: int(r["seq"]))
+        s = Service(rs[0]["train"], rs[0]["type"],
+                    [Stop(r["code"], _int(r["sched_arr"]), _int(r["sched_dep"]), _int(r["arr_delay"]),
+                          _int(r["dep_delay"]), r["arr_cxl"] == "1", r["dep_cxl"] == "1") for r in rs],
+                    rs[0]["full_cxl"] == "1", rs[0]["part_cxl"] == "1")
+        by_day.setdefault(day, {})
+        if s.train in by_day[day]:          # a number used twice in a day: keep the first, number the second
+            s.train = f"{s.train}b"
+        by_day[day][s.train] = s
+    return by_day
+
+
+@lru_cache(maxsize=1)
+def _all_links() -> dict[str, dict[str, str]]:
+    out: dict[str, dict[str, str]] = {}
+    with open(LINE_DIR / "links_2025h1.csv", encoding="utf-8") as f:
+        for r in csv.DictReader(f):
+            out.setdefault(r["date"], {})[r["arriving"]] = r["forms"]
+    return out
+
+
+@lru_cache(maxsize=1)
+def runtimes() -> dict:
+    return json.loads((LINE_DIR / "runtimes.json").read_text())
+
+
+def disruptions() -> list[dict]:
+    with open(LINE_DIR / "disruptions_2025h1.csv", encoding="utf-8") as f:
+        return list(csv.DictReader(f))
+
+
+def days() -> list[str]:
+    return sorted(_all_services())
+
+
+def span_minutes(net: Network, kind: str, a: str, b: str) -> int:
+    """Minimum running minutes between consecutive scheduled stops a and b."""
+    rt = runtimes()
+    hit = rt.get(kind, {}).get(f"{a}>{b}")
+    if hit:
+        return int(hit["min"])
+    # fallback: the stopping train's legs, less a minute per stop skipped
+    route = [c for c in net.route(a, b) if net.by_code[c].kind != "junction"]
+    total = 0
+    for x, y in zip(route, route[1:]):
+        leg = rt["stop"].get(f"{x}>{y}")
+        if leg is None:
+            raise KeyError(f"no running time for {kind} {a}>{b}")
+        total += int(leg["min"])
+    return max(1, total - (len(route) - 2))
+
+
+def clean_stops(net: Network, s: Service) -> list[Stop]:
+    """The service's stops in route order with both times where it calls on the way. On disrupted days the record
+    holds services changed on the day: an extra stop with only one time, or stops listed out of order."""
+    timed = sorted(s.stops, key=lambda st: st.sd if st.sd is not None else (st.sa if st.sa is not None else 10**9))
+    first, last = timed[0].code, timed[-1].code
+    d = net.direction(first, last)
+    seen: dict[str, Stop] = {}
+    for st in s.stops:
+        seen.setdefault(st.code, st)
+    out = sorted(seen.values(), key=lambda st: d * net.index[st.code])
+    for i, st in enumerate(out):
+        if 0 < i < len(out) - 1:
+            if st.sa is None:
+                st.sa = st.sd
+            if st.sd is None:
+                st.sd = st.sa
+    if out[0].sd is None:
+        out[0].sd = out[0].sa
+    if out[-1].sa is None:
+        out[-1].sa = out[-1].sd
+    times = [t for st in out for t in (st.sa, st.sd) if t is not None]
+    if any(b < a for a, b in zip(times, times[1:])):
+        raise ValueError(f"service {s.train}: times not in route order")
+    return out
+
+
+def make_run(net: Network, s: Service, unit: str = "") -> Run:
+    stops_rec = clean_stops(net, s)
+    codes = [st.code for st in stops_rec]
+    route = net.route(codes[0], codes[-1])
+    stop_at = {st.code: st for st in stops_rec}
+    n = len(route)
+    stops = [c in stop_at for c in route]
+    arr: list[int | None] = [None] * n
+    dep: list[int | None] = [None] * n
+    seg = [0] * (n - 1)
+    idx = [i for i in range(n) if stops[i]]
+    for i in idx:
+        st = stop_at[route[i]]
+        arr[i] = st.sa if i > 0 else None
+        dep[i] = st.sd if i < n - 1 else None
+    for ia, ib in zip(idx, idx[1:]):
+        a, b = stop_at[route[ia]], stop_at[route[ib]]
+        t_min = span_minutes(net, s.kind, route[ia], route[ib])
+        t_sched = (b.sa if b.sa is not None else b.sd) - (a.sd if a.sd is not None else a.sa)
+        ka, kb = net.by_code[route[ia]].km, net.by_code[route[ib]].km
+        cum = [round(t_min * abs(net.by_code[route[i]].km - ka) / abs(kb - ka)) for i in range(ia, ib + 1)]
+        for j in range(1, len(cum)):                # every section takes at least a minute
+            cum[j] = max(cum[j], cum[j - 1] + 1)
+        for j in range(ia, ib):
+            seg[j] = cum[j - ia + 1] - cum[j - ia]
+        t0 = a.sd if a.sd is not None else a.sa
+        for i in range(ia + 1, ib):
+            arr[i] = dep[i] = t0 + round(t_sched * abs(net.by_code[route[i]].km - ka) / abs(kb - ka))
+    return Run(id=s.train, kind=s.kind, route=route, stops=stops, arr=arr, dep=dep, seg=seg, unit=unit)
+
+
+@lru_cache(maxsize=64)
+def load_day(date: str) -> Day:
+    net = load_network()
+    services = dict(_all_services()[date])
+    for t in list(services):                  # a handful of services changed on the day are unreadable: drop them
+        try:
+            clean_stops(net, services[t])
+        except ValueError:
+            del services[t]
+    links = {a: f for a, f in _all_links().get(date, {}).items() if a in services and f in services}
+    day = Day(date, services, links)
+    formed = set(links.values())
+    starts = sorted((t for t in services if t not in formed), key=lambda t: services[t].stops[0].sd or 0)
+    for k, t in enumerate(starts):
+        chain = [t]
+        while chain[-1] in links:
+            chain.append(links[chain[-1]])
+        day.chains.append(chain)
+        for x in chain:
+            day.runs[x] = make_run(net, services[x], unit=f"T{k + 1:02d}")
+    return day

core/rail_core/generate.py

@@ -0,0 +1,226 @@
+"""A task from a real day: the line as it really stood at `start`, every run that leaves before `end`, the closures.
+
+The state at `start` comes from the 2025 record:
+    a train running then is placed where its actual departure from its last stop puts it (passing points by the
+    minimum running times); it keeps its real delay
+    a train set standing at a terminal is ready `turn_min` after its last run's actual arrival
+Everything after `start` is decided by the plan; the record's later times are kept only to score what the real
+dispatchers did (`reference.real`).
+
+A window is refused (`None`) when it cannot be rebuilt honestly: a run before `start` was cancelled or cut short in
+the record (its train is then not where the schedule says), or the plain timetable already conflicts inside it.
+"""
+
+from __future__ import annotations
+
+from .check import evaluate, network
+from .data import Day, Service, load_day
+from .model import RULES, Closure, Order, Run, Task, Unit, hhmm
+from .network import Network, load_network
+
+# causes after which the train involved is itself out of service (it blocks the section until the line reopens)
+FAILURES = ("broken down train", "collision", "defective train", "a collision", "an accident")
+
+
+def _actual(svc: Service, code: str) -> tuple[int | None, int | None, bool]:
+    """(actual arrival, actual departure, cancelled) at a stop of the record."""
+    for st in svc.stops:
+        if st.code == code:
+            return st.aa, st.adep, (st.arr_cxl or st.sa is None) and (st.dep_cxl or st.sd is None)
+    return None, None, True
+
+
+def _is_failure(net: Network, r: Run, served: list[str], closed: list[Closure]) -> bool:
+    """The run that broke down (or collided): cut short by a failure closure, last served next to the closed span."""
+    for c in closed:
+        if not any(f in c.cause.lower() for f in FAILURES):
+            continue
+        lo, hi = sorted((net.index[c.where[0]], net.index[c.where[-1]]))
+        last = served[-1] if served else r.origin
+        if lo - 1 <= net.index[last] <= hi + 1:
+            return True
+    return False
+
+
+def _served_in_record(svc: Service) -> list[str]:
+    return [st.code for st in svc.stops if not ((st.arr_cxl or st.sa is None) and (st.dep_cxl or st.sd is None))]
+
+
+def _place(net: Network, r: Run, svc: Service, start: int, closed: list[Closure]):
+    """Where a run is at `start`, from the record: None (it was cut short before `start`: the window cannot be
+    rebuilt), ("done", actual arrival), ("future", None), or (fixed_to, fixed_arr, fixed_from, stuck)."""
+    last_t = last_i = None
+    stop_at = len(r.route) - 1                   # the first stop it had not reached by `start`
+    for i, code in enumerate(r.route):
+        if not r.stops[i]:
+            continue
+        aa, ad, cxl = _actual(svc, code)
+        t_sched = r.arr[i] if r.arr[i] is not None else r.dep[i]
+        if cxl:
+            if t_sched < start:
+                return None
+            stop_at = i
+            break
+        if i > 0 and (aa is None or aa > start):
+            stop_at = i
+            break
+        if i == len(r.route) - 1:
+            return ("done", aa)
+        if ad is None or ad > start:
+            return ("future", None) if i == 0 else (i, aa, None, False)
+        last_t, last_i = ad, i
+    if last_i is None:
+        return ("future", None)
+    t = last_t
+    for i in range(last_i, stop_at):
+        nxt = t + r.seg[i]
+        if r.arr[i + 1] is not None:
+            nxt = max(nxt, r.arr[i + 1])
+        sec = net.section(r.route[i], r.route[i + 1])
+        for c in closed:
+            lo, hi = sorted((net.index[c.where[0]], net.index[c.where[-1]]))
+            if lo <= sec < hi and c.start <= start < c.end and t < c.start:
+                return (i + 1, max(start, c.end + max(0, nxt - c.start)), t, True)   # caught in the closed section
+        if nxt >= start or i + 1 == stop_at:
+            return (i + 1, max(start, nxt), t, False)
+        t = nxt
+    return ("done", t)
+
+
+def build_task(date: str, start: int, end: int, closures: list[Closure] | None = None, *, task_id: str = "",
+               split: str = "train", difficulty: str = "standard", notices: list[str] | None = None,
+               disruptions: list[dict] | None = None, rules: dict | None = None,
+               lookback: int = 150, why: list | None = None) -> Task | None:
+    why = why if why is not None else []
+    net = load_network()
+    day = load_day(date)
+    rules = {**RULES, **(rules or {})}
+    turn = rules["turn_min"]
+    closures = list(closures or [])
+    closed = [c for c in closures if c.kind == "closed"]
+    runs: list[Run] = []
+    units: list[Unit] = []
+    notes = list(notices or [])
+    real_runs: dict[str, dict] = {}
+    failed = None                                     # (unit, run, last stop): the train that broke down
+    for chain in day.chains:
+        u_runs: list[Run] = []
+        at, ready, after = None, None, None
+        last_hist: Service | None = None
+        for rid in chain:
+            r0 = day.runs[rid]
+            svc = day.services[rid]
+            sched_dep = r0.dep[0]
+            if sched_dep < start - lookback:          # long before the window: history
+                last_hist = svc
+                at, ready = r0.dest, None
+                aa, _, cxl = _actual(svc, r0.dest)
+                if aa is not None and not cxl:
+                    ready = aa + turn
+                continue
+            if last_hist is not None:
+                if last_hist.full_cxl or last_hist.part_cxl:
+                    why.append(f"{last_hist.train} (before the window) was cut short: its train is not where the "
+                               f"schedule says")
+                    return None
+                last_hist = None
+            if sched_dep >= end:
+                after = {"run": rid, "station": r0.origin, "dep": sched_dep, "stops": r0.n_stops}
+                break
+            if svc.full_cxl or svc.part_cxl:
+                served = _served_in_record(svc)
+                cut_before = [c for c in r0.route if r0.stops[r0.route.index(c)] and c not in served]
+                early = [c for c in cut_before if (r0.arr[r0.idx(c)] or r0.dep[r0.idx(c)]) < start]
+                if early:
+                    if failed is None and _is_failure(net, r0, served, closed):
+                        failed = (r0.unit, rid, served[-1] if served else r0.origin)
+                        u_runs = []
+                        break
+                    why.append(f"{rid} was cut short before the window ({', '.join(early)})")
+                    return None
+            r = Run(**{**r0.__dict__})
+            r.route, r.stops, r.arr, r.dep, r.seg = list(r0.route), list(r0.stops), list(r0.arr), list(r0.dep), list(r0.seg)
+            placed = _place(net, r, svc, start, closed)
+            if placed is None:
+                why.append(f"{rid}: a stop before the window was cancelled")
+                return None
+            if isinstance(placed, tuple) and placed[0] == "done":
+                at, ready = r.dest, max(start, placed[1] + turn)
+                continue
+            if isinstance(placed, tuple) and placed[0] == "future":
+                u_runs.append(r)
+            elif isinstance(placed, tuple):
+                fixed_to, fixed_arr, fixed_from, stuck = placed
+                if u_runs:                            # a later run of the same set cannot be running already
+                    why.append(f"{rid} is running but an earlier run of its set {r.unit} has not")
+                    return None
+                r.fixed_to, r.fixed_arr, r.fixed_from, r.stuck = fixed_to, fixed_arr, fixed_from, stuck
+                u_runs.append(r)
+                at, ready = None, None
+            real_runs[rid] = _real(r, svc, start)
+        if not u_runs or (failed and u_runs[0].unit == failed[0]):
+            continue
+        if u_runs[0].started:
+            at, ready = None, None
+        else:
+            if at is None:
+                at = u_runs[0].origin
+            ready = start if ready is None else max(start, ready)
+        units.append(Unit(id=u_runs[0].unit, runs=[r.id for r in u_runs], at=at, ready=ready, after=after))
+        runs += u_runs
+    if not runs:
+        why.append("no runs")
+        return None
+    if failed:
+        c = closed[0]
+        notes.insert(0, f"Train {failed[1]} broke down after {failed[2]} and is stuck in {c.where[0]}-{c.where[-1]}; "
+                        f"its train set is out of service for the rest of the window, so its later runs are already "
+                        f"cancelled and are not yours to plan.")
+    task = Task(task_id=task_id or f"{date}-{hhmm(start).replace(':', '')}", split=split, line="GN-LW", day=date,
+                start=start, end=end, network=net.to_dict(), runs=runs, units=units, closures=closures, notices=notes,
+                disruptions=list(disruptions or []), difficulty=difficulty, reference={}, rules=rules)
+    # the plain timetable (no delays, no closures) must be conflict-free in the window
+    calm = Task.from_dict({**task.to_dict(), "closures": []})
+    for r in calm.runs:
+        r.fixed_to, r.fixed_arr, r.fixed_from, r.stuck = 0, None, None, False
+    for u in calm.units:
+        first = calm.run(u.runs[0])
+        u.at, u.ready = first.origin, None
+    calm_res = evaluate(calm, {})
+    if not calm_res.feasible:
+        why.append("the plain timetable conflicts in the window: " + calm_res.violations[0]["detail"][:160])
+        return None
+    task.reference["real"] = _real_cost(task, real_runs)
+    return task
+
+
+def _real(r: Run, svc: Service, start: int) -> dict:
+    """What really happened to a run: actual arrivals at the stops it served, and the stops it did not."""
+    arr, unserved = {}, 0
+    for i, code in enumerate(r.route):
+        if not r.stops[i]:
+            continue
+        aa, ad, cxl = _actual(svc, code)
+        if cxl:
+            unserved += 1
+        elif i > 0 and aa is not None:
+            arr[code] = aa
+    return {"arr": arr, "unserved": unserved, "cancelled": svc.full_cxl, "short": svc.part_cxl and not svc.full_cxl}
+
+
+def _real_cost(task: Task, real_runs: dict[str, dict]) -> dict:
+    """The record's outcome scored with the task's cost (delays at served stops reached after `start`, cancel cost
+    for unserved stops). It is what Arriva and ProRail did with their information; it need not obey this model."""
+    delay = unserved = cxl = short = 0
+    for r in task.runs:
+        x = real_runs.get(r.id)
+        if x is None:
+            continue
+        for i, code in enumerate(r.route):
+            if r.stops[i] and code in x["arr"] and x["arr"][code] >= task.start and r.arr[i] is not None:
+                delay += max(0, x["arr"][code] - r.arr[i])
+        unserved += x["unserved"]
+        cxl += bool(x["cancelled"])
+        short += bool(x["short"])
+    return {"cost": delay + task.rule("cancel_cost") * unserved, "delay": delay, "unserved_stops": unserved,
+            "cancelled": cxl, "short_turned": short}

core/rail_core/hardness.py

@@ -0,0 +1,59 @@
+"""Hardness features of a task: model-independent properties that predict how badly an agent will do on it.
+
+They come from the task and its reference only (no language model), so an eval set can be chosen by them without
+ever looking at a model's results on the eval tasks themselves (see `select`).
+
+    runs, sets            problem size
+    conflicts             rule breaks if nothing is changed (single track, headway, platforms, closures)
+    decisions             holds + short-turns + cancellations in the proven optimum: how much must change
+    turn_points           distinct points where the optimum short-turns trains
+    avoidable             optimum - floor: what good sequencing saves over the train sets planned alone
+    greedy_gap            how far the best greedy dispatcher is from the optimum, in reward
+    closed_min, slow_min, track_min   minutes of each kind of disruption inside the window
+    single_closed         a closure on single track (no way round it)
+    mid_line              a closure with turn points on both sides (trains must be turned at both ends of it)
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+
+from .check import evaluate, network
+from .model import Task, plan_from_list
+
+
+def features(task: Task) -> dict:
+    net = network(task)
+    ref = task.reference
+    naive = evaluate(task, {})
+    rules = Counter(v["rule"] for v in naive.violations)
+    opt = ref.get("optimal_plan") or []
+    holds = sum(len(e.get("hold") or {}) for e in opt)
+    shorts = sum(1 for e in opt if ("to" in e or "from" in e) and not e.get("cancel"))
+    cancels = sum(1 for e in opt if e.get("cancel"))
+    turn_pts = {e.get("to") for e in opt if e.get("to")} | {e.get("from") for e in opt if e.get("from")}
+    clip = lambda c: max(0, min(c.end, task.end) - max(c.start, task.start))
+    single_closed = mid_line = False
+    for c in task.closures:
+        if c.kind != "closed":
+            continue
+        lo, hi = sorted((net.index[c.where[0]], net.index[c.where[-1]]))
+        if any(net.sections[k].single for k in range(lo, hi)):
+            single_closed = True
+        west = any(p.turn for p in net.points[:lo + 1])
+        east = any(p.turn for p in net.points[hi:])
+        if lo > 0 and hi < len(net.points) - 1 and west and east:
+            mid_line = True
+    greedy = max(ref.get("greedy_reward", 0.0), ref.get("greedy_fast_reward", 0.0))
+    return {
+        "runs": len(task.runs), "sets": len(task.units), "stops": sum(r.n_stops for r in task.runs),
+        "conflicts": len(naive.violations), "single_track": rules.get("single_track", 0),
+        "headway": rules.get("headway", 0), "platforms": rules.get("platforms", 0), "closed": rules.get("closed", 0),
+        "decisions": holds + shorts + cancels, "holds": holds, "short_turns": shorts, "cancels": cancels,
+        "turn_points": len(turn_pts), "avoidable": ref.get("optimal_cost", 0) - ref.get("floor_cost", 0),
+        "optimal": ref.get("optimal_cost", 0), "greedy_gap": round(1.0 - greedy, 4),
+        "closed_min": sum(clip(c) for c in task.closures if c.kind == "closed"),
+        "slow_min": sum(clip(c) for c in task.closures if c.kind == "slow"),
+        "track_min": sum(clip(c) for c in task.closures if c.kind == "track"),
+        "single_closed": single_closed, "mid_line": mid_line, "late_sets": sum("is held for" in n for n in task.notices),
+    }

core/rail_core/model.py

@@ -0,0 +1,307 @@
+"""Tasks and plans.
+
+A task is a window of one real 2025 day on the Groningen - Leeuwarden line after something went wrong. The agent is
+the dispatcher: every train (a *run* from one end of the line to the other) runs by default exactly as scheduled and
+as early as the physics allow (never ahead of its timetable). The plan says only what to change:
+
+    hold     keep a train at a station until a minute (to let an opposing train through a single-track section,
+             or to wait for a section to reopen)
+    to       short-turn: end the run early at a turn point, so the same train can start back from there
+    from     start a run late at a turn point (where its train was short-turned)
+    cancel   do not run it at all (its train stays where it is)
+
+The physics, given a plan, are deterministic (`check.simulate`): a train leaves each point at the latest of when it
+is ready, its scheduled departure (never early at a scheduled stop) and its hold; it runs at its minimum running
+time. A train held where it has no scheduled stop loses `stop_loss` minutes braking and `stop_loss` accelerating.
+Whether the result is legal (single-track and headway conflicts, platform tracks, closed sections, where each train
+ends up) is `check.evaluate`.
+
+Times are whole minutes after 00:00 of the service day (00:30 the next night is 24:30, minute 1470); plans may give
+them as integers or "HH:MM".
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+RULES = {
+    "h_follow": 3,       # minutes between two trains going the same way, at both ends of a section
+    "h_opp": 0,          # minutes after a train leaves a single-track section before an opposing train may enter it
+                         # (0: in the same minute, as the timetable's crossings are planned)
+    "turn_min": 4,       # minutes for a train to turn back (driver changes ends)
+    "stop_loss": 1,      # minutes lost braking, and again accelerating, at a stop that is not in the timetable
+    "cancel_cost": 30,   # per scheduled stop a train does not serve (the next train of its kind is 30 minutes later)
+    "max_delay": 120,    # no train may reach a stop more than this many minutes late
+    "gap_k": 100,        # reward: added to the avoidable cost (about three unserved stops)
+}
+
+
+@dataclass
+class Run:
+    """One scheduled train from one end of its route to the other."""
+    id: str                       # train number
+    kind: str                     # stop (Stoptrein: every station) | fast (Sneltrein)
+    route: list[str]              # every point from origin to destination in travel order, junctions included
+    stops: list[bool]             # scheduled stop at route[i]
+    arr: list[int | None]         # scheduled arrival at a stop, the timetable's passing minute elsewhere; None at origin
+    dep: list[int | None]         # scheduled departure at a stop, the passing minute elsewhere; None at destination
+    seg: list[int]                # minimum running minutes route[i] -> route[i + 1] for this train's stopping pattern
+    unit: str                     # the train (rolling-stock unit) that runs it
+    fixed_to: int = 0             # in progress: route index of the point it is at or approaching when the task starts
+    fixed_arr: int | None = None  # in progress: its arrival there (cannot change)
+    fixed_from: int | None = None # in progress and between points: the minute it left route[fixed_to - 1]
+    stuck: bool = False           # in progress inside a section that closed: it waits there for the reopening
+
+    @property
+    def origin(self) -> str:
+        return self.route[0]
+
+    @property
+    def dest(self) -> str:
+        return self.route[-1]
+
+    @property
+    def started(self) -> bool:
+        return self.fixed_arr is not None
+
+    @property
+    def n_stops(self) -> int:
+        return sum(self.stops)
+
+    def idx(self, code: str) -> int:
+        return self.route.index(code)
+
+
+@dataclass
+class Unit:
+    """A train set and the runs it works through the window, in order."""
+    id: str
+    runs: list[str]
+    at: str | None                # where it stands before its first run (None: its first run is already moving)
+    ready: int | None             # when it may leave `at`
+    after: dict | None = None     # its first run after the window: {"run", "station", "dep", "stops"}
+
+
+@dataclass
+class Closure:
+    kind: str                     # closed (no train may be in the sections) | slow (+extra minutes) | track (one
+                                  # platform track out of use at a station)
+    where: list[str]              # closed/slow: [a, b], every section between points a and b; track: [station]
+    start: int
+    end: int                      # exclusive
+    extra: int = 0
+    cause: str = ""
+    real: bool = False            # from the 2025 disruption record (else generated)
+
+
+@dataclass
+class Task:
+    task_id: str
+    split: str
+    line: str
+    day: str
+    start: int                    # "now": the minute the agent takes over
+    end: int                      # runs leaving their origin before this minute are in the task
+    network: dict
+    runs: list[Run]
+    units: list[Unit]
+    closures: list[Closure]
+    notices: list[str]
+    disruptions: list[dict]
+    difficulty: str
+    reference: dict = field(default_factory=dict)   # optimum, floor, baselines, the real outcome: never shown
+    rules: dict = field(default_factory=lambda: dict(RULES))
+
+    def to_dict(self, public: bool = False) -> dict:
+        d = asdict(self)
+        if public:
+            d.pop("reference")
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "Task":
+        d = dict(d)
+        d["runs"] = [Run(**r) for r in d["runs"]]
+        d["units"] = [Unit(**u) for u in d["units"]]
+        d["closures"] = [Closure(**c) for c in d["closures"]]
+        d.setdefault("reference", {})
+        d["rules"] = {**RULES, **(d.get("rules") or {})}
+        return cls(**d)
+
+    def run(self, rid: str) -> Run:
+        return self.run_map[rid]
+
+    @property
+    def run_map(self) -> dict[str, Run]:
+        m = self.__dict__.get("_run_map")
+        if m is None:
+            m = self.__dict__["_run_map"] = {r.id: r for r in self.runs}
+        return m
+
+    def rule(self, k: str) -> int:
+        return int(self.rules.get(k, RULES[k]))
+
+
+# ---------------------------------------------------------------- plans
+
+@dataclass
+class Order:
+    """What the plan changes for one run (absent from the plan: runs in full, as early as possible)."""
+    cancel: bool = False
+    start: str | None = None      # "from": start at this turn point instead of the origin
+    end: str | None = None        # "to": end at this turn point instead of the destination
+    hold: dict[str, int] = field(default_factory=dict)   # point -> do not leave before this minute
+
+    def to_json(self, rid: str) -> dict:
+        d: dict[str, Any] = {"train": rid}
+        if self.cancel:
+            d["cancel"] = True
+            return d
+        if self.start:
+            d["from"] = self.start
+        if self.end:
+            d["to"] = self.end
+        if self.hold:
+            d["hold"] = {k: hhmm(v) for k, v in self.hold.items()}
+        return d
+
+
+Plan = dict[str, Order]
+
+
+class PlanError(ValueError):
+    """The plan cannot be read at all."""
+
+
+def hhmm(m: int | None) -> str | None:
+    if m is None:
+        return None
+    return f"{m // 60:02d}:{m % 60:02d}"
+
+
+_TIME = re.compile(r"^\s*(\d{1,2}):(\d{2})\s*$")
+
+
+def parse_time(v: Any) -> int:
+    if isinstance(v, bool):
+        raise ValueError(f"not a time: {v!r}")
+    if isinstance(v, int):
+        m = v
+    elif isinstance(v, float):
+        if v != v or v in (float("inf"), float("-inf")) or v != int(v):
+            raise ValueError(f"not a whole minute: {v!r}")
+        m = int(v)
+    elif isinstance(v, str):
+        s = v.strip()
+        if re.fullmatch(r"-?\d+", s):
+            m = int(s)
+        else:
+            g = _TIME.match(s)
+            if not g:
+                raise ValueError(f'not a time: {v!r} (use "HH:MM" or minutes after midnight)')
+            h, mi = int(g.group(1)), int(g.group(2))
+            if mi > 59:
+                raise ValueError(f"not a time: {v!r}")
+            m = h * 60 + mi
+    else:
+        raise ValueError(f"not a time: {v!r}")
+    if not 0 <= m <= 48 * 60:
+        raise ValueError(f"time out of range: {v!r}")
+    return m
+
+
+def _load(raw: Any) -> Any:
+    if isinstance(raw, str):
+        s = raw.strip()
+        fence = re.search(r"```(?:json)?\s*(.*?)```", s, re.S)
+        if fence:
+            s = fence.group(1).strip()
+        if not s.startswith(("[", "{")):
+            i = min([k for k in (s.find("["), s.find("{")) if k >= 0], default=-1)
+            if i < 0:
+                raise PlanError("the plan is not JSON: give a list like "
+                                '[{"train": "37413", "hold": {"HDG": "07:31"}}, {"train": "37324", "cancel": true}]')
+            s = s[i:]
+        try:
+            raw, _ = json.JSONDecoder().raw_decode(s)
+        except json.JSONDecodeError as e:
+            raise PlanError(f"the plan is not valid JSON: {e}") from None
+    if isinstance(raw, dict):
+        if "plan" in raw and isinstance(raw["plan"], (list, dict)):
+            return _load(raw["plan"])
+        # {"37413": {...}, ...}
+        raw = [{"train": k, **(v if isinstance(v, dict) else {"cancel": v} if isinstance(v, bool) else {"bad": v})}
+               for k, v in raw.items()]
+    if not isinstance(raw, list):
+        raise PlanError("the plan must be a list of entries, one per train you change")
+    return raw
+
+
+def parse_plan(task: Task, raw: Any) -> tuple[Plan, list[str]]:
+    """(plan, entry problems). Raises PlanError only when nothing can be read. An empty list is a valid plan:
+    every train runs in full, as early as it can."""
+    entries = _load(raw)
+    runs = task.run_map
+    plan: Plan = {}
+    problems: list[str] = []
+    for n, e in enumerate(entries):
+        if not isinstance(e, dict):
+            problems.append(f"entry {n}: not an object")
+            continue
+        rid = e.get("train", e.get("run", e.get("id")))
+        if isinstance(rid, bool) or rid is None:
+            problems.append(f"entry {n}: no train number")
+            continue
+        rid = str(rid).strip()
+        if rid not in runs:
+            problems.append(f"entry {n}: unknown train {rid!r}")
+            continue
+        if rid in plan:
+            problems.append(f"entry {n}: train {rid} appears twice")
+            continue
+        r = runs[rid]
+        o = Order()
+        unknown = set(e) - {"train", "run", "id", "cancel", "from", "start", "to", "end", "hold", "note", "reason"}
+        if unknown:
+            problems.append(f"train {rid}: unknown field(s) {sorted(unknown)}")
+        c = e.get("cancel", False)
+        if c not in (True, False, None):
+            problems.append(f"train {rid}: cancel must be true or false")
+        o.cancel = c is True
+        for key, alt, attr in (("from", "start", "start"), ("to", "end", "end")):
+            v = e.get(key, e.get(alt))
+            if v is None:
+                continue
+            if not isinstance(v, str) or v.strip().upper() not in r.route:
+                problems.append(f"train {rid}: {key} {v!r} is not on its route {'-'.join(r.route)}")
+                continue
+            setattr(o, attr, v.strip().upper())
+        h = e.get("hold") or {}
+        if not isinstance(h, dict):
+            problems.append(f'train {rid}: hold must be an object like {{"HDG": "07:31"}}')
+            h = {}
+        for k, v in h.items():
+            code = str(k).strip().upper()
+            if code not in r.route:
+                problems.append(f"train {rid}: hold at {k!r}, which is not on its route")
+                continue
+            try:
+                o.hold[code] = parse_time(v)
+            except ValueError as ex:
+                problems.append(f"train {rid}: hold at {code}: {ex}")
+        plan[rid] = o
+    return plan, problems
+
+
+def plan_to_list(plan: Plan) -> list[dict]:
+    return [o.to_json(rid) for rid, o in plan.items()]
+
+
+def plan_from_list(task: Task, entries: list[dict]) -> Plan:
+    plan, problems = parse_plan(task, entries)
+    if problems:
+        raise PlanError("; ".join(problems))
+    return plan

core/rail_core/network.py

@@ -0,0 +1,80 @@
+"""The line: points west to east (terminals, stations, halts, junctions) and the sections between them.
+
+A section joins two neighbouring points and is single or double track. A point has a number of tracks (None: as many
+as needed, the terminals), may be *directional* (a station on double track: one track per direction, so two trains
+going the same way cannot both stand there and nothing overtakes), and may be a *turn* point where a train can be
+short-turned. Junctions are where double track becomes single between two stations; trains pass them but never stop.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+DATA = Path(__file__).resolve().parents[4] / "data"
+
+
+@dataclass
+class Point:
+    code: str
+    name: str
+    km: float
+    kind: str              # terminal | station | halt | junction
+    tracks: int | None     # None: unlimited (terminal)
+    directional: bool      # one track per direction (station on double track)
+    turn: bool             # trains may be short-turned here
+
+    @property
+    def stoppable(self) -> bool:
+        return self.kind != "junction"
+
+
+@dataclass
+class Section:
+    a: str                 # west end
+    b: str                 # east end
+    single: bool
+    prorail: str = ""
+
+
+class Network:
+    def __init__(self, points: list[Point], sections: list[Section], line: str = "", name: str = ""):
+        self.line, self.name = line, name
+        self.points = points
+        self.sections = sections
+        self.index = {p.code: i for i, p in enumerate(points)}
+        self.by_code = {p.code: p for p in points}
+        for i, s in enumerate(sections):
+            if (self.index[s.a], self.index[s.b]) != (i, i + 1):
+                raise ValueError(f"section {s.a}-{s.b} is not between neighbouring points {i} and {i + 1}")
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "Network":
+        return cls([Point(**p) for p in d["points"]], [Section(**s) for s in d["sections"]], d.get("line", ""),
+                   d.get("name", ""))
+
+    def to_dict(self) -> dict:
+        return {"line": self.line, "name": self.name, "points": [asdict(p) for p in self.points],
+                "sections": [asdict(s) for s in self.sections]}
+
+    def section(self, x: str, y: str) -> int:
+        """Index of the section between neighbouring points x and y (either order)."""
+        i, j = self.index[x], self.index[y]
+        if abs(i - j) != 1:
+            raise ValueError(f"{x} and {y} are not neighbours")
+        return min(i, j)
+
+    def route(self, a: str, b: str) -> list[str]:
+        """Every point from a to b inclusive, in travel order."""
+        i, j = self.index[a], self.index[b]
+        step = 1 if j >= i else -1
+        return [self.points[k].code for k in range(i, j + step, step)]
+
+    def direction(self, a: str, b: str) -> int:
+        """+1 eastbound (towards the last point), -1 westbound."""
+        return 1 if self.index[b] > self.index[a] else -1
+
+
+def load_network(line: str = "gnlw") -> Network:
+    return Network.from_dict(json.loads((DATA / line / "network.json").read_text()))

core/rail_core/ops.py

@@ -0,0 +1,160 @@
+"""Disruptions and tiers: what can go wrong on the line, from the 2025 record, and how tasks are drawn.
+
+A disruption in the Rijden de Treinen record has a cause, a start, an end and the stations it was linked to. Its
+effect in the model depends on the cause (an assumption, stated in SOURCE.md):
+
+    broken down train, collision, emergency call, defective track, person or animal on the track, power failure
+        -> the sections between the outermost stations named are closed for the whole disruption
+    signal failure, level crossing failure
+        -> trains run on sight there: every section in the span takes `SLOW_EXTRA` minutes longer
+    points failure
+        -> one track out of use at the passing station(s) in the span (no crossing there if it had two)
+
+A disruption linked to every station of the line has no usable location; such causes are replayed on a section
+drawn with the task's seed.
+"""
+
+from __future__ import annotations
+
+import random
+
+from .model import Closure
+from .network import Network
+
+SLOW_EXTRA = 4
+CLOSE = ("broken down", "collision", "emergency", "defective railway track", "person", "animal", "power failure",
+         "damaged", "fire", "accident", "vandalism", "copper theft")
+SLOW = ("signal", "level crossing")
+POINTS = ("points",)
+LOOPS = ("HDG", "FWD", "BP", "ZH")
+
+
+def effect(cause: str) -> str:
+    c = cause.lower()
+    if any(k in c for k in POINTS) and not any(k in c for k in SLOW):
+        return "track"
+    if any(k in c for k in SLOW):
+        return "slow"
+    return "closed"
+
+
+def span(net: Network, codes: list[str]) -> list[str] | None:
+    """[west, east] of the stations named, or None when the record names (nearly) the whole line."""
+    idx = sorted(net.index[c] for c in codes if c in net.index)
+    if len(idx) < 2 or (idx[0] == 0 and idx[-1] == len(net.points) - 1 and len(idx) >= 8):
+        return None
+    return [net.points[idx[0]].code, net.points[idx[-1]].code]
+
+
+def closures_for(net: Network, cause: str, codes: list[str], start: int, end: int, rng: random.Random,
+                 real: bool = True) -> list[Closure]:
+    kind = effect(cause)
+    where = span(net, codes)
+    if where is None:                      # no location in the record: draw one
+        where = _draw_span(net, kind, rng)
+    if kind == "track":
+        lo, hi = net.index[where[0]], net.index[where[-1]]
+        loops = [p.code for p in net.points[lo:hi + 1] if p.code in LOOPS] or [rng.choice(LOOPS)]
+        return [Closure("track", [c], start, end, cause=cause, real=real) for c in loops[:1]]
+    if kind == "slow":
+        return [Closure("slow", where, start, end, extra=SLOW_EXTRA, cause=cause, real=real)]
+    return [Closure("closed", where, start, end, cause=cause, real=real)]
+
+
+def _draw_span(net: Network, kind: str, rng: random.Random) -> list[str]:
+    stations = [p.code for p in net.points if p.kind != "junction"]
+    if kind == "track":
+        c = rng.choice(LOOPS)
+        return [c, c]
+    i = rng.randrange(len(stations) - 1)
+    j = min(len(stations) - 1, i + rng.choice((1, 1, 2)))
+    return [stations[i], stations[j]]
+
+
+# ---------------------------------------------------------------- tiers and candidates
+
+import csv
+from datetime import date as _date
+from functools import lru_cache
+
+from .data import LINE_DIR, days as _days, disruptions as _real_disruptions
+from .model import hhmm
+
+# Eval days lie in these ISO weeks of 2025 (42 days); train days are every other day of January-June.
+HELD_OUT = {4, 7, 11, 17, 22, 25}
+PEAKS = [(6 * 60 + 30, 9 * 60), (15 * 60 + 30, 18 * 60 + 30)]
+LATE_CAUSES = ("a technical inspection", "a late driver", "a door fault being fixed", "a cleaning crew overrun",
+               "coupling problems")
+
+TIERS = {
+    # window minutes; what is seeded (each disruption's cause and duration drawn from the 2024-2025 record)
+    "real":     dict(window=(150, 210)),                       # the record's own disruption, on its own day
+    "blockage": dict(window=(150, 210), closed=1, late=(0, 1)),
+    "loop":     dict(window=(150, 210), track=1, slow=(0, 1), late=(0, 1)),
+    "compound": dict(window=(180, 240), closed=1, track=(0, 1), slow=(0, 1), late=(1, 3)),
+}
+
+
+def split_of(day: str) -> str:
+    return "eval" if _date.fromisoformat(day).isocalendar()[1] in HELD_OUT else "train"
+
+
+def split_days(split: str) -> list[str]:
+    return [d for d in _days() if split_of(d) == split]
+
+
+@lru_cache(maxsize=1)
+def profiles() -> list[dict]:
+    with open(LINE_DIR / "disruption_profiles.csv", encoding="utf-8") as f:
+        rows = [r for r in csv.DictReader(f) if r["duration_minutes"]]
+    for r in rows:
+        r["effect"] = effect(r["cause_en"])
+        r["minutes"] = max(10, min(240, round(float(r["duration_minutes"]))))
+    return rows
+
+
+def real_disruptions(split: str | None = None) -> list[dict]:
+    """The record's own disruptions on the line, as (day, start, end, cause, stations)."""
+    out = []
+    for d in _real_disruptions():
+        day = d["start_time"][:10]
+        if split and split_of(day) != split:
+            continue
+        hh, mm = int(d["start_time"][11:13]), int(d["start_time"][14:16])
+        start = hh * 60 + mm
+        dur = round(float(d["duration_minutes"] or 0))
+        if dur < 15 or not 5 * 60 <= start <= 22 * 60:
+            continue
+        out.append({"day": day, "start": start, "end": start + dur, "cause": d["cause_en"],
+                    "stations": [c.strip() for c in d["rdt_station_codes"].split(",")]})
+    return out
+
+
+def draw(rng: random.Random, kind: str) -> dict:
+    pool = [p for p in profiles() if p["effect"] == kind] or profiles()
+    return rng.choice(pool)
+
+
+def seeded_closures(net: Network, tier: str, start: int, window: int, rng: random.Random) -> tuple[list, list[str]]:
+    """Closures for a seeded tier, starting within the first half hour of the window."""
+    r = TIERS[tier]
+    out: list[Closure] = []
+
+    def count(key):
+        v = r.get(key, 0)
+        return rng.randint(*v) if isinstance(v, tuple) else v
+
+    for kind, key in (("closed", "closed"), ("track", "track"), ("slow", "slow")):
+        for _ in range(count(key)):
+            p = draw(rng, kind)
+            t0 = start + rng.choice((0, 0, 5, 10, 20, 30))
+            minutes = min(p["minutes"], window - 20) if kind == "closed" else p["minutes"]
+            codes = [c.strip() for c in p["rdt_station_codes"].split(",")]
+            where = span(net, codes) or _draw_span(net, kind, rng)
+            out += closures_for(net, p["cause_en"], where, t0, t0 + minutes, rng, real=False)
+    notes = []
+    return out, notes
+
+
+def candidate_id(day: str, start: int, window: int, tier: str, seed: int) -> str:
+    return f"gnlw-{day}-{hhmm(start).replace(':', '')}-{window}m-{tier}-{seed}"

core/rail_core/pack.py

@@ -0,0 +1,100 @@
+"""Task packs: directories of tasks (tasks.jsonl or tasks.jsonl.gz, with their reference plans) plus a manifest.
+
+The server serves several packs at once; splits come from each task's `split` field. By default those are the
+rail-v1 eval and train packs.
+
+    RAIL_TASKS_DIR=/path/a:/path/b     colon-separated pack directories
+"""
+
+from __future__ import annotations
+
+import gzip
+import hashlib
+import json
+import os
+from pathlib import Path
+
+from .model import Task
+
+TASKS_ROOT = Path(__file__).resolve().parents[2] / "tasks"
+DEFAULT_PACKS = ["rail-v1-eval", "rail-v1-train"]
+
+
+def default_roots() -> list[Path]:
+    env = os.environ.get("RAIL_TASKS_DIR", "").strip()
+    if env:
+        return [Path(p) for p in env.split(":") if p]
+    return [TASKS_ROOT / p for p in DEFAULT_PACKS if _tasks_file(TASKS_ROOT / p)]
+
+
+def _tasks_file(root: Path) -> Path | None:
+    for name in ("tasks.jsonl", "tasks.jsonl.gz"):
+        if (root / name).is_file():
+            return root / name
+    return None
+
+
+def _read(root: Path) -> tuple[list[Task], dict]:
+    path = _tasks_file(root)
+    if path is None:
+        raise FileNotFoundError(f"no tasks.jsonl(.gz) in {root}")
+    raw = path.read_bytes()
+    body = gzip.decompress(raw) if path.suffix == ".gz" else raw
+    manifest = json.loads((root / "manifest.json").read_text()) if (root / "manifest.json").is_file() else {}
+    digest = hashlib.sha256(body).hexdigest()
+    if manifest.get("sha256") and manifest["sha256"] != digest:
+        raise ValueError(f"{path} does not match its manifest.json (sha256 {digest[:12]} != {manifest['sha256'][:12]})")
+    return [Task.from_dict(json.loads(line)) for line in body.decode().splitlines() if line.strip()], manifest
+
+
+class TaskPack:
+    def __init__(self, roots: Path | str | list[Path | str] | None = None):
+        if roots is None:
+            roots = default_roots()
+        if isinstance(roots, (str, Path)):
+            roots = [roots]
+        self.roots = [Path(r) for r in roots]
+        if not self.roots:
+            raise FileNotFoundError(f"no task packs found under {TASKS_ROOT}; set RAIL_TASKS_DIR")
+        self.tasks: list[Task] = []
+        self.manifests: dict[str, dict] = {}
+        for r in self.roots:
+            tasks, manifest = _read(r)
+            self.tasks += tasks
+            self.manifests[r.name] = manifest
+        self._by_id: dict[str, Task] = {}
+        for t in self.tasks:
+            if t.task_id in self._by_id:
+                raise ValueError(f"task id {t.task_id} appears in more than one pack")
+            self._by_id[t.task_id] = t
+        self._by_split: dict[str, list[Task]] = {}
+        for t in self.tasks:
+            self._by_split.setdefault(t.split, []).append(t)
+
+    def splits(self) -> list[str]:
+        return sorted(self._by_split)
+
+    def count(self, split: str) -> int:
+        return len(self._by_split.get(split, []))
+
+    def at(self, split: str, index: int) -> Task:
+        return self._by_split[split][index]
+
+    def get(self, task_id: str) -> Task:
+        return self._by_id[task_id]
+
+    def public(self, task: Task) -> dict:
+        """What anyone may see: everything but the reference plans and costs."""
+        return task.to_dict(public=True)
+
+
+_PACK: TaskPack | None = None
+
+
+def load_pack(root: Path | str | list | None = None) -> TaskPack:
+    global _PACK
+    if root is not None:
+        return TaskPack(root)
+    if _PACK is None:
+        _PACK = TaskPack()
+    return _PACK

core/rail_core/prompts.py

@@ -0,0 +1,192 @@
+"""What the agent reads: `rules(task)` is the system prompt, `situation(task)` what get_situation returns.
+
+Both are rendered at runtime from the task, so changing them never needs a pack rebuild.
+"""
+
+from __future__ import annotations
+
+from .check import network
+from .model import Run, Task, hhmm
+
+PROMPT_VERSION = "rail-v1.0"
+KIND_NAME = {"stop": "Stoptrein (stopping)", "fast": "Sneltrein (fast)"}
+
+
+def rules(task: Task, max_checks: int = 10) -> str:
+    R = task.rules
+    net = network(task)
+    turns = ", ".join(p.code for p in net.points if p.turn)
+    return f"""You are the train dispatcher (treindienstleider) for Arriva's line between Leeuwarden and Groningen in the \
+Netherlands, on a real day in 2025. Long stretches of the line are single track: trains going opposite ways can only \
+pass each other at stations with two tracks or on the double-track parts. Something has gone wrong and you must re-plan \
+the trains for the rest of the window. Everything you need is in the situation; it is the whole truth (no surprises \
+later).
+
+How trains move (the physics; deterministic):
+- Every train set works its runs in the order listed. A run starts where its train set is, no earlier than when the set \
+is ready there and never before its scheduled departure.
+- Unless your plan says otherwise, a train runs at its minimum running times and leaves as soon as it can, but it never \
+leaves a scheduled stop before its scheduled departure and never reaches any point before its timetable minute there \
+(the passing minutes marked * included): arrival at the next point = max(departure + running time, timetable minute). \
+A late train makes up time this way.
+- A train held where it has no scheduled stop (a fast train at a station it normally passes) loses \
+{R['stop_loss']} minute braking and {R['stop_loss']} minute accelerating. Trains cannot be held at junctions (J1, J2).
+- After a run ends, its train set is ready {R['turn_min']} minutes after arriving, at the point where the run ended.
+
+Rules (a plan that breaks any of them is infeasible):
+1. Single track: two trains going opposite ways may never be in a single-track section at the same time: the second \
+may enter only when the first has left it (arrived at the far end){' - in that same minute at the earliest' if not R['h_opp'] else f" - {R['h_opp']} minute(s) later at the earliest"}. \
+A train is in a section from its departure at one end to its arrival at the other.
+2. Headway: trains going the same way stay at least {R['h_follow']} minutes apart at both ends of every section, so a \
+train can only overtake another at a station where both fit.
+3. Platforms: never more trains standing at (or passing through) a station than it has tracks. A directional station \
+(on double track) has one track each way. A train set waiting at a station between runs keeps a track there. \
+Terminals (LW, GN) have room for everyone.
+4. Closures: no train may be in a closed section while it is closed. A train stuck inside when it closed waits there.
+5. Continuity: a run can only start where its train set is. You may short-turn trains only at the turn points \
+({turns}). A train already running cannot be cancelled (short-turn it instead). At the end of the window every train \
+set must be where its next run (listed) leaves from.
+6. No train may reach a stop more than {R['max_delay']} minutes late.
+
+What you decide, per train (run), in the plan:
+- "hold": {{"HDG": "07:31"}} keeps it at that point until 07:31 (it leaves then, or later if it is not ready). Use \
+holds to make trains wait for each other or for a closure to end.
+- "to": "HDG" ends the run early at a turn point (short-turn); its train set is then at HDG, so its next run must \
+start there.
+- "from": "HDG" starts a run at a turn point instead of its origin (where its set was short-turned).
+- "cancel": true does not run it at all; its train set stays where it is (so usually its next run is cancelled too, \
+or starts from where the set is).
+Trains you leave out of the plan run in full, as early as they can. An empty plan [] changes nothing.
+
+Cost, in stop-minutes (lower is better): every minute a train reaches one of its scheduled stops late (arrival at each \
+stop it serves after where it starts), plus {R['cancel_cost']} for every scheduled stop a train does not serve \
+(cancelled or cut off by a short-turn: passengers wait for the next train), plus, for each train set, the minutes it is \
+late for its next run after the window times that run's number of stops.
+
+Tools:
+- get_situation(): the line, the closures, the trains and the train sets.
+- check_plan(plan): simulates your plan and returns every train's times, delay, the rule breaks and the cost. You \
+have {max_checks} checks. It never grades the plan.
+- submit_plan(plan): your final plan. It ends the episode and is graded once against the best possible plan (proved \
+by a solver). A plan that breaks a rule scores below 0.2; a plan that breaks none scores 0.2-1.0 by how close its cost \
+is to the best.
+
+Plan format, a JSON list with one entry per train you change, for example:
+[{{"train": "37413", "to": "HDG"}}, {{"train": "37424", "from": "HDG", "hold": {{"HDG": "07:31"}}}}, \
+{{"train": "37326", "hold": {{"FWD": "07:55", "BP": "08:05"}}}}, {{"train": "37419", "cancel": true}}]
+Times are "HH:MM" (after midnight: 24:10)."""
+
+
+def _line_diagram(task: Task) -> list[str]:
+    net = network(task)
+    parts = []
+    for i, p in enumerate(net.points):
+        if p.kind == "terminal":
+            tag = f"{p.code}[terminal]"
+        elif p.kind == "junction":
+            tag = f"{p.code}"
+        elif p.directional:
+            tag = f"{p.code}[1 each way]"
+        else:
+            tag = f"{p.code}[{p.tracks}{' turn' if p.turn else ''}]"
+        if p.turn and p.kind != "terminal" and "turn" not in tag:
+            tag = tag[:-1] + " turn]"
+        parts.append(tag)
+        if i < len(net.sections):
+            parts.append(" ---single--- " if net.sections[i].single else " ===double=== ")
+    lines = ["West to east (km from Leeuwarden in brackets):"]
+    lines.append("  " + ", ".join(f"{p.code} {p.name} ({p.km:g})" for p in net.points))
+    lines.append("  " + "".join(parts))
+    lines.append("  [n] = tracks at a station; [1 each way] = one track per direction (no overtaking); turn = trains "
+                 "can be short-turned there; J1, J2 = junctions where double track becomes single (no stopping).")
+    return lines
+
+
+def _pattern(r: Run) -> tuple:
+    return (r.kind, tuple(r.route), tuple(r.stops), tuple(r.seg))
+
+
+def situation(task: Task) -> str:
+    net = network(task)
+    out = [f"Groningen - Leeuwarden, {task.day}. It is now {hhmm(task.start)}. You plan every run that leaves "
+           f"before {hhmm(task.end)} (and those already running)."]
+    out.append("")
+    out.append("THE LINE")
+    out += _line_diagram(task)
+    out.append("")
+    out.append("WHAT HAS HAPPENED")
+    for n in task.notices:
+        out.append(f"- {n}")
+    for c in task.closures:
+        where = "-".join(c.where) if c.kind != "track" else c.where[0]
+        if c.kind == "closed":
+            out.append(f"- CLOSED: every section between {c.where[0]} and {c.where[-1]}, {hhmm(c.start)} to "
+                       f"{hhmm(c.end)} ({c.cause}).")
+        elif c.kind == "slow":
+            out.append(f"- SLOW: trains entering a section between {c.where[0]} and {c.where[-1]} from "
+                       f"{hhmm(c.start)} to {hhmm(c.end)} take {c.extra} minutes longer ({c.cause}).")
+        else:
+            out.append(f"- TRACK OUT OF USE: one track at {where} cannot be used {hhmm(c.start)} to {hhmm(c.end)} "
+                       f"({c.cause}).")
+    if not task.notices and not task.closures:
+        out.append("- Nothing beyond the delays below.")
+    out.append("")
+    out.append("MINIMUM RUNNING TIMES (minutes from each point to the next, for each stopping pattern)")
+    patterns: dict[tuple, list[str]] = {}
+    for r in task.runs:
+        patterns.setdefault(_pattern(r), []).append(r.id)
+    for k, (pat, ids) in enumerate(patterns.items()):
+        kind, route, stops, seg = pat
+        legs = " ".join(f"{route[i]}{'' if stops[i] else '*'} {seg[i]}" for i in range(len(seg))) + f" {route[-1]}"
+        out.append(f"P{k + 1} {KIND_NAME[kind]} {route[0]}->{route[-1]}: {legs}")
+    out.append("  (* = no scheduled stop there: the train passes; held there it loses "
+               f"{task.rule('stop_loss')}+{task.rule('stop_loss')} min)")
+    pid = {rid: f"P{k + 1}" for k, ids in enumerate(patterns.values()) for rid in ids}
+    out.append("")
+    out.append("TRAINS (timetable: arrival/departure at stops, passing minute at points marked *; the pattern gives the "
+               "running times)")
+    for r in sorted(task.runs, key=lambda r: (r.fixed_arr if r.started else r.dep[0])):
+        stops = []
+        for i, code in enumerate(r.route):
+            if not r.stops[i]:
+                stops.append(f"{code}* {hhmm(r.arr[i])}")
+                continue
+            a, d = r.arr[i], r.dep[i]
+            if a is None:
+                stops.append(f"{code} {hhmm(d)}")
+            elif d is None:
+                stops.append(f"{code} {hhmm(a)}")
+            elif a == d:
+                stops.append(f"{code} {hhmm(a)}")
+            else:
+                stops.append(f"{code} {hhmm(a)}/{hhmm(d)}")
+        head = f"{r.id} {r.kind} {r.origin}->{r.dest} [{pid[r.id]}, set {r.unit}]"
+        if r.started:
+            k = r.fixed_to
+            code = r.route[k]
+            sched = r.arr[k] if r.arr[k] is not None else r.dep[k]
+            late = r.fixed_arr - sched if sched is not None else 0
+            if r.fixed_arr <= task.start and r.stops[k]:
+                pos = f"standing at {code} since {hhmm(r.fixed_arr)}"
+            elif r.stuck:
+                pos = f"STUCK in the closed section before {code}; reaches {code} at {hhmm(r.fixed_arr)} at the earliest"
+            else:
+                pos = f"running, reaches {code} at {hhmm(r.fixed_arr)}"
+            head += f" RUNNING ({pos}; {late:+d} min on its timetable there)"
+        out.append(f"{head}: " + ", ".join(stops))
+    out.append("")
+    out.append("TRAIN SETS (each works its runs in this order)")
+    for u in task.units:
+        first = task.run(u.runs[0])
+        if first.started:
+            where = f"running {first.id}"
+        else:
+            where = f"at {u.at}, ready {hhmm(u.ready)}"
+        nxt = (f"; must then be at {u.after['station']} for {u.after['run']} at {hhmm(u.after['dep'])} "
+               f"({u.after['stops']} stops)") if u.after else "; no further runs today"
+        out.append(f"{u.id}: {where}; runs " + " -> ".join(u.runs) + nxt)
+    return "\n".join(out)
+
+
+def brief(task: Task) -> str:
+    return f"{task.task_id}: {len(task.runs)} runs, {len(task.units)} train sets, {len(task.closures)} closures"

core/rail_core/reference.py

@@ -0,0 +1,131 @@
+"""A task's reference: the proven optimum, the floor, the lazy policies' costs and rewards, and the real outcome.
+
+Nothing here is shown to the agent.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .baselines import POLICIES
+from .check import evaluate
+from .model import Task, plan_to_list
+from .reward import score
+from .solve import floor_parts, optimal_plan
+
+
+def add_reference(task: Task, time_limit: float = 90.0, workers: int = 4, extend: int = 2) -> dict:
+    hints = {}
+    for name in ("greedy", "greedy_fast"):
+        try:
+            hints[name] = POLICIES[name](task)
+        except Exception as e:        # a baseline that crashes is a bug, but must not stop a build
+            hints[name] = None
+            task.reference.setdefault("errors", []).append(f"{name}: {type(e).__name__}: {e}")
+    best_hint = None
+    for name, p in hints.items():
+        if p is None:
+            continue
+        r = evaluate(task, p)
+        if r.feasible and (best_hint is None or r.cost < best_hint[1]):
+            best_hint = (p, r.cost)
+    floor, parts = floor_parts(task)
+    sol = optimal_plan(task, time_limit=time_limit, workers=workers, hint=best_hint[0] if best_hint else None,
+                       unit_floor=parts)
+    if sol.plan is None:
+        raise ValueError(f"{task.task_id}: no feasible plan found ({sol.status})")
+    floor = min(floor, sol.bound)
+    # large windows: warm-start from the best plan and give the proof more time, while the gap is closable
+    limit, spent = time_limit, sol.seconds
+    for _ in range(extend):
+        gap = (sol.cost - sol.bound) / (sol.cost - floor + task.rule("gap_k"))
+        if sol.optimal or gap <= 0.01 or gap > 0.3:     # close enough to finish, or hopeless
+            break
+        limit *= 2
+        nxt = optimal_plan(task, time_limit=limit, workers=workers, hint=sol.plan, unit_floor=parts)
+        spent += nxt.seconds
+        if nxt.plan is not None and (nxt.cost, -nxt.bound) <= (sol.cost, -sol.bound):
+            sol = nxt
+        elif nxt.plan is not None:
+            sol = type(sol)(sol.plan, sol.cost, max(sol.bound, nxt.bound), sol.optimal, sol.status, sol.seconds)
+    floor = min(floor, sol.bound)
+    ref = task.reference
+    ref.update(optimal_cost=sol.cost, optimal_plan=plan_to_list(sol.plan), proven_optimal=sol.optimal,
+               lower_bound=sol.bound, floor_cost=floor, solver_seconds=round(spent, 1), solver=sol.status)
+    score_baselines(task, hints)
+    if "real" in ref:
+        rr = ref["real"]
+        rew, _ = score(rr["cost"], True, 1.0, sol.cost, floor, gap_k)
+        rr["reward_if_legal"] = round(rew, 4)
+    return ref
+
+
+def score_baselines(task: Task, hints: dict | None = None) -> None:
+    """The lazy policies' feasibility, cost, reward and rule breaks, against the stored optimum and floor."""
+    ref = task.reference
+    if hints is None:
+        hints = {}
+        for name in ("greedy", "greedy_fast"):
+            try:
+                hints[name] = POLICIES[name](task)
+            except Exception as e:
+                hints[name] = None
+                ref.setdefault("errors", []).append(f"{name}: {type(e).__name__}: {e}")
+    gap_k = task.rule("gap_k")
+    for name, p in [("naive", POLICIES["naive"](task))] + list(hints.items()):
+        if p is None:
+            ref[f"{name}_feasible"] = False
+            ref[f"{name}_reward"] = 0.0
+            continue
+        r = evaluate(task, p)
+        clean = sum(1 for x in r.runs if not x.problems) / max(1, len(r.runs))
+        rew, _ = score(r.cost, r.feasible, clean, ref["optimal_cost"], ref["floor_cost"], gap_k)
+        ref[f"{name}_feasible"] = r.feasible
+        ref[f"{name}_cost"] = r.cost
+        ref[f"{name}_reward"] = round(rew, 4)
+        ref[f"{name}_violations"] = len(r.violations)
+
+
+BASELINE_KEYS = [f"{n}_{k}" for n in ("naive", "greedy", "greedy_fast") for k in ("feasible", "cost", "reward",
+                                                                                     "violations")]
+
+
+def refresh_baselines(pack_dir: Path) -> list[str]:
+    """Re-score the lazy policies of every task in a pack (after a baseline fix), without re-solving. Rewrites the
+    pack only if something changed; returns the ids of the tasks that changed."""
+    import json
+
+    from .build import write_pack
+    from .hardness import features
+    from .pack import _read
+
+    tasks, manifest = _read(pack_dir)
+    raw = [t.to_dict() for t in tasks]
+    changed = []
+    for t, d in zip(tasks, raw):
+        before = {k: t.reference.get(k) for k in BASELINE_KEYS}
+        t.reference.pop("errors", None)
+        score_baselines(t)
+        if {k: t.reference.get(k) for k in BASELINE_KEYS} != before or "errors" in d["reference"]:
+            t.reference["hardness"] = features(t)
+            d["reference"] = t.reference
+            changed.append(t.task_id)
+    if changed:
+        log = [json.loads(x) for x in (pack_dir / "build_log.jsonl").read_text().splitlines()]
+        for st in log:
+            for t in tasks:
+                if st.get("task_id") == t.task_id and "hardness" in st:
+                    st["hardness"] = t.reference["hardness"]
+        std = {"name", "split", "tasks", "file", "tiers", "sha256", "candidates", "days", "proven_optimal", "runs",
+               "source"}
+        write_pack(pack_dir, raw, log, manifest["split"], {k: v for k, v in manifest.items() if k not in std})
+    return changed
+
+
+if __name__ == "__main__":
+    import argparse
+
+    ap = argparse.ArgumentParser(description="re-score the lazy policies stored in task packs")
+    ap.add_argument("packs", nargs="+")
+    for pack in ap.parse_args().packs:
+        print(pack, refresh_baselines(Path(pack)))

core/rail_core/replay.py

@@ -0,0 +1,109 @@
+"""What the map replay animates: every run's simulated times under a plan, the plan's orders, the cost as it accrues,
+the rule breaks and the moments worth marking on the timeline. Built from the same `simulate` and `evaluate` the
+grader uses, so the picture is the grade. For people (the `/twin/` viewer); no MCP tool returns it.
+
+Cost events add up to the grader's cost: a stop's delay when the train arrives there, 30 for a stop not served at
+the minute it was due, and each train set's lateness handed on to the next window at the window's end.
+"""
+
+from __future__ import annotations
+
+from .check import evaluate, network, simulate
+from .model import Order, Plan, Task, hhmm
+from .reward import score
+
+
+def _due(r, j: int) -> int | None:
+    return r.arr[j] if r.arr[j] is not None else r.dep[j]
+
+
+def replay(task: Task, plan: Plan, name: str = "", parse_problems: list[str] | None = None) -> dict:
+    net = network(task)
+    res = evaluate(task, plan)
+    _, _, _, _, carry = simulate(task, plan)
+    problems = list(parse_problems or [])
+    feasible = res.feasible and not problems
+    clean = sum(1 for x in res.runs if not x.problems) / max(1, len(res.runs) + len(problems))
+    optimum, floor = int(task.reference.get("optimal_cost", 0)), int(task.reference.get("floor_cost", 0))
+    reward, _ = score(res.cost if feasible else None, feasible, clean, optimum, floor, task.rule("gap_k"))
+    cancel_cost = task.rule("cancel_cost")
+
+    runs, costs, events = [], [], []
+    for x in res.runs:
+        r = task.run(x.train)
+        o = plan.get(x.train) or Order()
+        n = len(r.route)
+        runs.append({
+            "train": x.train, "unit": x.unit, "kind": r.kind, "dir": "E" if net.direction(r.origin, r.dest) > 0
+            else "W", "route": r.route, "stops": r.stops, "sched_arr": r.arr, "sched_dep": r.dep,
+            "cancelled": x.cancelled, "first": x.first, "last": x.last,
+            "arr": [x.arr.get(i) for i in range(n)], "dep": [x.dep.get(i) for i in range(n)],
+            "stopped": [bool(x.stopped.get(i)) for i in range(n)],
+            "started": r.started, "fixed_to": r.fixed_to, "fixed_from": r.fixed_from, "stuck": r.stuck,
+            "delay": x.delay, "unserved": x.unserved, "problems": x.problems,
+            "order": o.to_json(x.train) if (o.cancel or o.start or o.end or o.hold) else None})
+        # cost as it accrues (the same terms as check.evaluate)
+        if x.cancelled:
+            for j in range(n):
+                if r.stops[j] and _due(r, j) is not None:
+                    costs.append([_due(r, j), cancel_cost, "unserved", x.train, r.route[j]])
+            events.append({"t": r.dep[0] if r.dep[0] is not None else task.start, "kind": "cancel",
+                           "train": x.train, "text": f"{x.train} cancelled ({r.origin} {hhmm(r.dep[0])} to {r.dest})"})
+            continue
+        s, e = x.first, x.last
+        k = r.fixed_to if r.started else s
+        for j in range(k if r.started else s + 1, e + 1):
+            if r.stops[j] and r.arr[j] is not None and x.arr.get(j) is not None and x.arr[j] >= task.start:
+                late = max(0, x.arr[j] - r.arr[j])
+                if late:
+                    costs.append([x.arr[j], late, "delay", x.train, r.route[j]])
+        for j in range(n):
+            if r.stops[j] and not (s <= j <= e) and _due(r, j) is not None:
+                costs.append([_due(r, j), cancel_cost, "unserved", x.train, r.route[j]])
+        if e < n - 1:
+            events.append({"t": x.arr.get(e), "kind": "turn", "train": x.train,
+                           "text": f"{x.train} turns back at {r.route[e]} (not to {r.dest})"})
+        if s > 0 and not r.started:
+            events.append({"t": x.dep.get(s), "kind": "turn", "train": x.train,
+                           "text": f"{x.train} starts at {r.route[s]} (not {r.origin})"})
+        for code, minute in sorted(o.hold.items(), key=lambda kv: kv[1]):
+            i = r.route.index(code) if code in r.route else None
+            if i is not None and x.dep.get(i) is not None:
+                events.append({"t": x.arr.get(i, minute), "kind": "hold", "train": x.train,
+                               "text": f"{x.train} held at {code} until {hhmm(minute)}"})
+    for unit, c in carry.items():
+        if c:
+            costs.append([task.end, c, "handed_on", unit, ""])
+    for c in task.closures:
+        span = "-".join(dict.fromkeys([c.where[0], c.where[-1]]))
+        what = {"closed": "closed", "slow": f"slow (+{c.extra} min)", "track": "one platform track out of use"}
+        events.append({"t": c.start, "kind": "closure", "text": f"{span} {what.get(c.kind, c.kind)}: {c.cause} "
+                       f"({hhmm(c.start)}-{hhmm(c.end)})"})
+        events.append({"t": c.end, "kind": "reopen", "text": f"{span} back to normal"})
+    for v in res.violations:
+        if v.get("time"):
+            h, m = v["time"].split(":")
+            events.append({"t": int(h) * 60 + int(m), "kind": "violation", "rule": v["rule"],
+                           "trains": v["trains"], "where": v["where"], "text": v["detail"]})
+    events.sort(key=lambda ev: (ev["t"] if ev["t"] is not None else task.start, ev["kind"]))
+    costs.sort(key=lambda c: c[0])
+    total = sum(c[1] for c in costs)
+    assert total == res.delay_cost + res.cancel_cost + res.carry_cost, "cost events must add up to the grader's cost"
+    return {
+        "task_id": task.task_id, "day": task.day, "start": task.start, "end": task.end,
+        "difficulty": task.difficulty, "plan": name, "feasible": feasible, "reward": round(reward, 4),
+        "cost": res.cost if feasible else None, "cost_if_legal": total,
+        "cost_parts": {"delay": res.delay_cost, "unserved": res.cancel_cost, "handed_on": res.carry_cost},
+        "optimal_cost": optimum, "floor_cost": floor,
+        "cancelled": res.cancelled, "short_turned": res.short_turned,
+        "violations": res.violations[:80], "parse_problems": problems,
+        "points": [{"code": p.code, "name": p.name, "km": p.km, "kind": p.kind, "tracks": p.tracks,
+                    "directional": p.directional, "turn": p.turn} for p in net.points],
+        "sections": [{"a": s.a, "b": s.b, "single": s.single} for s in net.sections],
+        "closures": [{"kind": c.kind, "where": c.where, "start": c.start, "end": c.end, "extra": c.extra,
+                      "cause": c.cause, "real": c.real} for c in task.closures],
+        "units": [{"id": u.id, "at": u.at, "ready": u.ready, "runs": u.runs, "after": u.after} for u in task.units],
+        "runs": runs, "costs": costs, "events": events, "notices": task.notices,
+        "rules": {k: task.rule(k) for k in ("h_follow", "h_opp", "turn_min", "stop_loss", "cancel_cost",
+                                           "max_delay")},
+    }

core/rail_core/report.py

@@ -0,0 +1,72 @@
+"""What check_plan shows the agent: every train's simulated times, its delay and lost stops, every rule broken, the
+cost. Never a score and never anything from the reference."""
+
+from __future__ import annotations
+
+from .check import evaluate, network
+from .model import Plan, Task, hhmm
+
+MAX_VIOLATIONS = 60
+
+
+def _times(task: Task, res) -> str:
+    r = task.run(res.train)
+    net = network(task)
+    parts = []
+    first = r.fixed_to if r.started else res.first
+    for i in range(first, res.last + 1):
+        code = r.route[i]
+        if net.by_code[code].kind == "junction":
+            continue
+        a, d = res.arr.get(i), res.dep.get(i)
+        if a is None and d is None:
+            continue
+        if a is None:                                   # where it starts
+            s = f"{code} dep {hhmm(d)}"
+        elif d is None or d == a:
+            s = f"{code} {hhmm(a)}"
+        else:
+            s = f"{code} {hhmm(a)}-{hhmm(d)}"
+        if r.stops[i] and r.arr[i] is not None and a is not None and i > res.first:
+            late = a - r.arr[i]
+            if late > 0:
+                s += f" (+{late})"
+        elif not r.stops[i] and res.stopped.get(i) and i not in (res.first, res.last):
+            s += " (unscheduled stop)"
+        parts.append(s)
+    return " | ".join(parts)
+
+
+def plan_report(task: Task, plan: Plan, problems: list[str] | None = None) -> dict:
+    res = evaluate(task, plan)
+    problems = list(problems or [])
+    feasible = res.feasible and not problems
+    trains = []
+    for x in sorted(res.runs, key=lambda x: (task.run(x.train).fixed_arr if task.run(x.train).started
+                                             else task.run(x.train).dep[0])):
+        r = task.run(x.train)
+        if x.cancelled:
+            what = "cancelled"
+        else:
+            a, b = r.route[x.first], r.route[x.last]
+            what = f"{a}->{b}" + ("" if (x.first == 0 and x.last == len(r.route) - 1) else " (short)")
+        row = {"train": x.train, "set": x.unit, "runs": what, "delay": x.delay, "unserved_stops": x.unserved}
+        if not x.cancelled:
+            row["times"] = _times(task, x)
+        if x.problems:
+            row["breaks"] = x.problems
+        trains.append(row)
+    out = {
+        "feasible": feasible,
+        "cost": res.delay_cost + res.cancel_cost + res.carry_cost if feasible else None,
+        "cost_parts": {"delay": res.delay_cost, "unserved_stops": res.cancel_cost, "handed_on": res.carry_cost},
+        "violations_total": len(res.violations),
+        "violations": res.violations[:MAX_VIOLATIONS],
+        "trains": trains,
+    }
+    if not feasible:
+        out["note"] = ("infeasible: fix every violation (cost_parts are what the plan would cost if it were legal)"
+                       if res.violations or problems else "")
+    if problems:
+        out["entry_problems"] = problems
+    return out

core/rail_core/reward.py

@@ -0,0 +1,68 @@
+"""The terminal reward, from a submitted plan, the task's proven optimum and its floor.
+
+    unreadable, malformed or infeasible   0.2 x clean runs / (runs + entry problems)                 in [0, 0.2)
+    feasible                              0.2 + 0.8 x exp(-g / 0.5)                                  in (0.2, 1]
+                                          g = (cost - optimum) / (optimum - floor + gap_k)
+
+`floor` is each train set's best cost alone with the closures (`solve.floor_cost`): what the disruption forces no
+matter how well the trains are sequenced. The gap is measured against the part a dispatcher controls, so a plan that
+wastes as much as the optimum spends above the floor (plus gap_k) scores 0.31. gap_k is 100 stop-minutes (about three
+unserved stops), which keeps the gap finite when the optimum sits on the floor.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import asdict, dataclass
+
+from .check import evaluate
+from .model import Plan, Task
+
+INFEASIBLE_CAP = 0.2
+GAP_TAU = 0.5
+
+
+@dataclass
+class Grade:
+    reward: float
+    feasible: bool
+    clean_fraction: float
+    quality: float
+    cost: int | None
+    delay_cost: int | None
+    cancel_cost: int | None
+    carry_cost: int | None
+    cancelled: int | None
+    short_turned: int | None
+    optimal_cost: int
+    floor_cost: int
+    violations: list[dict]
+    parse_problems: list[str]
+
+    def as_dict(self) -> dict:
+        return asdict(self)
+
+
+def score(cost: int | None, feasible: bool, clean_fraction: float, optimum: int, floor: int,
+          gap_k: int) -> tuple[float, float]:
+    """(reward, quality)."""
+    if not feasible or cost is None:
+        return INFEASIBLE_CAP * clean_fraction, 0.0
+    g = max(0, cost - optimum) / (max(0, optimum - floor) + gap_k)
+    quality = max(math.exp(-g / GAP_TAU), 1e-6)
+    return INFEASIBLE_CAP + (1.0 - INFEASIBLE_CAP) * quality, quality
+
+
+def grade(task: Task, plan: Plan, parse_problems: list[str] | None = None) -> Grade:
+    optimum = int(task.reference["optimal_cost"])
+    floor = int(task.reference["floor_cost"])
+    res = evaluate(task, plan)
+    problems = list(parse_problems or [])
+    feasible = res.feasible and not problems
+    clean = sum(1 for r in res.runs if not r.problems) / max(1, len(res.runs) + len(problems))
+    reward, quality = score(res.cost, feasible, clean, optimum, floor, task.rule("gap_k"))
+    ok = feasible
+    return Grade(round(reward, 6), feasible, round(clean, 4), round(quality, 6),
+                 res.cost if ok else None, res.delay_cost if ok else None, res.cancel_cost if ok else None,
+                 res.carry_cost if ok else None, res.cancelled if ok else None, res.short_turned if ok else None,
+                 optimum, floor, res.violations, problems)

core/rail_core/select.py

@@ -0,0 +1,189 @@
+"""Choose a hard eval set from a candidate pool, without looking at any model's results on the eval tasks.
+
+    python -m rail_core.select --pool ../tasks/pool-eval --calib ../../results/rollouts/<run>/index.json \
+        --n 45 --out ../tasks/rail-v1-eval
+
+How:
+1. Calibrate on the train split. A model is run on a few train tasks (eval/run_eval.py --split train); its rewards
+   and the tasks' hardness features (`hardness.features`, model-free) are the calibration set.
+2. Fit a ridge regression from standardized features to reward on that set (pure Python, leave-one-out error
+   reported). Features whose coefficient sign is unstable under leave-one-out are dropped.
+3. Predict every pool task's reward (the pool is built on held-out days only) and keep the `n` with the lowest
+   prediction, with at most `max_per_day` per day and every tier in the pool represented (`min_per_tier`).
+The eval tasks themselves are never scored by a model before selection: the choice depends only on train-split
+calibration and on features any solver-built task has, so the eval stays a fair test.
+
+Writes the pack (tasks.jsonl, manifest.json with the selection) and selection.json: the fit, its leave-one-out
+error, the weights, and every pool task's prediction.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+
+from .build import write_pack
+from .pack import TaskPack
+
+FEATURES = ["runs", "conflicts", "decisions", "holds", "short_turns", "cancels", "turn_points", "avoidable",
+            "greedy_gap", "closed_min", "slow_min", "track_min", "single_closed", "mid_line", "late_sets"]
+
+
+def _vec(h: dict, feats: list[str]) -> list[float]:
+    out = []
+    for f in feats:
+        v = h.get(f, 0)
+        v = float(v) if not isinstance(v, bool) else float(int(v))
+        if f in ("avoidable",):
+            v = math.log1p(max(0.0, v))
+        out.append(v)
+    return out
+
+
+def _solve(A: list[list[float]], b: list[float]) -> list[float]:
+    """Gaussian elimination with partial pivoting."""
+    n = len(A)
+    M = [row[:] + [b[i]] for i, row in enumerate(A)]
+    for c in range(n):
+        p = max(range(c, n), key=lambda r: abs(M[r][c]))
+        M[c], M[p] = M[p], M[c]
+        if abs(M[c][c]) < 1e-12:
+            continue
+        for r in range(n):
+            if r != c:
+                f = M[r][c] / M[c][c]
+                for k in range(c, n + 1):
+                    M[r][k] -= f * M[c][k]
+    return [M[i][n] / M[i][i] if abs(M[i][i]) > 1e-12 else 0.0 for i in range(n)]
+
+
+def ridge(X: list[list[float]], y: list[float], lam: float) -> list[float]:
+    """w (intercept first) minimizing |y - [1 X] w|^2 + lam |w[1:]|^2."""
+    Z = [[1.0] + row for row in X]
+    d = len(Z[0])
+    A = [[sum(z[i] * z[j] for z in Z) + (lam if i == j and i > 0 else 0.0) for j in range(d)] for i in range(d)]
+    b = [sum(z[i] * yy for z, yy in zip(Z, y)) for i in range(d)]
+    return _solve(A, b)
+
+
+def predict(w: list[float], x: list[float]) -> float:
+    return w[0] + sum(a * b for a, b in zip(w[1:], x))
+
+
+class Scaler:
+    def __init__(self, rows: list[list[float]]):
+        n = len(rows)
+        self.mu = [sum(r[j] for r in rows) / n for j in range(len(rows[0]))]
+        self.sd = [math.sqrt(sum((r[j] - self.mu[j]) ** 2 for r in rows) / n) or 1.0 for j in range(len(rows[0]))]
+
+    def __call__(self, r: list[float]) -> list[float]:
+        return [(v - m) / s for v, m, s in zip(r, self.mu, self.sd)]
+
+
+def fit(calib: list[tuple[dict, float]], pool_feats: list[dict], feats: list[str], lam: float):
+    X_raw = [_vec(h, feats) for h, _ in calib]
+    scale = Scaler(X_raw + [_vec(h, feats) for h in pool_feats])
+    X = [scale(r) for r in X_raw]
+    y = [r for _, r in calib]
+    w = ridge(X, y, lam)
+    loo, signs = [], []
+    for i in range(len(X)):
+        wi = ridge(X[:i] + X[i + 1:], y[:i] + y[i + 1:], lam)
+        loo.append(predict(wi, X[i]) - y[i])
+        signs.append([math.copysign(1, v) if abs(v) > 1e-9 else 0 for v in wi[1:]])
+    stable = [all(s[j] == signs[0][j] for s in signs) for j in range(len(feats))]
+    return w, scale, loo, stable
+
+
+def _spearman(a: list[float], b: list[float]) -> float:
+    def ranks(v):
+        o = sorted(range(len(v)), key=lambda i: v[i])
+        r = [0.0] * len(v)
+        for k, i in enumerate(o):
+            r[i] = k
+        return r
+    ra, rb = ranks(a), ranks(b)
+    n = len(a)
+    ma, mb = sum(ra) / n, sum(rb) / n
+    num = sum((x - ma) * (y - mb) for x, y in zip(ra, rb))
+    den = math.sqrt(sum((x - ma) ** 2 for x in ra) * sum((y - mb) ** 2 for y in rb)) or 1.0
+    return num / den
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--pool", required=True)
+    ap.add_argument("--calib", nargs="+", required=True, help="index.json of runs on train tasks (with hardness)")
+    ap.add_argument("--model", default=None, help="only this model's calibration episodes")
+    ap.add_argument("--n", type=int, default=45)
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--max-per-day", type=int, default=3)
+    ap.add_argument("--min-per-tier", type=int, default=4)
+    ap.add_argument("--lam", type=float, default=3.0)
+    args = ap.parse_args()
+    calib = []
+    for path in args.calib:
+        for e in json.loads(Path(path).read_text())["episodes"]:
+            if e.get("split") == "train" and e.get("hardness") and (not args.model or e["model"] == args.model):
+                calib.append((e["hardness"], float(e["reward"])))
+    pool = TaskPack(args.pool)
+    tasks = [t for t in pool.tasks if t.split == "eval"]
+    feats = list(FEATURES)
+    w, scale, loo, stable = fit(calib, [t.reference["hardness"] for t in tasks], feats, args.lam)
+    keep = [f for f, s in zip(feats, stable) if s]
+    if keep and len(keep) < len(feats):
+        feats = keep
+        w, scale, loo, stable = fit(calib, [t.reference["hardness"] for t in tasks], feats, args.lam)
+    preds = {t.task_id: predict(w, scale(_vec(t.reference["hardness"], feats))) for t in tasks}
+    y = [r for _, r in calib]
+    loo_pred = [e + yy for e, yy in zip(loo, y)]
+    # pick: lowest predicted reward, every tier represented, at most max_per_day per day
+    order = sorted(tasks, key=lambda t: preds[t.task_id])
+    chosen, per_day, per_tier = [], {}, {}
+    tiers = sorted({t.difficulty for t in tasks})
+    for tier in tiers:                       # the hardest few of each tier first
+        for t in [x for x in order if x.difficulty == tier]:
+            if per_tier.get(tier, 0) >= args.min_per_tier or len(chosen) >= args.n:
+                break
+            if per_day.get(t.day, 0) < args.max_per_day:
+                chosen.append(t)
+                per_day[t.day] = per_day.get(t.day, 0) + 1
+                per_tier[tier] = per_tier.get(tier, 0) + 1
+    for t in order:
+        if len(chosen) >= args.n:
+            break
+        if t in chosen or per_day.get(t.day, 0) >= args.max_per_day:
+            continue
+        chosen.append(t)
+        per_day[t.day] = per_day.get(t.day, 0) + 1
+        per_tier[t.difficulty] = per_tier.get(t.difficulty, 0) + 1
+    report = {
+        "calibration_episodes": len(calib), "features": feats, "lambda": args.lam,
+        "weights": dict(zip(["intercept"] + feats, [round(v, 4) for v in w])),
+        "loo_mae": round(sum(abs(e) for e in loo) / max(1, len(loo)), 4),
+        "loo_spearman": round(_spearman(loo_pred, y), 4) if len(y) > 2 else None,
+        "calibration_mean_reward": round(sum(y) / max(1, len(y)), 4),
+        "pool": len(tasks), "chosen": len(chosen), "per_tier": per_tier,
+        "predicted_mean_chosen": round(sum(preds[t.task_id] for t in chosen) / max(1, len(chosen)), 4),
+        "predicted_mean_pool": round(sum(preds.values()) / max(1, len(preds)), 4),
+        "predictions": {k: round(v, 4) for k, v in sorted(preds.items(), key=lambda kv: kv[1])},
+    }
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+    for t in chosen:
+        t.reference["predicted_reward"] = round(preds[t.task_id], 4)
+    picked = sorted((t.to_dict() for t in chosen), key=lambda d: (d["difficulty"], d["day"], d["start"]))
+    log = [json.loads(line) for line in (Path(args.pool) / "build_log.jsonl").read_text().splitlines()] \
+        if (Path(args.pool) / "build_log.jsonl").is_file() else []
+    manifest = write_pack(out, picked, log, "eval", extra={"selected_from": Path(args.pool).name,
+                                                          "selection": {k: report[k] for k in report
+                                                                        if k != "predictions"}})
+    (out / "selection.json").write_text(json.dumps(report, indent=1) + "\n")
+    print(json.dumps({k: v for k, v in report.items() if k != "predictions"}, indent=1))
+    print(json.dumps({k: manifest[k] for k in ("tasks", "tiers", "runs")}))
+
+
+if __name__ == "__main__":
+    main()

core/rail_core/solve.py

@@ -0,0 +1,608 @@
+"""The reference plan: CP-SAT over the same physics and rules as `check`, proven optimal (or within a stated gap).
+
+The model mirrors `check.simulate` exactly:
+    one option per run (run in full, short-turned / started at a turn point, or cancelled)
+    arrival and departure minutes at every point it may serve, with the same recurrences: minimum running times,
+    never ahead of the timetable, no early departures at scheduled stops, `stop_loss` for an unscheduled stop (a Boolean per passing point)
+    each train set's position and readiness carried run to run (a cancelled run leaves both unchanged)
+    single-track and headway rules as pairwise disjunctions (pruned where the time windows cannot meet), platform
+    tracks as cumulatives, closures as disjunctions, max delay as a domain bound
+The solution is turned into a plan of holds, short-turns and cancellations and re-checked with `check.evaluate`: its
+cost must equal the solver's objective.
+
+`floor`: the same model without any interaction between train sets (no single-track, headway or platform rules).
+Every real plan is feasible there, so its optimum is a lower bound: the cost the closures force on each train set
+alone. The reward measures the gap against optimum - floor.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+
+from ortools.sat.python import cp_model
+
+from .check import evaluate, network, run_dir
+from .model import Order, Plan, Run, Task
+
+
+@dataclass
+class Solution:
+    plan: Plan | None
+    cost: int | None
+    bound: int
+    optimal: bool
+    status: str
+    seconds: float
+
+
+def _options(task: Task, r: Run) -> list[tuple[int, int] | None]:
+    net = network(task)
+    n = len(r.route)
+    turn = [i for i in range(1, n - 1) if net.by_code[r.route[i]].turn]
+    if r.started:
+        ends = [n - 1] + [i for i in turn if i >= r.fixed_to]
+        return [(0, e) for e in ends]
+    starts = [0] + turn
+    opts: list[tuple[int, int] | None] = [None]
+    for s in starts:
+        for e in [n - 1] + turn:
+            if e > s:
+                opts.append((s, e))
+    return opts
+
+
+class _Model:
+    def __init__(self, task: Task, interactions: bool = True, horizon_pad: int = 300,
+                 unit_floor: dict[str, int] | None = None):
+        self.task = task
+        self.net = network(task)
+        self.m = cp_model.CpModel()
+        self.H = task.end + horizon_pad
+        self.interactions = interactions
+        self.L = task.rule("stop_loss")
+        self.turn = task.rule("turn_min")
+        self.cost_terms: list = []
+        self.const_cost = 0
+        self.unit_terms: dict[str, list] = {u.id: [] for u in task.units}
+        self.unit_const: dict[str, int] = {u.id: 0 for u in task.units}
+        self.unit_floor = unit_floor or {}
+        self.rv: dict[str, dict] = {}
+        self._build()
+
+    # ---------------------------------------------------------------- per run
+    def _bounds(self, r: Run):
+        """(lo, hi_arr, hi_dep): earliest minute at each route point, and the latest arrival and departure there in
+        any plan that obeys max_delay (a run that may end before its next stop is bounded only by the horizon)."""
+        n = len(r.route)
+        lo = [0] * n
+        k = r.fixed_to if r.started else 0
+        t = max(r.fixed_arr, self.task.start) if r.started else r.dep[0]
+        lo[k] = r.fixed_arr if r.started else t
+        for i in range(k, n - 1):
+            if i > k and r.stops[i]:
+                t = max(t, r.dep[i])
+            t += r.seg[i]
+            if r.arr[i + 1] is not None:
+                t = max(t, r.arr[i + 1])
+            lo[i + 1] = t
+        maxd = self.task.rule("max_delay")
+        H = self.H
+        hi_arr, hi_dep = [H] * n, [H] * n
+        cap, travel, open_end = None, 0, False     # the next stop's latest arrival, minutes to it, could end before it
+        for i in range(n - 1, k - 1, -1):
+            p = self.net.by_code[r.route[i]]
+            if i < n - 1:
+                travel += r.seg[i]
+                if cap is not None and not open_end:
+                    hi_dep[i] = cap - travel
+            if r.stops[i] and r.arr[i] is not None and i > 0:
+                hi_arr[i] = r.arr[i] + maxd
+                cap, travel, open_end = r.arr[i] + maxd, 0, False
+            elif i < n - 1:
+                hi_arr[i] = hi_dep[i] if not p.turn else H
+                if p.turn:
+                    open_end = True
+        for i in range(n):
+            hi_dep[i] = max(hi_dep[i], lo[i])
+            hi_arr[i] = max(hi_arr[i], lo[i])
+        return lo, hi_arr, hi_dep
+
+    def _run_vars(self, r: Run):
+        m, net = self.m, self.net
+        n = len(r.route)
+        opts = _options(self.task, r)
+        o = [m.NewBoolVar(f"o_{r.id}_{a}") for a in range(len(opts))]
+        m.AddExactlyOne(o)
+        lo, hi_arr, hi_dep = self._bounds(r)
+        f0 = r.fixed_to if r.started else 0
+        arr, dep = {}, {}
+        for i in range(f0, n):
+            arr[i] = m.NewIntVar(lo[i], hi_arr[i] + (self.L if not r.stops[i] else 0), f"a_{r.id}_{i}")
+            if i < n - 1:
+                dep[i] = m.NewIntVar(lo[i], hi_dep[i] + self.L, f"d_{r.id}_{i}")
+
+        def bsum(pred, name):
+            terms = [o[a] for a, op in enumerate(opts) if op is not None and pred(op)]
+            if not terms:
+                return 0
+            if len(terms) == 1:
+                return terms[0]
+            b = m.NewBoolVar(name)
+            m.Add(b == sum(terms))
+            return b
+
+        v = {i: bsum(lambda op, i=i: op[0] <= i <= op[1], f"v_{r.id}_{i}") for i in range(f0, n)}
+        u = {i: bsum(lambda op, i=i: op[0] <= i and op[1] >= i + 1, f"u_{r.id}_{i}") for i in range(f0, n - 1)}
+        st = {} if r.started else {i: bsum(lambda op, i=i: op[0] == i, f"s_{r.id}_{i}") for i in range(n)}
+        en = {i: bsum(lambda op, i=i: op[1] == i, f"e_{r.id}_{i}") for i in range(f0, n)}
+        cancel = o[0] if opts[0] is None else 0
+        w = {}
+        inner = {}
+        for i in range(f0, n):
+            code = r.route[i]
+            vi, si, ei = v[i], st.get(i, 0), en[i]
+            if isinstance(vi, int) and vi == 0:
+                inner[i] = 0
+                continue
+            if r.started and i == f0:
+                inner[i] = m.NewBoolVar(f"in_{r.id}_{i}")
+                m.Add(inner[i] == 1 - ei)
+            else:
+                inner[i] = m.NewBoolVar(f"in_{r.id}_{i}")
+                m.Add(inner[i] == vi - si - ei)
+            if not r.stops[i] and net.by_code[code].kind != "junction" and i < n - 1:
+                w[i] = m.NewBoolVar(f"w_{r.id}_{i}")
+                m.AddImplication(w[i], inner[i])
+        # departures and dwell
+        for i in range(f0, n - 1):
+            code = r.route[i]
+            pt = net.by_code[code]
+            if not isinstance(inner[i], int):
+                lit = inner[i]
+                if r.started and i == f0:
+                    if r.stops[i]:
+                        m.Add(dep[i] >= max(r.dep[i], self.task.start)).OnlyEnforceIf(lit)
+                    m.Add(dep[i] >= self.task.start).OnlyEnforceIf(lit)
+                if r.stops[i]:
+                    m.Add(dep[i] >= arr[i]).OnlyEnforceIf(lit)
+                    m.Add(dep[i] >= r.dep[i]).OnlyEnforceIf(lit)
+                elif pt.kind == "junction":
+                    m.Add(dep[i] == arr[i]).OnlyEnforceIf(lit)
+                else:
+                    m.Add(dep[i] == arr[i]).OnlyEnforceIf([lit, w[i].Not()])
+                    m.Add(dep[i] >= arr[i]).OnlyEnforceIf(w[i])
+            if not r.started and not isinstance(st[i], int):
+                m.Add(dep[i] >= r.dep[i]).OnlyEnforceIf(st[i])
+        if r.started:
+            k = f0
+            if k in w:
+                m.Add(arr[k] == r.fixed_arr + self.L * w[k])
+            else:
+                m.Add(arr[k] == r.fixed_arr)
+        # running
+        slow = [c for c in self.task.closures if c.kind == "slow"]
+        for i in range(f0, n - 1):
+            if isinstance(u[i], int):
+                continue
+            acc_terms = []
+            if i in w:
+                acc_terms.append(w[i])
+            if not r.started and not r.stops[i] and not isinstance(st.get(i, 0), int):
+                acc_terms.append(st[i])
+            brk_terms = []
+            if (i + 1) in w:
+                brk_terms.append(w[i + 1])
+            if not r.stops[i + 1] and not isinstance(en[i + 1], int):
+                brk_terms.append(en[i + 1])
+            extra = 0
+            sec = self.net.section(r.route[i], r.route[i + 1])
+            for c in slow:
+                lo_i, hi_i = sorted((self.net.index[c.where[0]], self.net.index[c.where[-1]]))
+                if not lo_i <= sec < hi_i:
+                    continue
+                y = m.NewBoolVar(f"slow_{r.id}_{i}_{c.start}")
+                b1 = m.NewBoolVar("")
+                b2 = m.NewBoolVar("")
+                m.Add(dep[i] >= c.start).OnlyEnforceIf(b1)
+                m.Add(dep[i] < c.start).OnlyEnforceIf(b1.Not())
+                m.Add(dep[i] < c.end).OnlyEnforceIf(b2)
+                m.Add(dep[i] >= c.end).OnlyEnforceIf(b2.Not())
+                m.AddBoolAnd([b1, b2]).OnlyEnforceIf(y)
+                m.AddBoolOr([b1.Not(), b2.Not()]).OnlyEnforceIf(y.Not())
+                extra = extra + c.extra * y
+            run_t = m.NewIntVar(0, 2 * self.H, f"rt_{r.id}_{i}")
+            m.Add(run_t == dep[i] + r.seg[i] + self.L * sum(acc_terms) + extra)
+            if r.arr[i + 1] is not None:          # never ahead of the timetable
+                reach = m.NewIntVar(0, 2 * self.H, f"rc_{r.id}_{i}")
+                m.AddMaxEquality(reach, [run_t, r.arr[i + 1]])
+            else:
+                reach = run_t
+            m.Add(arr[i + 1] == reach + self.L * sum(brk_terms)).OnlyEnforceIf(u[i])
+        # cost: delays at served stops (not where it starts), cancelled stops
+        C = self.task.rule("cancel_cost")
+        for i in range(f0, n):
+            if not r.stops[i] or r.arr[i] is None or i == 0:
+                continue
+            if r.started and i == f0:
+                if r.fixed_arr >= self.task.start:
+                    self.const_cost += max(0, r.fixed_arr - r.arr[i])
+                    self.unit_const[r.unit] += max(0, r.fixed_arr - r.arr[i])
+                continue
+            lit = m.NewBoolVar(f"late_{r.id}_{i}")
+            m.Add(lit == v[i] - st.get(i, 0)) if not isinstance(v[i], int) else m.Add(lit == 0)
+            dl = m.NewIntVar(0, self.H, f"dl_{r.id}_{i}")
+            m.Add(dl >= arr[i] - r.arr[i]).OnlyEnforceIf(lit)
+            self.cost_terms.append(dl)
+            self.unit_terms[r.unit].append(dl)
+        for a, op in enumerate(opts):
+            if op is None:
+                self.cost_terms.append(C * r.n_stops * o[a])
+                self.unit_terms[r.unit].append(C * r.n_stops * o[a])
+            else:
+                s, e = op
+                lost = sum(1 for j, x in enumerate(r.stops) if x and not (s <= j <= e))
+                if lost:
+                    self.cost_terms.append(C * lost * o[a])
+                    self.unit_terms[r.unit].append(C * lost * o[a])
+        self.rv[r.id] = dict(run=r, opts=opts, o=o, arr=arr, dep=dep, v=v, u=u, st=st, en=en, w=w, inner=inner,
+                             lo=lo, hi_arr=hi_arr, hi_dep=hi_dep, cancel=cancel, f0=f0)
+
+    # ---------------------------------------------------------------- train sets
+    def _units(self):
+        m, net = self.m, self.net
+        self.waits = []           # (station, start expr/var, end var, literal)
+        for u in self.task.units:
+            pos = net.index[u.at] if u.at else None
+            rdy = u.ready
+            arrived = self.task.start if u.at else None
+            for k, rid in enumerate(u.runs):
+                R = self.rv[rid]
+                r = R["run"]
+                npos = m.NewIntVar(0, len(net.points) - 1, f"pos_{rid}")
+                nrdy = m.NewIntVar(0, self.H + self.turn, f"rdy_{rid}")
+                narr = m.NewIntVar(0, self.H, f"arrd_{rid}")
+                c = R["cancel"]
+                if not isinstance(c, int):
+                    if pos is None:
+                        m.Add(c == 0)
+                    else:
+                        m.Add(npos == pos).OnlyEnforceIf(c)
+                        m.Add(nrdy == (rdy if rdy is not None else 0)).OnlyEnforceIf(c)
+                        m.Add(narr == (arrived if arrived is not None else 0)).OnlyEnforceIf(c)
+                if not r.started:
+                    for i, sv in R["st"].items():
+                        if isinstance(sv, int):
+                            continue
+                        want = net.index[r.route[i]]
+                        if pos is None or (isinstance(pos, int) and pos != want):
+                            m.Add(sv == 0)
+                        elif not isinstance(pos, int):
+                            m.Add(pos == want).OnlyEnforceIf(sv)
+                        if rdy is not None:
+                            m.Add(R["dep"][i] >= rdy).OnlyEnforceIf(sv)
+                        code = r.route[i]
+                        p = net.by_code[code]
+                        if p.tracks is not None and p.kind != "junction" and self.interactions:
+                            self.waits.append((code, arrived, R["dep"][i], sv))
+                for i, ev in R["en"].items():
+                    if isinstance(ev, int):
+                        continue
+                    m.Add(npos == net.index[r.route[i]]).OnlyEnforceIf(ev)
+                    m.Add(nrdy == R["arr"][i] + self.turn).OnlyEnforceIf(ev)
+                    m.Add(narr == R["arr"][i]).OnlyEnforceIf(ev)
+                pos, rdy, arrived = npos, nrdy, narr
+            if u.after:
+                m.Add(pos == net.index[u.after["station"]])
+                cr = m.NewIntVar(0, (self.H + self.turn) * int(u.after["stops"]), f"carry_{u.id}")
+                m.Add(cr >= int(u.after["stops"]) * (rdy - u.after["dep"]))
+                self.cost_terms.append(cr)
+                self.unit_terms[u.id].append(cr)
+            # a set that ends the window at a station with few tracks keeps one there
+            if self.interactions and pos is not None and not isinstance(pos, int):
+                for p in net.points:
+                    if p.tracks is not None and p.kind != "junction" and p.turn:
+                        b = m.NewBoolVar(f"park_{u.id}_{p.code}")
+                        m.Add(pos == net.index[p.code]).OnlyEnforceIf(b)
+                        m.Add(pos != net.index[p.code]).OnlyEnforceIf(b.Not())
+                        self.waits.append((p.code, arrived, self.H, b))
+
+    # ---------------------------------------------------------------- interactions
+    def _sections(self):
+        m, net = self.m, self.net
+        hf, ho = self.task.rule("h_follow"), self.task.rule("h_opp")
+        occ: dict[int, list] = {}
+        for rid, R in self.rv.items():
+            r = R["run"]
+            d = run_dir(net, r)
+            for i, ui in R["u"].items():
+                if isinstance(ui, int) and ui == 0:
+                    continue
+                sec = net.section(r.route[i], r.route[i + 1])
+                occ.setdefault(sec, []).append((rid, d, R["dep"][i], R["arr"][i + 1], ui,
+                                                R["lo"][i], R["hi_dep"][i] + self.L, R["lo"][i + 1],
+                                                R["hi_arr"][i + 1] + self.L))
+            if r.started and r.fixed_from is not None:
+                k = r.fixed_to
+                sec = net.section(r.route[k - 1], r.route[k])
+                occ.setdefault(sec, []).append((rid, d, r.fixed_from, R["arr"][k], 1, r.fixed_from, r.fixed_from,
+                                                r.fixed_arr, r.fixed_arr + self.L))
+        self.n_pairs = 0
+        order: dict[tuple, object] = {}       # (section, first run id, second run id) -> "first goes first"
+        for sec, lst in occ.items():
+            single = net.sections[sec].single
+            for x in range(len(lst)):
+                for y in range(x + 1, len(lst)):
+                    a, b = lst[x], lst[y]
+                    if a[0] == b[0]:
+                        continue
+                    same = a[1] == b[1]
+                    if not same and not single:
+                        continue
+                    lits = [l for l in (a[4], b[4]) if not isinstance(l, int)]
+                    if same:
+                        a_first = b[5] >= a[6] + hf and b[7] >= a[8] + hf
+                        b_first = a[5] >= b[6] + hf and a[7] >= b[8] + hf
+                    else:
+                        a_first = b[5] >= a[8] + ho
+                        b_first = a[5] >= b[8] + ho
+                    if a_first or b_first:
+                        order[(sec, a[0], b[0])] = bool(a_first)
+                        continue
+                    self.n_pairs += 1
+                    z = m.NewBoolVar("")
+                    order[(sec, a[0], b[0])] = z
+                    if same:
+                        m.Add(b[2] >= a[2] + hf).OnlyEnforceIf([z] + lits)
+                        m.Add(b[3] >= a[3] + hf).OnlyEnforceIf([z] + lits)
+                        m.Add(a[2] >= b[2] + hf).OnlyEnforceIf([z.Not()] + lits)
+                        m.Add(a[3] >= b[3] + hf).OnlyEnforceIf([z.Not()] + lits)
+                    else:
+                        m.Add(b[2] >= a[3] + ho).OnlyEnforceIf([z] + lits)
+                        m.Add(a[2] >= b[3] + ho).OnlyEnforceIf([z.Not()] + lits)
+        self._tie_orders(order, occ)
+
+    def _tie_orders(self, order: dict, occ: dict):
+        """Redundant but exact: where two trains cannot pass each other at the point between two sections (a junction,
+        a one-track halt, a station with one track each way), their order is the same in both sections. Tying the
+        order variables removes symmetric search the solver would otherwise do."""
+        m, net = self.m, self.net
+        self.n_ties = 0
+        dirs = {e[0]: e[1] for lst in occ.values() for e in lst}
+
+        def lit(sec, a, b):
+            if (sec, a, b) in order:
+                return order[(sec, a, b)]
+            if (sec, b, a) in order:
+                v = order[(sec, b, a)]
+                return (not v) if isinstance(v, bool) else v.Not()
+            return None
+
+        for sec in range(len(net.sections) - 1):
+            p = net.points[sec + 1]
+            no_pass = p.kind == "junction" or p.directional or p.tracks == 1
+            one_track = p.tracks == 1 and net.sections[sec].single and net.sections[sec + 1].single
+            if not (no_pass or one_track):
+                continue
+            for (s, a, b) in list(order):
+                if s != sec:
+                    continue
+                same = dirs.get(a) == dirs.get(b)
+                if (same and not no_pass) or (not same and not one_track):
+                    continue
+                x, y = lit(sec, a, b), lit(sec + 1, a, b)
+                if x is None or y is None or (isinstance(x, bool) and isinstance(y, bool)):
+                    continue
+                if isinstance(x, bool):
+                    m.AddBoolOr([y if x else y.Not()])
+                elif isinstance(y, bool):
+                    m.AddBoolOr([x if y else x.Not()])
+                else:
+                    m.AddImplication(x, y)
+                    m.AddImplication(y, x)
+                self.n_ties += 1
+
+    def _closures(self):
+        m, net = self.m, self.net
+        for c in self.task.closures:
+            if c.kind != "closed":
+                continue
+            lo_s, hi_s = sorted((net.index[c.where[0]], net.index[c.where[-1]]))
+            for rid, R in self.rv.items():
+                r = R["run"]
+                for i, ui in R["u"].items():
+                    if isinstance(ui, int) and ui == 0:
+                        continue
+                    sec = net.section(r.route[i], r.route[i + 1])
+                    if not lo_s <= sec < hi_s:
+                        continue
+                    if R["lo"][i] >= c.end or R["hi_arr"][i + 1] + self.L <= c.start:
+                        continue
+                    lits = [ui] if not isinstance(ui, int) else []
+                    z = m.NewBoolVar("")
+                    m.Add(R["arr"][i + 1] <= c.start).OnlyEnforceIf([z] + lits)
+                    m.Add(R["dep"][i] >= c.end).OnlyEnforceIf([z.Not()] + lits)
+
+    def _stations(self):
+        m, net = self.m, self.net
+        by_pt: dict[str, list] = {}
+        for rid, R in self.rv.items():
+            r = R["run"]
+            d = run_dir(net, r)
+            for i, lit in R["inner"].items():
+                if isinstance(lit, int) and lit == 0:
+                    continue
+                code = r.route[i]
+                p = net.by_code[code]
+                if p.tracks is None or p.kind == "junction" or i == len(r.route) - 1:
+                    continue
+                end = m.NewIntVar(0, self.H + 1, "")
+                m.Add(end == R["dep"][i] + 1)
+                size = m.NewIntVar(1, self.H + 1, "")
+                iv = m.NewOptionalIntervalVar(R["arr"][i], size, end, lit, f"p_{rid}_{i}")
+                by_pt.setdefault(code, []).append((iv, d))
+        for code, start, depv, lit in self.waits:
+            s0 = start if start is not None else 0
+            if isinstance(s0, int):
+                sv = m.NewConstant(s0)
+            else:
+                sv = s0
+            end = m.NewIntVar(0, self.H + 2, "")
+            m.Add(end == depv + 1)
+            size = m.NewIntVar(0, self.H + 2, "")
+            iv = m.NewOptionalIntervalVar(sv, size, end, lit, f"wait_{code}")
+            by_pt.setdefault(code, []).append((iv, 0))
+        for code, lst in by_pt.items():
+            p = net.by_code[code]
+            outs = [c for c in self.task.closures if c.kind == "track" and c.where[0] == code]
+            fixed = [m.NewFixedSizeIntervalVar(c.start, c.end - c.start, "") for c in outs]
+            if p.directional:
+                for d in (1, -1):
+                    ivs = [iv for iv, dd in lst if dd in (d, 0)]
+                    if len(ivs) + len(fixed) > 1:
+                        m.AddNoOverlap(ivs + fixed)
+            else:
+                ivs = [iv for iv, _ in lst] + fixed
+                if len(ivs) > p.tracks:
+                    m.AddCumulative(ivs, [1] * len(ivs), p.tracks)
+
+    def _build(self):
+        for r in self.task.runs:
+            self._run_vars(r)
+        self._units()
+        self._closures()
+        self.n_pairs = 0
+        if self.interactions:
+            self._sections()
+            self._stations()
+        self.obj = sum(self.cost_terms) + self.const_cost
+        # each train set costs at least what it costs alone with the closures (the floor's part): exact, and it
+        # lifts the solver's bound to the floor at once, so only the interactions are left to prove
+        for uid, f in self.unit_floor.items():
+            if uid in self.unit_terms:
+                self.m.Add(sum(self.unit_terms[uid]) + self.unit_const[uid] >= f)
+        if self.unit_floor:                    # CP-SAT's bound does not add the parts up by itself
+            self.m.Add(self.obj >= sum(self.unit_floor.values()))
+        self.m.Minimize(self.obj)
+
+    def unit_costs(self, solver) -> dict[str, int]:
+        return {uid: int(sum(solver.Value(t) for t in terms)) + self.unit_const[uid]
+                for uid, terms in self.unit_terms.items()}
+
+    # ---------------------------------------------------------------- solution
+    def plan(self, solver) -> Plan:
+        plan: Plan = {}
+        for rid, R in self.rv.items():
+            r = R["run"]
+            a = next(a for a, ov in enumerate(R["o"]) if solver.Value(ov))
+            op = R["opts"][a]
+            if op is None:
+                plan[rid] = Order(cancel=True)
+                continue
+            s, e = op
+            o = Order(start=r.route[s] if s > 0 else None, end=r.route[e] if e < len(r.route) - 1 else None)
+            first = R["f0"] if r.started else s
+            for i in range(first, e):
+                if self.net.by_code[r.route[i]].kind == "junction":
+                    continue
+                o.hold[r.route[i]] = solver.Value(R["dep"][i])
+            plan[rid] = o
+        return _tidy(self.task, plan)
+
+    def hint(self, plan: Plan):
+        """Hint the solver with a plan's times (from `check.simulate`)."""
+        from .check import simulate
+        res, *_ = simulate(self.task, plan)
+        for rid, R in self.rv.items():
+            x = res.get(rid)
+            o = plan.get(rid) or Order()
+            r = R["run"]
+            if x is None:
+                continue
+            if x.cancelled:
+                key = None
+            else:
+                key = (0 if r.started else x.first, x.last)
+            for a, op in enumerate(R["opts"]):
+                self.m.AddHint(R["o"][a], int(op == key))
+            if x.cancelled:
+                continue
+            for i, t in x.arr.items():
+                if i in R["arr"]:
+                    self.m.AddHint(R["arr"][i], t)
+            for i, t in x.dep.items():
+                if i in R["dep"]:
+                    self.m.AddHint(R["dep"][i], t)
+            for i, wv in R["w"].items():
+                self.m.AddHint(wv, int(bool(x.stopped.get(i)) and not r.stops[i] and i != x.first and i != x.last))
+
+
+def _tidy(task: Task, plan: Plan) -> Plan:
+    """Drop holds that change nothing (the train would leave then anyway), so reference plans read cleanly."""
+    from .check import simulate
+    out: Plan = {}
+    for rid, o in plan.items():
+        if o.cancel:
+            out[rid] = o
+            continue
+        out[rid] = Order(start=o.start, end=o.end, hold=dict(o.hold))
+    base, *_ = simulate(task, out)
+    for rid, o in list(out.items()):
+        if o.cancel:
+            continue
+        for code in list(o.hold):
+            trial = Order(start=o.start, end=o.end, hold={k: v for k, v in o.hold.items() if k != code})
+            res, *_ = simulate(task, {**out, rid: trial})
+            if res[rid].arr == base[rid].arr and res[rid].dep == base[rid].dep:
+                out[rid] = trial
+                o = trial
+    return {rid: o for rid, o in out.items() if o.cancel or o.start or o.end or o.hold}
+
+
+def solve(task: Task, time_limit: float = 60.0, workers: int = 4, hint: Plan | None = None,
+          interactions: bool = True, log: bool = False, unit_floor: dict[str, int] | None = None) -> Solution:
+    t0 = time.time()
+    M = _Model(task, interactions=interactions, unit_floor=unit_floor)
+    if hint is not None:
+        M.hint(hint)
+    solver = cp_model.CpSolver()
+    solver.parameters.max_time_in_seconds = time_limit
+    solver.parameters.num_workers = workers
+    solver.parameters.log_search_progress = log
+    st = solver.Solve(M.m)
+    name = solver.StatusName(st)
+    if st not in (cp_model.OPTIMAL, cp_model.FEASIBLE):
+        return Solution(None, None, int(solver.BestObjectiveBound()) if st != cp_model.INFEASIBLE else 0, False, name,
+                        time.time() - t0)
+    plan = M.plan(solver) if interactions else None
+    return Solution(plan, int(round(solver.ObjectiveValue())), int(round(solver.BestObjectiveBound())),
+                    st == cp_model.OPTIMAL, name, time.time() - t0)
+
+
+def floor_cost(task: Task, time_limit: float = 30.0) -> int:
+    """Lower bound: each train set alone with the closures (no interactions)."""
+    return floor_parts(task, time_limit)[0]
+
+
+def floor_parts(task: Task, time_limit: float = 30.0) -> tuple[int, dict[str, int]]:
+    """(floor, each train set's own part). Without interactions the sets are independent, so a proven optimum is
+    the sum of each set's optimum alone; the parts are only returned when that is proven."""
+    M = _Model(task, interactions=False)
+    solver = cp_model.CpSolver()
+    solver.parameters.max_time_in_seconds = time_limit
+    solver.parameters.num_workers = 4
+    st = solver.Solve(M.m)
+    if st == cp_model.OPTIMAL:
+        return int(round(solver.ObjectiveValue())), M.unit_costs(solver)
+    return int(solver.BestObjectiveBound()) if st == cp_model.FEASIBLE else 0, {}
+
+
+def optimal_plan(task: Task, time_limit: float = 60.0, workers: int = 4, hint: Plan | None = None,
+                 unit_floor: dict[str, int] | None = None) -> Solution:
+    sol = solve(task, time_limit=time_limit, workers=workers, hint=hint, unit_floor=unit_floor)
+    if sol.plan is not None:
+        res = evaluate(task, sol.plan)
+        if not res.feasible or res.cost != sol.cost:
+            raise AssertionError(f"{task.task_id}: solver plan re-checks to feasible={res.feasible} cost={res.cost}, "
+                                 f"solver said {sol.cost}: {res.violations[:3]}")
+    return sol

openenv.yaml

@@ -0,0 +1,38 @@
+spec_version: 1
+name: rail_ops
+type: space
+runtime: fastapi
+app: rail_openenv.server:app
+port: 7860
+description: Rail dispatch on Arriva's single-track Groningen - Leeuwarden line (Netherlands) on real January-June 2025 days - hold, short-turn and cancel trains so opposing trains cross safely after real breakdowns, collisions, signal and points failures (and seeded ones drawn from the 2024-2025 disruption record); graded once on submit against the CP-SAT optimum. 45 eval tasks on held-out weeks, chosen for hardness, and a train pack on the other days.
+version: "0.1.0"
+variables:
+  RAIL_TASKS_DIR: ""          # colon-separated pack directories; defaults to tasks/rail-v1-eval:tasks/rail-v1-train
+  RAIL_MAX_CHECKS: "10"
+  RAIL_MAX_TOOL_CALLS: "24"
+  MAX_CONCURRENT_ENVS: "64"
+validation:
+  reward:
+    range: [0.0, 1.0]
+    # oracle/solve.py submits the CP-SAT optimum and scores exactly 1.0; no plan scores 0, any rule broken < 0.2
+    oracle_tolerance: 0.001
+    floor_margin: 0.5
+  resources:
+    # pure Python: the grader re-simulates a plan in milliseconds, CP-SAT never runs on the server
+    cpu: 2.0
+    memory_mb: 2048
+    disk_mb: 1024
+    episode_timeout_s: 3600.0
+  network:
+    mode: no-network
+  capabilities:
+    verifier:
+      kind: reward_channel
+    oracle:
+      form: script
+      location: oracle/solve.py
+    rubric_tree: true
+    task_api: true
+    declared_tools: [get_situation, check_plan, submit_plan]
+  types:
+    tags: [simulation, railway, dispatching, scheduling, operations-research, mcp, real-world-data]

openenv/rail_openenv/environment.py

@@ -0,0 +1,266 @@
+"""The OpenEnv environment: one dispatching episode per session, three MCP tools.
+
+    get_situation()      the line, closures, trains (timetables, positions, delays) and train sets
+    check_plan(plan)     simulates a draft: every train's times, the rules it breaks and the cost (budgeted; never a
+                         score or a reference)
+    submit_plan(plan)    the final answer: ends the episode; the rubric grades it once
+
+`reset(task_id=...)` or `reset(split=, index=)` (or `seed=` for a random task) picks a task. Tasks are served through
+OpenEnv's Task API (`list_splits`, `num_tasks`, `get_task`, `get_task_range`). The reward is `RailPlanRubric` applied
+to the `submit_plan` action; every other step has reward 0.0. An episode that runs out of tool calls ends with 0.0.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import random
+import threading
+import time
+import uuid
+from collections import OrderedDict
+from typing import Annotated, Any
+
+from fastmcp import FastMCP
+from openenv.core.env_server.mcp_environment import MCPEnvironment
+from openenv.core.env_server.mcp_types import CallToolAction
+from openenv.core.env_server.types import Action, EnvironmentMetadata, Observation, State
+from pydantic import Field
+
+from rail_core import (PROMPT_VERSION, PlanError, Task, TaskPack, load_pack, parse_plan, plan_report, plan_to_list,
+                       rules, situation)
+
+try:
+    from .rubric import SUBMIT_TOOL, RailPlanRubric
+except ImportError:  # flat layout
+    from rubric import SUBMIT_TOOL, RailPlanRubric
+
+MAX_CHECKS = int(os.environ.get("RAIL_MAX_CHECKS", "10"))
+MAX_TOOL_CALLS = int(os.environ.get("RAIL_MAX_TOOL_CALLS", "24"))
+
+PlanArg = Annotated[list[dict[str, Any]] | str, Field(
+    description='one entry per train you change, e.g. [{"train": "37413", "to": "HDG"}, '
+                '{"train": "37424", "from": "HDG", "hold": {"HDG": "07:31"}}, {"train": "37419", "cancel": true}]; '
+                'trains not listed run in full, as early as they can')]
+
+
+class RailState(State):
+    task_id: str | None = None
+    split: str | None = None
+    checks_used: int = 0
+    tool_calls: int = 0
+    done: bool = False
+    reward: float | None = None
+    grade: dict | None = None
+
+
+class Episode:
+    """Everything one episode did (bounded store, newest first), for /api/episodes."""
+
+    def __init__(self, task: Task, episode_id: str):
+        self.task = task
+        self.episode_id = episode_id
+        self.started = time.time()
+        self.steps: list[dict] = []
+        self.done = False
+        self.grade: dict | None = None
+        self.end_reason: str | None = None
+
+    def summary(self) -> dict:
+        return {"episode_id": self.episode_id, "task_id": self.task.task_id, "started": self.started,
+                "done": self.done, "end_reason": self.end_reason, "steps": self.steps, "grade": self.grade}
+
+
+class _Store:
+    def __init__(self, cap: int = 200):
+        self.cap = cap
+        self._d: OrderedDict[str, Episode] = OrderedDict()
+        self._lock = threading.Lock()
+
+    def add(self, ep: Episode):
+        with self._lock:
+            self._d[ep.episode_id] = ep
+            while len(self._d) > self.cap:
+                self._d.popitem(last=False)
+
+    def get(self, eid: str) -> Episode | None:
+        return self._d.get(eid)
+
+    def recent(self, n: int = 50) -> list[Episode]:
+        return list(reversed(self._d.values()))[:n]
+
+
+STORE = _Store()
+
+
+def _json(obj: Any) -> str:
+    return json.dumps(obj, ensure_ascii=False, separators=(",", ":"))
+
+
+class RailOpsEnvironment(MCPEnvironment):
+    """Re-plan Arriva's trains on the single-track Groningen - Leeuwarden line on a real 2025 day."""
+
+    SUPPORTS_CONCURRENT_SESSIONS = True
+
+    def get_metadata(self) -> EnvironmentMetadata:
+        return EnvironmentMetadata(
+            name="RailSimEnv v1",
+            description="Dispatch Arriva's trains on the single-track Groningen - Leeuwarden line (Netherlands) on a "
+                        "real 2025 day: real timetables, delays and disruptions from the Rijden de Treinen record. "
+                        "Hold, short-turn or cancel trains so they cross safely. Tools: get_situation, check_plan "
+                        "(10 per episode), submit_plan (graded once, deterministically, against the CP-SAT optimum).",
+            version="1.0.0",
+            author="RLSimEnv",
+        )
+
+    def __init__(self, pack: TaskPack | None = None):
+        self.pack = pack or load_pack()
+        self._episode: Episode | None = None
+        self._state = RailState()
+        mcp = FastMCP("rail_ops")
+
+        @mcp.tool
+        def get_situation() -> str:
+            """The line, what has happened (closures), every train to plan and every train set."""
+            ep = self._require()
+            return situation(ep.task)
+
+        @mcp.tool
+        def check_plan(plan: PlanArg) -> str:
+            """Simulate your plan: every train's times, its delay and the stops it loses, every rule it breaks, and
+            the cost. Uses one of your checks. It does not grade the plan."""
+            ep = self._require(open_only=True)
+            if self._state.checks_used >= MAX_CHECKS:
+                return _json({"error": f"no checks left (you had {MAX_CHECKS}); submit_plan when ready"})
+            self._state.checks_used += 1
+            try:
+                parsed, problems = parse_plan(ep.task, plan)
+            except PlanError as e:
+                out = {"error": str(e), "checks_left": MAX_CHECKS - self._state.checks_used}
+                ep.steps.append({"turn": self._state.tool_calls, "tool": "check_plan", "plan": None, "result": out})
+                return _json(out)
+            out = plan_report(ep.task, parsed, problems)
+            out["checks_left"] = MAX_CHECKS - self._state.checks_used
+            ep.steps.append({"turn": self._state.tool_calls, "tool": "check_plan", "plan": plan_to_list(parsed),
+                             "result": {k: v for k, v in out.items() if k != "trains"}})
+            return _json(out)
+
+        @mcp.tool
+        def submit_plan(plan: PlanArg) -> str:
+            """Submit your final plan. Ends the episode; the plan is graded once."""
+            ep = self._require(open_only=True)
+            try:
+                parsed, problems = parse_plan(ep.task, plan)
+            except PlanError as e:
+                parsed, problems = {}, [str(e)]
+            # The rubric grades the same arguments again in step(); this result is what the agent reads.
+            g = self.rubric.graded(CallToolAction(tool_name=SUBMIT_TOOL, arguments={"plan": plan}))
+            ep.done = True
+            ep.end_reason = "submitted"
+            ep.grade = g.as_dict() if g else None
+            ep.steps.append({"turn": self._state.tool_calls, "tool": "submit_plan", "plan": plan_to_list(parsed),
+                             "result": {"grade": ep.grade}})
+            out = {"submitted": True, "feasible": g.feasible if g else False, "reward": g.reward if g else 0.0}
+            if g and g.feasible:
+                out.update(cost=g.cost, delay_cost=g.delay_cost, unserved_stops_cost=g.cancel_cost,
+                           handed_on_cost=g.carry_cost, cancelled=g.cancelled, short_turned=g.short_turned)
+            elif g:
+                out.update(violations=g.violations[:20], entry_problems=g.parse_problems)
+            return _json(out)
+
+        super().__init__(mcp)
+        self.rubric = RailPlanRubric()
+
+    # ------------------------------------------------------------ Task API
+
+    def list_splits(self):
+        return [{"name": s, "type": s, "num_tasks": self.pack.count(s)} for s in self.pack.splits()]
+
+    def num_tasks(self, split):
+        return self.pack.count(split)
+
+    def get_task(self, split, index):
+        return self.pack.public(self.pack.at(split, int(index)))
+
+    def get_task_range(self, split, start=None, stop=None):
+        n = self.pack.count(split)
+        start, stop = int(start or 0), int(n if stop is None else stop)
+        return [self.pack.public(self.pack.at(split, i)) for i in range(max(0, start), min(n, stop))]
+
+    def list_tasks(self, split):
+        return self.get_task_range(split)
+
+    # ------------------------------------------------------------ lifecycle
+
+    def reset(self, seed: int | None = None, episode_id: str | None = None, split: str | None = None,
+              index: int | None = None, task_id: str | None = None, **kwargs: Any) -> Observation:
+        if task_id is not None:
+            task = self.pack.get(task_id)
+        else:
+            split = split or ("train" if "train" in self.pack.splits() else self.pack.splits()[0])
+            n = self.pack.count(split)
+            index = random.Random(seed).randrange(n) if index is None else int(index)
+            task = self.pack.at(split, index)
+        ep = Episode(task, str(episode_id)[:64] if episode_id else uuid.uuid4().hex[:12])
+        STORE.add(ep)
+        self._episode = ep
+        self._state = RailState(episode_id=ep.episode_id, step_count=0, task_id=task.task_id, split=task.split)
+        self._reset_rubric()
+        self.rubric.set_task(task)
+        return Observation(done=False, reward=None, metadata={
+            "episode_id": ep.episode_id,
+            "task_id": task.task_id,
+            "split": task.split,
+            "difficulty": task.difficulty,
+            "instructions": rules(task, MAX_CHECKS),
+            "situation": situation(task),
+            "max_checks": MAX_CHECKS,
+            "max_tool_calls": MAX_TOOL_CALLS,
+            "tools": ["get_situation", "check_plan", "submit_plan"],
+            "prompt_version": PROMPT_VERSION,
+        })
+
+    def _require(self, open_only: bool = False) -> Episode:
+        if self._episode is None:
+            raise ValueError("no episode: call reset first")
+        if open_only and self._episode.done:
+            raise ValueError("the episode is over: the plan was already submitted")
+        return self._episode
+
+    @property
+    def state(self) -> RailState:
+        return self._state
+
+    # ------------------------------------------------------------ stepping
+
+    def _after_step(self, action: Action, obs: Observation) -> Observation:
+        ep = self._episode
+        if ep is None or not isinstance(action, CallToolAction):
+            return obs
+        self._state.tool_calls += 1
+        self._state.step_count += 1
+        obs.reward = self._apply_rubric(action, obs)  # 0.0 unless this was submit_plan
+        if ep.done:
+            g = self.rubric.last_grade
+            obs.done = True
+            obs.metadata = {**(obs.metadata or {}), "grade": g.as_dict() if g else ep.grade,
+                            "rubric": {name: r.last_score for name, r in self.rubric.named_rubrics()},
+                            "episode_id": ep.episode_id}
+            self._state.done, self._state.reward = True, obs.reward
+            self._state.grade = obs.metadata["grade"]
+        elif self._state.tool_calls >= MAX_TOOL_CALLS:
+            ep.done, ep.end_reason = True, "tool_call_limit"
+            obs.done, obs.reward = True, 0.0
+            obs.metadata = {**(obs.metadata or {}), "end_reason": "tool_call_limit", "episode_id": ep.episode_id}
+            self._state.done, self._state.reward = True, 0.0
+        return obs
+
+    def step(self, action: Action, timeout_s: float | None = None, **kwargs: Any) -> Observation:
+        return self._after_step(action, super().step(action, timeout_s=timeout_s, **kwargs))
+
+    async def step_async(self, action: Action, timeout_s: float | None = None, **kwargs: Any) -> Observation:
+        return self._after_step(action, await super().step_async(action, timeout_s=timeout_s, **kwargs))
+
+    def _step_impl(self, action: Action, timeout_s: float | None = None, **kwargs) -> Observation:
+        return Observation(done=False, reward=0.0,
+                           metadata={"error": "use the MCP tools: get_situation, check_plan, submit_plan"})

openenv/rail_openenv/gradio_ui.py

@@ -0,0 +1,37 @@
+"""The "Explore" tab of OpenEnv's web UI (/web): the eval explorer, the 3D replay and the train graph, each the
+server's own page in a frame, one tab each. OpenEnv's Playground tab (reset, step and the MCP tools) stays next to it.
+
+A frame is only created when its tab is first opened, so the 3D replay does not start WebGL in a hidden tab.
+"""
+
+from __future__ import annotations
+
+import html
+
+import gradio as gr
+
+PAGES = [("Eval explorer", "/explorer/?embed=1"), ("3D replay", "/twin/"), ("Train graph", "/viewer/?embed=1")]
+# OpenEnv's page caps the container width; the pages want the full window.
+STYLE = ("<style>.gradio-container .main.fillable{max-width:none!important;padding-left:12px!important;"
+         "padding-right:12px!important}.gradio-container .html-container:has(iframe){padding:0!important}</style>")
+
+
+def frame(src: str, title: str) -> str:
+    return (f'{STYLE}<iframe src="{html.escape(src)}" title="RailSimEnv {html.escape(title)}" allow="fullscreen" '
+            'style="width:100%;height:calc(100vh - 190px);min-height:720px;border:0;display:block"></iframe>')
+
+
+def build_ui(*_args, **_kwargs) -> gr.Blocks:
+    """OpenEnv's `gradio_builder` hook; its arguments (web manager, action fields, metadata, ...) are not needed."""
+    with gr.Blocks(title="RailSimEnv v1") as ui:
+        with gr.Tabs():
+            for i, (name, src) in enumerate(PAGES):
+                with gr.Tab(name) as tab:
+                    out = gr.HTML(frame(src, name) if i == 0 else "")
+                    loaded = gr.State(i == 0)
+
+                    def show(done: bool, src: str = src, name: str = name):
+                        return (gr.update(), True) if done else (frame(src, name), True)
+
+                    tab.select(show, inputs=loaded, outputs=[out, loaded])
+    return ui

openenv/rail_openenv/rubric.py

@@ -0,0 +1,99 @@
+"""The reward as OpenEnv rubrics (RFC 004).
+
+`RailPlanRubric` scores the `submit_plan` call and returns 0.0 for every other action, so the grader runs once per
+episode. Its two children are the inputs of the score and show up in `named_rubrics()` with their `last_score`:
+
+    runs_clean     fraction of runs with no rule broken (entry problems count as unclean)
+    cost_quality   exp(-g / 0.5), g the gap to the proven optimum over the avoidable cost; 0 when infeasible
+
+The combination is `rail_core.reward.score` (infeasible: 0.2 x runs_clean; feasible: 0.2 + 0.8 x cost_quality),
+shared with the offline grader so the two can never disagree.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from openenv.core.env_server.mcp_types import CallToolAction
+from openenv.core.rubrics import Rubric
+
+from rail_core import Grade, PlanError, Task, grade, parse_plan
+
+SUBMIT_TOOL = "submit_plan"
+
+
+def submitted_plan(action: Any):
+    if isinstance(action, CallToolAction) and action.tool_name == SUBMIT_TOOL:
+        return (action.arguments or {}).get("plan")
+    return None
+
+
+class _Graded(Rubric):
+    """Grades the submitted plan once per action and shares the result with sibling rubrics."""
+
+    def __init__(self):
+        super().__init__()
+        self.task: Task | None = None
+        self._cache: tuple[int, Grade | None] | None = None
+
+    def graded(self, action: Any) -> Grade | None:
+        if self._cache is not None and self._cache[0] == id(action):
+            return self._cache[1]
+        raw = submitted_plan(action)
+        g = None
+        if raw is not None and self.task is not None:
+            try:
+                plan, problems = parse_plan(self.task, raw)
+            except PlanError as e:
+                plan, problems = {}, [str(e)]
+            g = grade(self.task, plan, problems)
+        self._cache = (id(action), g)
+        return g
+
+
+class RunsClean(Rubric):
+    def __init__(self, source: _Graded):
+        super().__init__()
+        object.__setattr__(self, "_source", source)  # not a child: avoid a cycle in named_rubrics()
+
+    def forward(self, action, observation) -> float:
+        g = self._source.graded(action)
+        return 0.0 if g is None else g.clean_fraction
+
+
+class CostQuality(Rubric):
+    def __init__(self, source: _Graded):
+        super().__init__()
+        object.__setattr__(self, "_source", source)
+
+    def forward(self, action, observation) -> float:
+        g = self._source.graded(action)
+        return 0.0 if g is None else g.quality
+
+
+class RailPlanRubric(_Graded):
+    """Terminal reward for a dispatch plan: 0.0 until `submit_plan`, then the score in [0, 1]."""
+
+    def __init__(self):
+        super().__init__()
+        self.runs_clean = RunsClean(self)
+        self.cost_quality = CostQuality(self)
+        self.last_grade: Grade | None = None
+
+    def set_task(self, task: Task) -> None:
+        self.task = task
+        self._cache = None
+        self.last_grade = None
+
+    def forward(self, action, observation) -> float:
+        g = self.graded(action)
+        self.runs_clean(action, observation)
+        self.cost_quality(action, observation)
+        if g is None:
+            return 0.0
+        self.last_grade = g
+        return g.reward
+
+    def reset(self) -> None:
+        self._cache = None
+        self.last_grade = None

openenv/rail_openenv/server.py

@@ -0,0 +1,338 @@
+"""The server: OpenEnv's app plus the map replay, a train-graph viewer and their read-only JSON on the same port.
+
+OpenEnv provides `/reset`, `/step`, `/state`, `/schema`, `/ws`, `/mcp`, `/health`, the Task API under `/rail_ops/...`
+and its web UI at `/web`, where an "Explore" tab (`gradio_ui.py`) frames the pages below next to OpenEnv's Playground.
+We add:
+
+    /twin/                                the map replay: trains moving on the line's OpenStreetMap track, any plan
+    /viewer/                              a train graph (time against distance) of any plan, live episodes too
+    /explorer/                            the eval explorer: the board and every model's plan on every eval task
+    /api/tasks                            task summaries, with the lazy baselines' rewards
+    /api/runs                             the committed model runs: each episode's reward and outcome, and a board
+    /api/tasks/{id}                       a public task (what the agent sees, structured)
+    /api/tasks/{id}/reference             optimum, floor, baselines and the real outcome - for people; no tool shows them
+    /api/tasks/{id}/timeline?plan=...     paths for the graph: plan = optimal | naive | greedy | greedy_fast
+    /api/episodes                         live episodes on this server (newest first)
+    /api/episodes/{episode_id}/timeline   the latest plan an episode checked or submitted, as paths
+    /api/tasks/{id}/plans                 the plans the replay can show: optimum, baselines, models' submitted plans
+                                          (from results/rollouts/*/index.json, or RAIL_RUNS_DIR), live episodes
+    /api/tasks/{id}/replay?plan=...       everything the replay animates (rail_core.replay)
+    /api/episodes/{episode_id}/replay     the same for the latest plan of a live episode
+
+    uvicorn rail_openenv.server:app --port 8000
+
+`/` is OpenEnv's: it redirects to the web UI (`/web/`), or to `/explorer/` when ENABLE_WEB_INTERFACE is false.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import random
+import statistics
+from functools import lru_cache
+from pathlib import Path
+
+from fastapi import HTTPException
+from fastapi.responses import RedirectResponse
+from fastapi.staticfiles import StaticFiles
+from openenv.core.env_server.http_server import create_app
+from openenv.core.env_server.mcp_types import CallToolAction, CallToolObservation
+
+from rail_core import TaskPack, evaluate, hhmm, load_pack, parse_plan
+from rail_core.baselines import POLICIES
+from rail_core.check import network
+from rail_core.replay import replay
+
+try:
+    from .environment import STORE, RailOpsEnvironment, RailState
+    from .gradio_ui import build_ui
+except ImportError:
+    from environment import STORE, RailOpsEnvironment, RailState
+    from gradio_ui import build_ui
+
+ENV_NAME = "rail_ops"
+WEB = Path(__file__).resolve().parent / "web"
+RUNS_DIR = Path(os.environ.get("RAIL_RUNS_DIR", Path(__file__).resolve().parents[4] / "results" / "rollouts"))
+BASELINES = {"greedy": "greedy dispatcher", "greedy_fast": "greedy dispatcher (turns early)",
+             "naive": "change nothing"}
+
+
+TIERS = ("real", "blockage", "loop", "compound")
+PROVIDERS = {"together": "Together", "baseten": "Baseten", "novita": "Novita", "deepinfra": "DeepInfra",
+             "fireworks": "Fireworks"}
+
+
+def model_name(spec: str) -> str:
+    """A person's name for a run's model spec: "hf:Qwen/Qwen3.8-2.4T-A95B:together@default" -> "Qwen3.8-2.4T-A95B
+    (Together)", "claude-sonnet-5-5@high" -> "Claude Sonnet 5.5 (effort high)"."""
+    model, _, effort = spec.partition("@")
+    if model.startswith("hf:"):
+        repo, _, provider = model[3:].partition(":")
+        name = repo.split("/")[-1]
+        return f"{name} ({PROVIDERS.get(provider, provider)})" if provider else name
+    if model.startswith("claude-"):
+        parts = model.split("-")[1:]
+        family = " ".join(p.capitalize() for p in parts if not p.isdigit())
+        version = ".".join(p for p in parts if p.isdigit())
+        name = f"Claude {family} {version}".strip()
+        return f"{name} (effort {effort})" if effort and effort != "default" else name
+    return model
+
+
+def load_runs(runs_dir: Path = RUNS_DIR) -> list[dict]:
+    """The committed rollout runs (results/rollouts/*/index.json): [{run, episodes}]."""
+    out = []
+    for idx in sorted(runs_dir.glob("*/index.json")) if runs_dir.is_dir() else []:
+        try:
+            body = json.loads(idx.read_text())
+        except (OSError, ValueError):
+            continue
+        out.append({"run": body["run"], "episodes": body.get("episodes", [])})
+    return out
+
+
+def run_plans(runs_dir: Path = RUNS_DIR) -> dict[str, list[dict]]:
+    """Submitted plans in the committed rollout runs, by task: [{id, label, model, run, reward, plan}]."""
+    out: dict[str, list[dict]] = {}
+    for body in load_runs(runs_dir):
+        for e in body["episodes"]:
+            if e.get("plan") is None:
+                continue
+            out.setdefault(e["task_id"], []).append(
+                {"id": f"run:{body['run']}:{e['model']}", "label": model_name(e["model"]),
+                 "model": e["model"], "run": body["run"], "reward": e.get("reward"), "plan": e["plan"]})
+    for entries in out.values():                     # two runs of one model on a task: name the run too
+        for e in entries:
+            if sum(x["model"] == e["model"] for x in entries) > 1:
+                e["label"] = f"{e['label']} ({e['run']})"
+    return out
+
+
+def ci(xs, n=2000, seed=0):
+    """95 % bootstrap interval of the mean, the same as eval/report.py's (so the numbers match the README)."""
+    xs = sorted(xs)
+    rng = random.Random(seed)
+    means = sorted(statistics.mean(rng.choices(xs, k=len(xs))) for _ in range(n))
+    return means[int(0.025 * n)], means[int(0.975 * n)]
+
+
+def runs_summary(runs: list[dict]) -> dict:
+    """What the eval explorer shows: one row per (run, model) with the board's columns, and every episode's outcome."""
+    rows, episodes = [], []
+    for body in runs:
+        by: dict[str, list[dict]] = {}
+        for e in body["episodes"]:
+            by.setdefault(e["model"], []).append(e)
+        for model, es in by.items():
+            r = [e["reward"] for e in es]
+            lo, hi = ci(r)
+            real = [e for e in es if e["difficulty"] == "real" and e.get("real_cost") is not None]
+            rows.append({
+                "run": body["run"], "model": model, "name": model_name(model), "split": es[0]["split"],
+                "n": len(es), "mean": statistics.mean(r), "ci": [lo, hi],
+                "tiers": {t: statistics.mean(x["reward"] for x in es if x["difficulty"] == t)
+                          for t in TIERS if any(x["difficulty"] == t for x in es)},
+                "feasible": sum(bool(e["feasible"]) for e in es),
+                "optimal": sum(1 for e in es if e["feasible"] and e["cost"] == e["optimal_cost"]),
+                "no_submit": sum(not e["submitted"] for e in es),
+                "beat_real": sum(1 for e in real if e["feasible"] and e["cost"] < e["real_cost"]), "real": len(real),
+                "median_turns": statistics.median(e["agent_turns"] for e in es)})
+            for e in es:
+                episodes.append({k: e.get(k) for k in ("model", "task_id", "reward", "feasible", "submitted", "cost",
+                                                       "optimal_cost", "end_reason", "agent_turns", "checks",
+                                                       "violations")}
+                                | {"run": body["run"], "plan_id": f"run:{body['run']}:{model}"
+                                   if e.get("plan") is not None else None})
+    rows.sort(key=lambda x: (x["split"], -x["mean"]))
+    return {"models": rows, "episodes": episodes}
+
+
+def _summary(t, plans: dict | None = None) -> dict:
+    ref = t.reference
+    return {"task_id": t.task_id, "split": t.split, "day": t.day, "start": hhmm(t.start), "end": hhmm(t.end),
+            "difficulty": t.difficulty, "runs": len(t.runs), "closures": [c.kind for c in t.closures],
+            "causes": sorted({c.cause for c in t.closures if c.cause}),
+            "model_plans": len((plans or {}).get(t.task_id, [])), "optimal_cost": ref.get("optimal_cost"),
+            "rewards": {"greedy": ref.get("greedy_reward"), "greedy_fast": ref.get("greedy_fast_reward"),
+                        "naive": ref.get("naive_reward"), "real": (ref.get("real") or {}).get("reward_if_legal")}}
+
+
+def timeline(task, plan) -> dict:
+    """Every served run as a path of (km, minute) points, for a time-distance graph."""
+    net = network(task)
+    res = evaluate(task, plan)
+    paths = []
+    for x in res.runs:
+        if x.cancelled:
+            paths.append({"train": x.train, "set": x.unit, "cancelled": True, "points": []})
+            continue
+        r = task.run(x.train)
+        pts = []
+        for i in sorted(set(x.arr) | set(x.dep)):
+            km = net.by_code[r.route[i]].km
+            if i in x.arr:
+                pts.append([km, x.arr[i]])
+            if i in x.dep and x.dep[i] != x.arr.get(i):
+                pts.append([km, x.dep[i]])
+        paths.append({"train": x.train, "set": x.unit, "kind": r.kind, "points": pts, "delay": x.delay,
+                      "unserved": x.unserved, "problems": x.problems})
+    return {"task_id": task.task_id, "start": task.start, "end": task.end,
+            "points": [{"code": p.code, "km": p.km, "kind": p.kind, "tracks": p.tracks} for p in net.points],
+            "sections": [{"a": s.a, "b": s.b, "single": s.single} for s in net.sections],
+            "closures": [{"kind": c.kind, "where": c.where, "start": c.start, "end": c.end, "cause": c.cause}
+                         for c in task.closures],
+            "paths": paths, "feasible": res.feasible, "cost": res.cost, "violations": res.violations[:50],
+            "optimal_cost": task.reference.get("optimal_cost")}
+
+
+def mount_api(app, pack: TaskPack) -> None:
+    plans_by_task = run_plans()
+    runs = runs_summary(load_runs())
+
+    @app.get("/api/tasks", include_in_schema=False)
+    def tasks():
+        return [_summary(t, plans_by_task) for t in pack.tasks]
+
+    @app.get("/api/runs", include_in_schema=False)
+    def model_runs():
+        return runs
+
+    def _task(task_id):
+        try:
+            return pack.get(task_id)
+        except KeyError:
+            raise HTTPException(404, f"no task {task_id}") from None
+
+    @app.get("/api/tasks/{task_id}", include_in_schema=False)
+    def task(task_id: str):
+        return pack.public(_task(task_id))
+
+    @app.get("/api/tasks/{task_id}/reference", include_in_schema=False)
+    def reference(task_id: str):
+        return _task(task_id).reference
+
+    @app.get("/api/tasks/{task_id}/timeline", include_in_schema=False)
+    def task_timeline(task_id: str, plan: str = "optimal"):
+        t = _task(task_id)
+        if plan == "optimal":
+            p, _ = parse_plan(t, t.reference["optimal_plan"])
+        elif plan in POLICIES:
+            p = POLICIES[plan](t)
+        else:
+            raise HTTPException(400, "plan must be optimal, naive, greedy or greedy_fast")
+        return timeline(t, p)
+
+    def _plan(t, plan_id: str):
+        """(plan, parse problems, label) for a plan id."""
+        if plan_id == "optimal":
+            p, probs = parse_plan(t, t.reference["optimal_plan"])
+            return p, probs, "CP-SAT optimum"
+        if plan_id in POLICIES:
+            return POLICIES[plan_id](t), [], BASELINES.get(plan_id, plan_id)
+        for e in plans_by_task.get(t.task_id, []):
+            if e["id"] == plan_id:
+                p, probs = parse_plan(t, e["plan"])
+                return p, probs, e["label"]
+        raise HTTPException(400, f"unknown plan {plan_id!r}: see /api/tasks/{t.task_id}/plans")
+
+    @lru_cache(maxsize=256)
+    def _replay(task_id: str, plan_id: str) -> dict:
+        t = _task(task_id)
+        p, probs, label = _plan(t, plan_id)
+        return replay(t, p, label, probs) | {"plan_id": plan_id}
+
+    @app.get("/api/tasks/{task_id}/plans", include_in_schema=False)
+    def task_plans(task_id: str):
+        t = _task(task_id)
+        ref = t.reference
+        out = [{"id": "optimal", "label": "CP-SAT optimum", "reward": 1.0, "cost": ref.get("optimal_cost")}]
+        out += [{"id": k, "label": v, "reward": ref.get(f"{k}_reward"),
+                 "cost": ref.get(f"{k}_cost") if ref.get(f"{k}_feasible") else None} for k, v in BASELINES.items()]
+        out += [{k: e[k] for k in ("id", "label", "reward")} for e in plans_by_task.get(task_id, [])]
+        out += [{"id": f"episode:{ep.episode_id}", "label": f"live episode {ep.episode_id}", "reward": None}
+                for ep in STORE.recent() if ep.task.task_id == task_id]
+        return out
+
+    @app.get("/api/tasks/{task_id}/replay", include_in_schema=False)
+    def task_replay(task_id: str, plan: str = "optimal"):
+        if plan.startswith("episode:"):
+            return episode_replay(plan.split(":", 1)[1])
+        return _replay(task_id, plan)
+
+    @app.get("/api/episodes/{episode_id}/replay", include_in_schema=False)
+    def episode_replay(episode_id: str):
+        ep = STORE.get(episode_id)
+        if ep is None:
+            raise HTTPException(404, f"no episode {episode_id}")
+        last = next((s for s in reversed(ep.steps) if s.get("plan") is not None), None)
+        p, probs = parse_plan(ep.task, last["plan"]) if last else ({}, [])
+        return replay(ep.task, p, f"live episode {episode_id}", probs) | {"plan_id": f"episode:{episode_id}"}
+
+    @app.get("/api/episodes", include_in_schema=False)
+    def episodes():
+        return [{k: v for k, v in ep.summary().items() if k != "steps"} | {"steps": len(ep.steps)}
+                for ep in STORE.recent()]
+
+    @app.get("/api/episodes/{episode_id}/timeline", include_in_schema=False)
+    def episode_timeline(episode_id: str):
+        ep = STORE.get(episode_id)
+        if ep is None:
+            raise HTTPException(404, f"no episode {episode_id}")
+        last = next((s for s in reversed(ep.steps) if s.get("plan") is not None), None)
+        p, _ = parse_plan(ep.task, last["plan"]) if last else ({}, [])
+        return timeline(ep.task, p) | {"episode": {k: v for k, v in ep.summary().items() if k != "steps"}}
+
+    if (WEB / "twin").is_dir():
+        app.mount("/twin", StaticFiles(directory=WEB / "twin", html=True), name="twin")
+    if (WEB / "explorer").is_dir():
+        app.mount("/explorer", StaticFiles(directory=WEB / "explorer", html=True), name="explorer")
+    if WEB.is_dir():
+        app.mount("/viewer", StaticFiles(directory=WEB, html=True), name="viewer")
+
+        @app.get("/", include_in_schema=False)
+        def root():
+            return RedirectResponse("/explorer/" if (WEB / "explorer" / "index.html").is_file() else "/twin/")
+
+
+def create_server(pack: TaskPack | None = None):
+    pack = pack or load_pack()
+
+    def factory():
+        return RailOpsEnvironment(pack)
+
+    os.environ.setdefault("ENABLE_WEB_INTERFACE", "true")
+    app = create_app(factory, CallToolAction, CallToolObservation, env_name=ENV_NAME,
+                     max_concurrent_envs=int(os.environ.get("MAX_CONCURRENT_ENVS", "64")),
+                     gradio_builder=build_ui, custom_tab_name="Explore", custom_tab_primary=True,
+                     show_default_tab=True, title_override="RailSimEnv v1 Environment", state_cls=RailState)
+    mount_api(app, pack)
+
+    @app.get("/healthz", include_in_schema=False)
+    def healthz():
+        return {"status": "ok", "tasks": {s: pack.count(s) for s in pack.splits()}}
+
+    return app
+
+
+_app = None
+
+
+def __getattr__(name: str):
+    global _app
+    if name == "app":
+        if _app is None:
+            _app = create_server()
+        return _app
+    raise AttributeError(name)
+
+
+def main(host: str = "0.0.0.0", port: int | None = None) -> None:
+    import uvicorn
+
+    port = port or int(os.environ.get("PORT", "8000"))
+    uvicorn.run(create_server(), host=host, port=port, ws_ping_interval=60, ws_ping_timeout=300)
+
+
+if __name__ == "__main__":
+    main()

openenv/rail_openenv/session.py

@@ -0,0 +1,115 @@
+"""A client session on a RailSimEnv server (OpenEnv's MCP client over its WebSocket), for scripts and agents.
+
+    env = EnvSession("http://127.0.0.1:8000")          # or LocalSession(pack): the same tools, in this process
+    meta = env.reset("gnlw-2025-03-13-0703-real-0")      # metadata["instructions"] is the system prompt
+    text, done, reward, meta = env.call("submit_plan", {"plan": [...]})
+"""
+
+from __future__ import annotations
+
+import json
+
+from openenv.core.env_server.mcp_types import CallToolAction
+from openenv.core.mcp_client import MCPToolClient
+
+
+class EnvSession:
+    """One WebSocket session (one episode at a time)."""
+
+    def __init__(self, base_url: str, timeout_s: float = 300.0):
+        self.client = MCPToolClient(base_url.rstrip("/"), message_timeout_s=timeout_s).sync()
+        self._tools = None
+
+    def reset(self, task_id: str | None = None, **kw) -> dict:
+        if task_id is not None:
+            kw["task_id"] = task_id
+        return dict(self.client.reset(**kw).observation.metadata or {})
+
+    @property
+    def tools(self):
+        if self._tools is None:
+            self._tools = self.client.list_tools()
+        return self._tools
+
+    def call(self, name: str, arguments: dict) -> tuple[str, bool, float | None, dict]:
+        """(tool result text, done, reward, observation metadata)."""
+        step = self.client.step(CallToolAction(tool_name=name, arguments=arguments))
+        obs = step.observation
+        err = getattr(obs, "error", None)
+        res = getattr(obs, "result", None)
+        text = None
+        if isinstance(res, dict):
+            blocks = res.get("content") or []
+            text = "\n".join(b.get("text", "") for b in blocks if b.get("type") == "text") or None
+            if text is None and res.get("data") is not None:
+                text = res["data"] if isinstance(res["data"], str) else json.dumps(res["data"])
+        elif res is not None:
+            data = getattr(res, "data", None)
+            text = data if isinstance(data, str) else json.dumps(data) if data is not None else str(res)
+        if err:
+            msg = err.get("message") if isinstance(err, dict) else getattr(err, "message", str(err))
+            text = json.dumps({"error": str(msg)})
+        reward = step.reward if step.reward is not None else obs.reward
+        return text or "", bool(step.done or obs.done), reward, dict(obs.metadata or {})
+
+    def close(self):
+        try:
+            self.client.close()
+        except Exception:
+            pass
+
+
+def _result_text(res) -> str | None:
+    if res is None:
+        return None
+    if isinstance(res, dict):
+        blocks = res.get("content") or []
+        text = "\n".join(b.get("text", "") for b in blocks if b.get("type") == "text")
+        if text:
+            return text
+        data = res.get("data")
+        return data if isinstance(data, str) else (json.dumps(data) if data is not None else None)
+    content = getattr(res, "content", None)
+    if content:
+        text = "\n".join(getattr(b, "text", "") for b in content)
+        if text:
+            return text
+    data = getattr(res, "data", None)
+    return data if isinstance(data, str) else (json.dumps(data) if data is not None else str(res))
+
+
+class LocalSession:
+    """The environment in this process (no server, no WebSocket): the same tools, results and rubric. For tests,
+    pilots and quick experiments."""
+
+    def __init__(self, pack=None):
+        from openenv.core.env_server.mcp_types import ListToolsAction
+
+        from .environment import RailOpsEnvironment
+
+        self.env = RailOpsEnvironment(pack)
+        self._list = ListToolsAction
+        self._tools = None
+
+    def reset(self, task_id: str | None = None, **kw) -> dict:
+        if task_id is not None:
+            kw["task_id"] = task_id
+        return dict(self.env.reset(**kw).metadata or {})
+
+    @property
+    def tools(self):
+        if self._tools is None:
+            self._tools = self.env.step(self._list()).tools
+        return self._tools
+
+    def call(self, name: str, arguments: dict) -> tuple[str, bool, float | None, dict]:
+        obs = self.env.step(CallToolAction(tool_name=name, arguments=arguments))
+        err = getattr(obs, "error", None)
+        text = _result_text(getattr(obs, "result", None))
+        if err:
+            msg = err.get("message") if isinstance(err, dict) else getattr(err, "message", str(err))
+            text = json.dumps({"error": str(msg)})
+        return text or "", bool(obs.done), obs.reward, dict(obs.metadata or {})
+
+    def close(self):
+        pass

openenv/rail_openenv/web/explorer/index.html

@@ -0,0 +1,313 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>RailSimEnv eval explorer</title>
+<link rel="icon" href="data:,">
+<style>
+  :root {
+    color-scheme: light;
+    --page: #f9f9f7; --surface: #fcfcfb; --ink: #0b0b0b; --ink-2: #52514e; --muted: #898781;
+    --grid: #e1e0d9; --axis: #c3c2b7; --ring: rgba(11, 11, 11, 0.10); --wash: #f0efec;
+    --accent: #2a78d6; --critical: #d03b3b; --good: #0ca30c; --bar: #2a78d6; --ref: #898781;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root:where(:not([data-theme="light"])) {
+      color-scheme: dark;
+      --page: #0d0d0d; --surface: #1a1a19; --ink: #ffffff; --ink-2: #c3c2b7; --muted: #898781;
+      --grid: #2c2c2a; --axis: #383835; --ring: rgba(255, 255, 255, 0.10); --wash: #232321;
+      --accent: #3987e5; --bar: #3987e5;
+    }
+  }
+  :root[data-theme="dark"] {
+    color-scheme: dark;
+    --page: #0d0d0d; --surface: #1a1a19; --ink: #ffffff; --ink-2: #c3c2b7; --muted: #898781;
+    --grid: #2c2c2a; --axis: #383835; --ring: rgba(255, 255, 255, 0.10); --wash: #232321;
+    --accent: #3987e5; --bar: #3987e5;
+  }
+  * { box-sizing: border-box; }
+  [hidden] { display: none !important; }
+  body { margin: 0; background: var(--page); color: var(--ink); font: 14px/1.45 system-ui, -apple-system, "Segoe UI", sans-serif; }
+  a { color: var(--accent); }
+  nav.site { display: flex; gap: 4px 18px; flex-wrap: wrap; align-items: baseline; padding: 12px 16px 0; }
+  nav.site b { font-size: 15px; margin-right: 6px; }
+  nav.site a { color: var(--ink-2); text-decoration: none; padding: 2px 0; border-bottom: 2px solid transparent; }
+  nav.site a:hover { color: var(--ink); }
+  nav.site a[aria-current] { color: var(--ink); border-bottom-color: var(--accent); }
+  main { padding: 16px 16px 32px; max-width: 1320px; margin: 0 auto; }
+  h1 { font-size: 24px; line-height: 1.2; margin: 0 0 6px; font-weight: 650; }
+  h2 { font-size: 17px; margin: 0 0 4px; font-weight: 650; }
+  .lede { color: var(--ink-2); max-width: 88ch; margin: 0 0 16px; }
+  .card { background: var(--surface); border: 1px solid var(--ring); border-radius: 10px; padding: 16px; margin-bottom: 16px; }
+  .note { color: var(--ink-2); font-size: 13px; margin: 0 0 10px; }
+  .seg { display: inline-flex; border: 1px solid var(--axis); border-radius: 8px; overflow: hidden; margin-bottom: 16px; }
+  .seg button { font: inherit; border: 0; background: var(--surface); color: var(--ink-2); padding: 6px 14px; cursor: pointer; }
+  .seg button + button { border-left: 1px solid var(--axis); }
+  .seg button[aria-pressed="true"] { background: var(--accent); color: #fff; }
+  .tablewrap { overflow-x: auto; }
+  table { border-collapse: collapse; width: 100%; font-size: 13px; }
+  th, td { padding: 7px 8px; border-bottom: 1px solid var(--grid); text-align: left; vertical-align: middle; white-space: nowrap; }
+  th { color: var(--ink-2); font-weight: 600; font-size: 12px; }
+  td.n, th.n { text-align: right; font-variant-numeric: tabular-nums; }
+  tr.ref td { color: var(--ink-2); }
+  tr.ref:first-of-type td { border-top: 1px solid var(--axis); }
+  .meanbar { display: inline-flex; align-items: center; gap: 10px; }
+  .meanbar b { font-variant-numeric: tabular-nums; min-width: 40px; display: inline-block; }
+  .meanbar small { color: var(--ink-2); font-variant-numeric: tabular-nums; }
+  .bar { width: 160px; height: 14px; position: relative; flex: none; }
+  .bar .track { position: absolute; inset: 6px 0; background: var(--wash); border-radius: 2px; }
+  .bar .fill { position: absolute; left: 0; top: 3px; height: 8px; background: var(--bar); border-radius: 0 4px 4px 0; }
+  .bar .ci { position: absolute; top: 6px; height: 2px; background: var(--ink); opacity: 0.65; }
+  .bar .ci::before, .bar .ci::after { content: ""; position: absolute; top: -4px; width: 1.5px; height: 10px; background: var(--ink); }
+  .bar .ci::before { left: 0; } .bar .ci::after { right: 0; }
+  tr.ref .bar .fill { background: var(--ref); }
+  .filters { display: flex; flex-wrap: wrap; gap: 8px 16px; align-items: center; margin: 4px 0 12px; }
+  .chips { display: inline-flex; flex-wrap: wrap; gap: 6px; }
+  .chip { font: inherit; font-size: 13px; border: 1px solid var(--axis); background: var(--surface); color: var(--ink-2); border-radius: 999px; padding: 3px 11px; cursor: pointer; }
+  .chip[aria-pressed="true"] { border-color: var(--accent); color: var(--ink); box-shadow: inset 0 0 0 1px var(--accent); }
+  .ramp { display: inline-flex; align-items: center; gap: 6px; font-size: 12px; color: var(--ink-2); }
+  .ramp i { display: inline-block; width: 22px; height: 12px; }
+  .ramp i:first-of-type { border-radius: 3px 0 0 3px; } .ramp i:last-of-type { border-radius: 0 3px 3px 0; }
+  .key { display: inline-flex; align-items: center; gap: 5px; font-size: 12px; color: var(--ink-2); }
+  #grid th.sort { cursor: pointer; user-select: none; }
+  #grid th.sort:hover { color: var(--ink); }
+  #grid th.sorted::after { content: " ↓"; }
+  #grid th.sorted.asc::after { content: " ↑"; }
+  #grid td.cell { padding: 3px; }
+  #grid td.cell button { width: 100%; min-width: 64px; font: inherit; font-size: 13px; font-variant-numeric: tabular-nums; border: 0; border-radius: 5px;
+                         padding: 5px 6px; cursor: pointer; text-align: right; outline-offset: 1px; }
+  #grid td.cell button:hover, #grid td.cell button:focus-visible { outline: 2px solid var(--ink); }
+  #grid td.cell button.sel { outline: 2px solid var(--accent); }
+  #grid td.cell button.illegal { background: var(--wash); color: var(--ink); }
+  #grid td.cell button.illegal::before { content: "✕ "; color: var(--critical); font-weight: 700; }
+  #grid td.cell button.none { background: transparent; color: var(--muted); border: 1px dashed var(--axis); }
+  .tier { display: inline-block; font-size: 11px; padding: 1px 7px; border-radius: 999px; border: 1px solid var(--ring); color: var(--ink-2); }
+  .task small { color: var(--ink-2); }
+  #detail { position: sticky; bottom: 12px; z-index: 3; margin-top: 12px; box-shadow: 0 6px 24px rgba(0, 0, 0, 0.14); }
+  #detail .row { display: flex; flex-wrap: wrap; gap: 8px 22px; align-items: baseline; }
+  #detail .k { font-size: 12px; color: var(--ink-2); display: block; }
+  #detail .v { font-size: 17px; font-weight: 600; font-variant-numeric: tabular-nums; }
+  #detail .links { margin-left: auto; display: flex; gap: 8px; }
+  #detail .links a { padding: 6px 12px; border: 1px solid var(--axis); border-radius: 6px; text-decoration: none; color: var(--ink); background: var(--surface); }
+  #detail .links a.primary { background: var(--accent); border-color: var(--accent); color: #fff; }
+  #detail button.close { font: inherit; background: none; border: 0; color: var(--ink-2); cursor: pointer; font-size: 18px; }
+  footer { color: var(--muted); font-size: 12px; margin-top: 18px; }
+  .err { color: var(--critical); }
+</style>
+</head>
+<body>
+<nav class="site" id="nav">
+  <b>RailSimEnv</b>
+  <a href="/explorer/" aria-current="page">Eval explorer</a>
+  <a href="/twin/">3D replay</a>
+  <a href="/viewer/">Train graph</a>
+  <a href="/web">Environment</a>
+</nav>
+<main>
+  <h1>Eval explorer</h1>
+  <p class="lede">Each task is a real 2025 disruption on the single-track Groningen – Leeuwarden line: hold, short-turn and
+    cancel trains so opposing trains cross safely. Every plan is graded against a proven CP-SAT optimum (reward 1.0); a plan
+    that breaks a rule scores under 0.2. Pick any cell to watch that plan run in 3D or read it on the train graph.</p>
+  <div class="seg" role="group" aria-label="Task split" id="splits"></div>
+
+  <section class="card">
+    <h2>Leaderboard</h2>
+    <p class="note" id="boardnote"></p>
+    <div class="tablewrap"><table id="board"></table></div>
+  </section>
+
+  <section class="card">
+    <h2>Every task, every model</h2>
+    <div class="filters">
+      <div class="chips" id="tiers" role="group" aria-label="Tier"></div>
+      <span class="ramp" id="ramp"></span>
+      <span class="key"><b style="color:var(--critical)">✕</b> breaks a rule</span>
+      <span class="key"><i style="display:inline-block;width:22px;height:12px;border:1px dashed var(--axis);border-radius:3px"></i> no plan submitted</span>
+    </div>
+    <div class="tablewrap"><table id="grid"></table></div>
+    <div class="card" id="detail" hidden></div>
+  </section>
+  <footer>Data: Rijden de Treinen open data (CC BY 4.0, "Rijden de Treinen"); track and map © OpenStreetMap contributors (ODbL 1.0).
+    Rewards are one rollout per model per task.</footer>
+</main>
+<script>
+"use strict";
+const $ = (s) => document.querySelector(s);
+const params = new URLSearchParams(location.search);
+const TIERS = ["real", "blockage", "loop", "compound"];
+const TIER = { real: "real disruption", blockage: "blockage", loop: "lost passing track", compound: "compound" };
+// sequential blue ramp (light to dark) for rewards from 0.2 (legal) to 1.0 (the optimum)
+const RAMP = [["#cde2fb", 0.2], ["#9ec5f4", 0.3], ["#6da7ec", 0.4], ["#3987e5", 0.55], ["#256abf", 0.7], ["#184f95", 0.85], ["#0d366b", 0.999]];
+const S = { runs: null, tasks: [], byTask: {}, split: params.get("split") || "eval", tier: "all", sort: { key: "mean", asc: true }, sel: null };
+
+const esc = (s) => String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+const f3 = (x) => (x === null || x === undefined ? "–" : Number(x).toFixed(3));
+const mean = (xs) => xs.reduce((a, b) => a + b, 0) / Math.max(1, xs.length);
+const shortName = (n) => n.replace(/ \(.*\)$/, "");
+const day = (d) => new Date(`${d}T12:00:00Z`).toLocaleDateString("en-GB", { weekday: "short", day: "numeric", month: "short", timeZone: "UTC" });
+async function json(url) {
+  const r = await fetch(url);
+  if (!r.ok) throw new Error(`${url}: HTTP ${r.status}`);
+  return r.json();
+}
+function rampColor(r) {
+  let c = RAMP[0][0];
+  for (const [hex, lo] of RAMP) if (r >= lo) c = hex;
+  return c;
+}
+function textOn(hex) {
+  const n = parseInt(hex.slice(1), 16), rgb = [n >> 16, (n >> 8) & 255, n & 255].map((v) => { v /= 255; return v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4; });
+  return 0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2] > 0.3 ? "#0b0b0b" : "#ffffff";
+}
+const bar = (m, ci) => `<span class="bar"><span class="track"></span><span class="fill" style="width:${(m * 100).toFixed(1)}%"></span>`
+  + (ci ? `<span class="ci" style="left:${(ci[0] * 100).toFixed(1)}%;width:${((ci[1] - ci[0]) * 100).toFixed(1)}%"></span>` : "") + `</span>`;
+
+function models() {
+  return S.runs.models.filter((m) => m.split === S.split);
+}
+
+function renderSplits() {
+  const splits = [...new Set(S.runs.models.map((m) => m.split))].sort((a, b) => (a === "eval" ? -1 : b === "eval" ? 1 : 0));
+  if (!splits.includes(S.split)) S.split = splits[0];
+  $("#splits").innerHTML = splits.map((sp) => {
+    const n = new Set(S.runs.episodes.filter((e) => S.runs.models.some((m) => m.run === e.run && m.split === sp)).map((e) => e.task_id)).size;
+    return `<button type="button" data-split="${esc(sp)}" aria-pressed="${sp === S.split}">${sp === "eval" ? "Eval" : "Train (calibration)"} · ${n} tasks</button>`;
+  }).join("");
+  for (const b of $("#splits").querySelectorAll("button")) b.onclick = () => { S.split = b.dataset.split; S.sel = null; render(); };
+}
+
+function taskIds() {
+  const runs = new Set(models().map((m) => m.run));
+  return [...new Set(S.runs.episodes.filter((e) => runs.has(e.run)).map((e) => e.task_id))];
+}
+
+function renderBoard() {
+  const ms = models();
+  const tiers = TIERS.filter((t) => ms.some((m) => t in m.tiers));
+  const ids = taskIds(), tasks = ids.map((id) => S.byTask[id]).filter(Boolean);
+  $("#boardnote").textContent = `${tasks.length} tasks, one rollout per model, the same rules for every model: 12 turns, 64k output tokens per turn, `
+    + `10 checks of a draft, one graded submit. 95% bootstrap intervals.`;
+  const head = `<thead><tr><th>#</th><th>Model</th><th>Mean reward (95% CI)</th>${tiers.map((t) => `<th class="n">${esc(t)}</th>`).join("")}`
+    + `<th class="n">Legal plans</th><th class="n">Optimal</th><th class="n">No plan</th><th class="n">Median turns</th></tr></thead>`;
+  const rows = ms.map((m, i) => `<tr><td class="n">${i + 1}</td><td><b>${esc(m.name)}</b></td>`
+    + `<td><span class="meanbar"><b>${f3(m.mean)}</b>${bar(m.mean, m.ci)}<small>${f3(m.ci[0])}–${f3(m.ci[1])}</small></span></td>`
+    + tiers.map((t) => `<td class="n">${f3(m.tiers[t])}</td>`).join("")
+    + `<td class="n">${m.feasible} / ${m.n}</td><td class="n">${m.optimal}</td><td class="n">${m.no_submit}</td><td class="n">${m.median_turns}</td></tr>`);
+  const refRow = (name, f, legal) => {
+    const xs = tasks.map(f).filter((x) => x !== null && x !== undefined);
+    if (!xs.length) return "";
+    const per = tiers.map((t) => { const ys = tasks.filter((x) => x.difficulty === t).map(f).filter((x) => x !== null && x !== undefined); return `<td class="n">${ys.length ? f3(mean(ys)) : "–"}</td>`; });
+    return `<tr class="ref"><td></td><td>${esc(name)}</td><td><span class="meanbar"><b>${f3(mean(xs))}</b>${bar(mean(xs))}<small>${xs.length < tasks.length ? `${xs.length} tasks` : ""}</small></span></td>`
+      + per.join("") + `<td class="n">${legal}</td><td class="n"></td><td class="n"></td><td class="n"></td></tr>`;
+  };
+  const refs = [refRow("CP-SAT optimum (the reference)", () => 1.0, `${tasks.length} / ${tasks.length}`),
+    refRow("the real dispatchers (the record, real tier only, scored as if legal)", (t) => (t.difficulty === "real" ? t.rewards.real : null), ""),
+    refRow("greedy dispatcher", (t) => t.rewards.greedy, ""),
+    refRow("change nothing", (t) => t.rewards.naive, "")];
+  $("#board").innerHTML = head + `<tbody>${rows.join("")}${refs.join("")}</tbody>`;
+}
+
+function renderGrid() {
+  const ms = models();
+  const ids = taskIds();
+  const ep = {};
+  for (const e of S.runs.episodes) ep[`${e.run}|${e.model}|${e.task_id}`] = e;
+  const tiers = TIERS.filter((t) => ids.some((id) => S.byTask[id] && S.byTask[id].difficulty === t));
+  $("#tiers").innerHTML = ["all", ...tiers].map((t) => {
+    const n = t === "all" ? ids.length : ids.filter((id) => S.byTask[id] && S.byTask[id].difficulty === t).length;
+    return `<button type="button" class="chip" data-tier="${t}" aria-pressed="${S.tier === t}">${t === "all" ? "All" : esc(TIER[t])} · ${n}</button>`;
+  }).join("");
+  for (const b of $("#tiers").querySelectorAll("button")) b.onclick = () => { S.tier = b.dataset.tier; renderGrid(); };
+  $("#ramp").innerHTML = `0.2 ${RAMP.map(([c]) => `<i style="background:${c}"></i>`).join("")} 1.0 (the optimum)`;
+
+  let rows = ids.map((id) => {
+    const t = S.byTask[id];
+    const cells = ms.map((m) => ep[`${m.run}|${m.model}|${id}`] || null);
+    const rs = cells.filter(Boolean).map((e) => e.reward);
+    return { id, t, cells, mean: rs.length ? mean(rs) : null };
+  }).filter((r) => r.t && (S.tier === "all" || r.t.difficulty === S.tier));
+  const k = S.sort.key, dir = S.sort.asc ? 1 : -1;
+  const val = (r) => (k === "mean" ? r.mean : k === "task" ? `${r.t.day} ${r.t.start}` : k === "greedy" ? r.t.rewards.greedy
+    : k === "runs" ? r.t.runs : r.cells[+k] ? r.cells[+k].reward : -1);
+  rows.sort((a, b) => { const x = val(a), y = val(b); return (x < y ? -1 : x > y ? 1 : 0) * dir || a.id.localeCompare(b.id); });
+
+  const th = (key, label, cls = "") => `<th class="sort ${cls}${S.sort.key === key ? ` sorted${S.sort.asc ? " asc" : ""}` : ""}" data-key="${key}" scope="col">${label}</th>`;
+  const head = `<thead><tr>${th("task", "Task")}${th("runs", "Trains", "n")}${ms.map((m, i) => th(String(i), esc(shortName(m.name)), "n")).join("")}`
+    + `${th("mean", "Mean of models", "n")}${th("greedy", "Greedy", "n")}<th>Watch</th></tr></thead>`;
+  const body = rows.map((r) => {
+    const cause = (r.t.causes || []).join(", ");
+    const cells = r.cells.map((e, i) => {
+      if (!e) return `<td class="cell"><button type="button" class="none" disabled>–</button></td>`;
+      const sel = S.sel && S.sel.task === r.id && S.sel.i === i ? " sel" : "";
+      const title = `${shortName(ms[i].name)}: reward ${f3(e.reward)}, ${e.submitted ? (e.feasible ? "legal plan" : `${e.violations} rule breaks`) : "no plan submitted"}`;
+      if (!e.submitted || !e.plan_id) return `<td class="cell"><button type="button" class="none${sel}" data-task="${esc(r.id)}" data-i="${i}" title="${esc(title)}">no plan</button></td>`;
+      if (!e.feasible) return `<td class="cell"><button type="button" class="illegal${sel}" data-task="${esc(r.id)}" data-i="${i}" title="${esc(title)}">${f3(e.reward)}</button></td>`;
+      const c = rampColor(e.reward);
+      return `<td class="cell"><button type="button" class="${sel.trim()}" style="background:${c};color:${textOn(c)}" data-task="${esc(r.id)}" data-i="${i}" title="${esc(title)}">${e.reward >= 0.999 ? "★ " : ""}${f3(e.reward)}</button></td>`;
+    }).join("");
+    return `<tr><td class="task"><b>${esc(day(r.t.day))}</b> ${esc(r.t.start)}–${esc(r.t.end)} <span class="tier">${esc(TIER[r.t.difficulty] || r.t.difficulty)}</span><br><small>${esc(cause)}</small></td>`
+      + `<td class="n">${r.t.runs}</td>${cells}<td class="n">${f3(r.mean)}</td><td class="n">${f3(r.t.rewards.greedy)}</td>`
+      + `<td><a href="/twin/?task=${encodeURIComponent(r.id)}&plan=optimal">3D</a> · <a href="/viewer/?task=${encodeURIComponent(r.id)}&plan=optimal">graph</a></td></tr>`;
+  }).join("");
+  $("#grid").innerHTML = head + `<tbody>${body}</tbody>`;
+  for (const h of $("#grid").querySelectorAll("th.sort")) h.onclick = () => {
+    const key = h.dataset.key;
+    S.sort = { key, asc: S.sort.key === key ? !S.sort.asc : key === "task" || key === "runs" ? true : key === "mean" };
+    renderGrid();
+  };
+  for (const b of $("#grid").querySelectorAll("td.cell button[data-task]")) b.onclick = () => { S.sel = { task: b.dataset.task, i: +b.dataset.i }; renderGrid(); renderDetail(); };
+}
+
+function renderDetail() {
+  const box = $("#detail");
+  if (!S.sel) { box.hidden = true; return; }
+  const m = models()[S.sel.i], t = S.byTask[S.sel.task];
+  const e = S.runs.episodes.find((x) => x.run === m.run && x.model === m.model && x.task_id === S.sel.task);
+  if (!e || !t) { box.hidden = true; return; }
+  const over = e.feasible && e.cost !== null && e.optimal_cost ? Math.round((e.cost / e.optimal_cost - 1) * 100) : null;
+  const outcome = !e.submitted ? "no plan submitted" : e.feasible ? (over === 0 ? "the proven optimum" : `legal, ${over}% over the optimum`) : `${e.violations} rule break${e.violations === 1 ? "" : "s"}`;
+  const plan = e.plan_id ? encodeURIComponent(e.plan_id) : "optimal";
+  const task = encodeURIComponent(t.task_id);
+  box.innerHTML = `<div class="row">
+      <div><span class="k">${esc(day(t.day))} ${esc(t.start)}–${esc(t.end)} · ${esc(TIER[t.difficulty] || t.difficulty)}</span><span class="v">${esc(m.name)}</span></div>
+      <div><span class="k">Reward</span><span class="v">${f3(e.reward)}</span></div>
+      <div><span class="k">Outcome</span><span class="v">${esc(outcome)}</span></div>
+      <div><span class="k">Cost / optimum</span><span class="v">${e.cost ?? "–"} / ${e.optimal_cost}</span></div>
+      <div><span class="k">Turns · checks</span><span class="v">${e.agent_turns} · ${e.checks}</span></div>
+      <div class="links">${e.plan_id ? `<a class="primary" href="/twin/?task=${task}&plan=${plan}">Watch in 3D</a><a href="/viewer/?task=${task}&plan=${plan}">Train graph</a>` : ""}
+        <a href="/viewer/?task=${task}&plan=optimal">The optimum</a><button class="close" type="button" aria-label="Close">×</button></div>
+    </div>`;
+  box.hidden = false;
+  box.querySelector(".close").onclick = () => { S.sel = null; renderGrid(); renderDetail(); };
+}
+
+function render() {
+  renderSplits();
+  renderBoard();
+  renderGrid();
+  renderDetail();
+}
+
+(async () => {
+  if (params.has("embed")) $("#nav").hidden = true;
+  if (params.get("theme")) document.documentElement.dataset.theme = params.get("theme");
+  try {
+    const [runs, tasks] = await Promise.all([json("/api/runs"), json("/api/tasks")]);
+    S.runs = runs;
+    S.tasks = tasks;
+    S.byTask = Object.fromEntries(tasks.map((t) => [t.task_id, t]));
+  } catch (err) {
+    $("main").insertAdjacentHTML("afterbegin", `<p class="err">${esc(err.message)}</p>`);
+    return;
+  }
+  if (!S.runs.models.length) {
+    $("main").insertAdjacentHTML("afterbegin", `<p class="note">No model runs on this server (results/rollouts/*/index.json, or RAIL_RUNS_DIR).</p>`);
+    return;
+  }
+  render();
+  document.body.dataset.ready = "1";
+})();
+</script>
+</body>
+</html>

openenv/rail_openenv/web/index.html

@@ -0,0 +1,592 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>RailSimEnv train graph</title>
+<link rel="icon" href="data:,">
+<style>
+  :root {
+    color-scheme: light;
+    --page: #f9f9f7; --surface: #fcfcfb; --ink: #0b0b0b; --ink-2: #52514e; --muted: #898781;
+    --grid: #e1e0d9; --axis: #c3c2b7; --ring: rgba(11, 11, 11, 0.10);
+    --stop: #2a78d6; --fast: #eb6834; --critical: #d03b3b; --warning: #fab219; --serious: #ec835a; --good: #0ca30c;
+    --good-text: #006300; --single: #f1efe9; --after: rgba(11, 11, 11, 0.035); --accent: #2a78d6;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root:where(:not([data-theme="light"])) {
+      color-scheme: dark;
+      --page: #0d0d0d; --surface: #1a1a19; --ink: #ffffff; --ink-2: #c3c2b7; --muted: #898781;
+      --grid: #2c2c2a; --axis: #383835; --ring: rgba(255, 255, 255, 0.10);
+      --stop: #3987e5; --fast: #d95926; --good-text: #0ca30c; --single: #232321; --after: rgba(255, 255, 255, 0.03);
+      --accent: #3987e5;
+    }
+  }
+  :root[data-theme="dark"] {
+    color-scheme: dark;
+    --page: #0d0d0d; --surface: #1a1a19; --ink: #ffffff; --ink-2: #c3c2b7; --muted: #898781;
+    --grid: #2c2c2a; --axis: #383835; --ring: rgba(255, 255, 255, 0.10);
+    --stop: #3987e5; --fast: #d95926; --good-text: #0ca30c; --single: #232321; --after: rgba(255, 255, 255, 0.03);
+    --accent: #3987e5;
+  }
+  * { box-sizing: border-box; }
+  [hidden] { display: none !important; }
+  body { margin: 0; background: var(--page); color: var(--ink); font: 14px/1.45 system-ui, -apple-system, "Segoe UI", sans-serif; }
+  a { color: var(--accent); }
+  nav.site { display: flex; gap: 4px 18px; flex-wrap: wrap; align-items: baseline; padding: 12px 16px 0; }
+  nav.site b { font-size: 15px; margin-right: 6px; }
+  nav.site a { color: var(--ink-2); text-decoration: none; padding: 2px 0; border-bottom: 2px solid transparent; }
+  nav.site a:hover { color: var(--ink); }
+  nav.site a[aria-current] { color: var(--ink); border-bottom-color: var(--accent); }
+  main { padding: 12px 16px 24px; max-width: 1440px; margin: 0 auto; }
+  .controls { display: flex; gap: 8px 12px; flex-wrap: wrap; align-items: end; margin-bottom: 14px; }
+  .controls label { display: grid; gap: 2px; font-size: 12px; color: var(--ink-2); min-width: 0; }
+  .controls select { font: inherit; font-size: 14px; color: var(--ink); background: var(--surface); border: 1px solid var(--axis);
+                     border-radius: 6px; padding: 6px 8px; max-width: min(92vw, 460px); }
+  .controls .open3d { margin-left: auto; padding: 7px 12px; border-radius: 6px; border: 1px solid var(--axis); text-decoration: none;
+                      color: var(--ink); background: var(--surface); white-space: nowrap; }
+  .card { background: var(--surface); border: 1px solid var(--ring); border-radius: 10px; padding: 16px; }
+  .head { display: flex; gap: 12px 24px; flex-wrap: wrap; justify-content: space-between; align-items: start; }
+  .head h1 { font-size: 20px; line-height: 1.25; margin: 0 0 4px; font-weight: 650; }
+  .head .sub { color: var(--ink-2); margin: 0; max-width: 78ch; }
+  .stats { display: flex; flex-wrap: wrap; gap: 8px 28px; margin: 14px 0 6px; }
+  .stat { display: grid; gap: 0; }
+  .stat .k { font-size: 12px; color: var(--ink-2); }
+  .stat .v { font-size: 20px; font-weight: 600; }
+  .stat .v small { font-size: 13px; font-weight: 400; color: var(--ink-2); margin-left: 4px; }
+  .badge { display: inline-flex; gap: 6px; align-items: center; font-size: 13px; font-weight: 600; padding: 3px 10px;
+           border-radius: 999px; border: 1px solid var(--ring); white-space: nowrap; }
+  .badge.ok i { color: var(--good); font-style: normal; }
+  .badge.bad i { color: var(--critical); font-style: normal; }
+  .legend { display: flex; flex-wrap: wrap; gap: 6px 18px; margin: 12px 0 4px; font-size: 13px; color: var(--ink-2); }
+  .legend span { display: inline-flex; align-items: center; gap: 6px; white-space: nowrap; }
+  .legend svg { flex: none; }
+  .chartwrap { position: relative; overflow-x: auto; margin-top: 4px; }
+  #chart { display: block; }
+  #chart text { font-family: system-ui, -apple-system, "Segoe UI", sans-serif; }
+  .halo { paint-order: stroke; stroke: var(--surface); stroke-width: 4px; stroke-linejoin: round; }
+  .num { font-variant-numeric: tabular-nums; }
+  .paths.focus .run:not(.on) { opacity: 0.18; }
+  .paths.focus .run.on path.line { stroke-width: 3; }
+  .tip { position: absolute; pointer-events: none; background: var(--surface); color: var(--ink); border: 1px solid var(--ring);
+         border-radius: 8px; padding: 8px 10px; font-size: 13px; line-height: 1.4; box-shadow: 0 4px 16px rgba(0,0,0,0.12);
+         max-width: 300px; z-index: 2; }
+  .tip b { font-size: 14px; }
+  .tip .key { display: inline-block; width: 14px; height: 0; border-top: 2px solid; vertical-align: middle; margin-right: 6px; }
+  .tip .m { color: var(--ink-2); }
+  details { margin-top: 14px; }
+  summary { cursor: pointer; color: var(--ink-2); }
+  table { border-collapse: collapse; width: 100%; font-size: 13px; margin-top: 8px; }
+  th, td { text-align: left; padding: 5px 8px; border-bottom: 1px solid var(--grid); vertical-align: top; }
+  th { color: var(--ink-2); font-weight: 600; }
+  td.n, th.n { text-align: right; font-variant-numeric: tabular-nums; }
+  .tablewrap { overflow-x: auto; }
+  .breaks { margin: 10px 0 0; padding-left: 18px; color: var(--ink-2); font-size: 13px; }
+  .err { color: var(--critical); }
+  body.figure main { padding: 0; max-width: none; }
+  body.figure .card { border: 0; border-radius: 0; padding: 22px 26px 18px; }
+  body.figure .head h1 { font-size: 22px; }
+  body.figure .sub { font-size: 15px; }
+  body.figure .legend { font-size: 14px; }
+</style>
+</head>
+<body>
+<nav class="site" id="nav">
+  <b>RailSimEnv</b>
+  <a href="/explorer/">Eval explorer</a>
+  <a href="/twin/">3D replay</a>
+  <a href="/viewer/" aria-current="page">Train graph</a>
+  <a href="/web">Environment</a>
+</nav>
+<main>
+  <div class="controls" id="controls">
+    <label>Task<select id="task" aria-label="Task"></select></label>
+    <label>Plan<select id="plan" aria-label="Plan"></select></label>
+    <a class="open3d" id="open3d" href="/twin/">Watch it in 3D ↗</a>
+  </div>
+  <section class="card" aria-live="polite">
+    <div class="head">
+      <div>
+        <h1 id="title">Loading…</h1>
+        <p class="sub" id="sub"></p>
+      </div>
+      <div id="badge"></div>
+    </div>
+    <div class="stats" id="stats"></div>
+    <ol class="breaks" id="breaks" hidden></ol>
+    <div class="legend" id="legend"></div>
+    <div class="chartwrap" id="chartwrap">
+      <svg id="chart" role="img" aria-labelledby="title"></svg>
+      <div class="tip" id="tip" hidden></div>
+    </div>
+    <details id="tablebox">
+      <summary>Every train as a table</summary>
+      <div class="tablewrap"><table id="table"></table></div>
+    </details>
+  </section>
+</main>
+<script>
+"use strict";
+const $ = (s) => document.querySelector(s);
+const params = new URLSearchParams(location.search);
+const FIGURE = params.has("figure");
+const EMBED = FIGURE || params.has("embed");
+const FEATURED = "gnlw-2025-05-01-0800-180m-blockage-0";
+const TIER = { real: "real disruption", blockage: "blockage", loop: "lost passing track", compound: "compound" };
+const WHAT = { closed: "closed", slow: "slow running", track: "a platform track out of use" };
+const S = { tasks: [], R: null, paths: [], geo: null };
+
+const esc = (s) => String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+const hhmm = (m) => { m = Math.round(m); const d = ((m % 1440) + 1440) % 1440; return `${String(Math.floor(d / 60)).padStart(2, "0")}:${String(d % 60).padStart(2, "0")}`; };
+const fmt = (n) => (n === null || n === undefined ? "–" : Number(n).toLocaleString("en-GB"));
+async function json(url) {
+  const r = await fetch(url);
+  if (!r.ok) throw new Error(`${url}: HTTP ${r.status}`);
+  return r.json();
+}
+function longDay(day) {
+  return new Date(`${day}T12:00:00Z`).toLocaleDateString("en-GB", { weekday: "long", day: "numeric", month: "long", year: "numeric", timeZone: "UTC" });
+}
+function shortDay(day) {
+  return new Date(`${day}T12:00:00Z`).toLocaleDateString("en-GB", { day: "numeric", month: "short", timeZone: "UTC" });
+}
+const shortName = (p) => (p.kind === "junction" ? p.name.replace(/ (east|west) junction$/, " jn.") : p.name);
+function orderText(o) {
+  if (!o) return "";
+  const out = [];
+  if (o.cancel) out.push("cancelled");
+  if (o.from) out.push(`starts at ${o.from}`);
+  if (o.to) out.push(`turns back at ${o.to}`);
+  for (const [c, t] of Object.entries(o.hold || {})) out.push(`held at ${c} until ${t}`);
+  return out.join("; ");
+}
+
+// ---- geometry ------------------------------------------------------------------------------------------------
+
+const measure = (() => {
+  const g = document.createElement("canvas").getContext("2d");
+  return (text, px, weight = 400) => { g.font = `${weight} ${px}px system-ui, -apple-system, "Segoe UI", sans-serif`; return g.measureText(text).width; };
+})();
+
+function pathOf(r, km) {
+  const pts = [];
+  if (r.started && r.fixed_from !== null && r.fixed_from !== undefined) pts.push([r.fixed_from, km[r.route[r.fixed_to - 1]]]);
+  const from = r.started ? r.fixed_to : r.first;
+  for (let i = from; i <= r.last; i++) {
+    const k = km[r.route[i]];
+    if (r.arr[i] !== null && r.arr[i] !== undefined && !(i === from && !r.started)) pts.push([r.arr[i], k]);
+    if (r.dep[i] !== null && r.dep[i] !== undefined && i < r.last) pts.push([r.dep[i], k]);
+  }
+  return pts;
+}
+
+function timetablePath(r, km) {
+  const pts = [];
+  for (let i = 0; i < r.route.length; i++) {
+    if (r.sched_arr[i] !== null && i > 0) pts.push([r.sched_arr[i], km[r.route[i]]]);
+    if (r.sched_dep[i] !== null && i < r.route.length - 1) pts.push([r.sched_dep[i], km[r.route[i]]]);
+  }
+  return pts;
+}
+
+function holdsOf(r, km) {
+  const out = [];
+  for (const code of Object.keys((r.order && r.order.hold) || {})) {
+    for (let i = r.first; i <= r.last; i++) {
+      if (r.route[i] !== code) continue;
+      const a = r.arr[i] ?? r.sched_dep[i], d = r.dep[i];
+      if (a !== null && d !== null && d > a) out.push([a, d, km[code]]);
+    }
+  }
+  return out;
+}
+
+function segHitsBox(ax, ay, bx, by, b) {            // Liang-Barsky: does segment a-b cross box b?
+  let t0 = 0, t1 = 1;
+  const dx = bx - ax, dy = by - ay;
+  for (const [p, q] of [[-dx, ax - b.x0], [dx, b.x1 - ax], [-dy, ay - b.y0], [dy, b.y1 - ay]]) {
+    if (p === 0) { if (q < 0) return false; continue; }
+    const r = q / p;
+    if (p < 0) { if (r > t1) return false; if (r > t0) t0 = r; } else { if (r < t0) return false; if (r < t1) t1 = r; }
+  }
+  return true;
+}
+const overlap = (a, b) => a.x0 < b.x1 && b.x0 < a.x1 && a.y0 < b.y1 && b.y0 < a.y1;
+
+// ---- the chart -----------------------------------------------------------------------------------------------
+
+function draw() {
+  const R = S.R;
+  if (!R) return;
+  const wrap = $("#chartwrap");
+  const W = FIGURE ? Math.floor(wrap.clientWidth) : Math.max(760, Math.floor(wrap.clientWidth));
+  const fs = FIGURE ? 14 : 13, fsSmall = fs - 2, fsTrain = FIGURE ? 12.5 : 12;
+  const km = Object.fromEntries(R.points.map((p) => [p.code, p.km]));
+  const kmMax = Math.max(...R.points.map((p) => p.km));
+  const compact = W < 900 && !FIGURE;
+  const label = (p) => (compact ? p.code : shortName(p));
+  const nameW = Math.max(...R.points.map((p) => measure(label(p), p.kind === "junction" ? fsSmall : fs, p.kind === "terminal" ? 600 : 400)
+    + (compact || p.kind === "junction" ? 0 : measure(` ${p.code}`, fsSmall))));
+  const L = Math.ceil(nameW) + 44, Rm = 18, T = 38, B = 34;
+  const H = FIGURE ? 600 : Math.max(520, Math.min(680, Math.round(W * 0.5)));
+  const paths = R.runs.filter((r) => !r.cancelled).map((r) => ({ r, pts: pathOf(r, km) })).filter((p) => p.pts.length > 1);
+  const allT = paths.flatMap((p) => p.pts.map((q) => q[0]));
+  const t0 = Math.min(R.start - 10, ...allT.filter((t) => t >= R.start - 30)) - 2;
+  const t1 = Math.min(R.end + 75, Math.max(R.end + 15, ...allT)) + 3;
+  const x = (t) => L + (t - t0) / (t1 - t0) * (W - L - Rm);
+  const y = (k) => T + k / kmMax * (H - T - B);
+  const s = [];
+
+  s.push(`<defs>
+    <clipPath id="plot"><rect x="${L}" y="${T - 6}" width="${W - L - Rm}" height="${H - T - B + 12}"/></clipPath>
+    <pattern id="hatch-closed" width="7" height="7" patternUnits="userSpaceOnUse" patternTransform="rotate(45)">
+      <rect width="7" height="7" fill="var(--critical)" fill-opacity="0.10"/><line x1="0" y1="0" x2="0" y2="7" stroke="var(--critical)" stroke-opacity="0.55" stroke-width="2"/></pattern>
+    <pattern id="hatch-slow" width="7" height="7" patternUnits="userSpaceOnUse" patternTransform="rotate(45)">
+      <rect width="7" height="7" fill="var(--warning)" fill-opacity="0.14"/><line x1="0" y1="0" x2="0" y2="7" stroke="var(--warning)" stroke-opacity="0.75" stroke-width="2"/></pattern>
+    <pattern id="hatch-track" width="7" height="7" patternUnits="userSpaceOnUse" patternTransform="rotate(135)">
+      <rect width="7" height="7" fill="var(--serious)" fill-opacity="0.12"/><line x1="0" y1="0" x2="0" y2="7" stroke="var(--serious)" stroke-opacity="0.7" stroke-width="2"/></pattern>
+  </defs>`);
+
+  // single-track rows, the time grid, the window
+  R.sections.forEach((sec) => {
+    if (!sec.single) return;
+    s.push(`<rect x="${L}" y="${y(km[sec.a])}" width="${W - L - Rm}" height="${y(km[sec.b]) - y(km[sec.a])}" fill="var(--single)"/>`);
+  });
+  if (R.end < t1) s.push(`<rect x="${x(R.end)}" y="${T}" width="${x(t1) - x(R.end)}" height="${H - T - B}" fill="var(--after)"/>`);
+  for (const p of R.points) s.push(`<line x1="${L}" x2="${W - Rm}" y1="${y(p.km)}" y2="${y(p.km)}" stroke="var(--grid)"/>`);
+  const step = (W - L - Rm) / (t1 - t0) * 30 < 46 ? 60 : 30;
+  for (let t = Math.ceil(t0 / step) * step; t <= t1; t += step) {
+    const hour = t % 60 === 0;
+    s.push(`<line x1="${x(t)}" x2="${x(t)}" y1="${T}" y2="${H - B}" stroke="${hour ? "var(--axis)" : "var(--grid)"}"/>`);
+    if (x(t) + measure(hhmm(t), fs, 600) / 2 > W) continue;
+    for (const yy of [T - 12, H - B + 21]) {
+      s.push(`<text x="${x(t)}" y="${yy}" text-anchor="middle" font-size="${hour ? fs : fsSmall}" font-weight="${hour ? 600 : 400}" fill="${hour ? "var(--ink-2)" : "var(--muted)"}" class="num">${hhmm(t)}</text>`);
+    }
+  }
+
+  // stations and the track: one line for single track, two for double
+  const tx = L - 18;
+  R.sections.forEach((sec) => {
+    const ya = y(km[sec.a]), yb = y(km[sec.b]);
+    if (sec.single) s.push(`<line x1="${tx}" x2="${tx}" y1="${ya}" y2="${yb}" stroke="var(--ink-2)" stroke-width="2.5"/>`);
+    else for (const d of [-2.6, 2.6]) s.push(`<line x1="${tx + d}" x2="${tx + d}" y1="${ya}" y2="${yb}" stroke="var(--ink-2)" stroke-width="1.3"/>`);
+  });
+  for (const p of R.points) {
+    const yy = y(p.km);
+    if (p.kind === "terminal") s.push(`<rect x="${tx - 6}" y="${yy - 2.5}" width="12" height="5" rx="1.5" fill="var(--ink)"/>`);
+    else if (p.kind === "station") s.push(`<circle cx="${tx}" cy="${yy}" r="4.6" fill="var(--surface)" stroke="var(--ink)" stroke-width="1.6"/>`);
+    else if (p.kind === "halt") s.push(`<circle cx="${tx}" cy="${yy}" r="3" fill="var(--ink)"/>`);
+    const junction = p.kind === "junction";
+    const code = compact || junction ? "" : ` <tspan font-size="${fsSmall}" fill="var(--muted)">${esc(p.code)}</tspan>`;
+    s.push(`<text x="${tx - 14}" y="${yy + fs * 0.36}" text-anchor="end" font-size="${junction ? fsSmall : fs}" font-weight="${p.kind === "terminal" ? 600 : 400}" fill="${junction ? "var(--muted)" : "var(--ink)"}"><title>${esc(p.name)} (${esc(p.code)}${p.tracks ? `, ${p.tracks} platform track${p.tracks > 1 ? "s" : ""}` : ""})</title>${esc(label(p))}${code}</text>`);
+  }
+
+  // disruptions
+  const boxes = [];
+  const closures = [];
+  for (const c of R.closures) {
+    const a = km[c.where[0]], b = km[c.where[c.where.length - 1]];
+    const k0 = c.kind === "track" ? a - 0.55 : Math.min(a, b), k1 = c.kind === "track" ? a + 0.55 : Math.max(a, b);
+    const bx = x(Math.max(c.start, t0)), bw = x(Math.min(c.end, t1)) - bx, by = y(k0), bh = Math.max(8, y(k1) - y(k0));
+    s.push(`<rect x="${bx}" y="${by}" width="${bw}" height="${bh}" fill="url(#hatch-${c.kind})" stroke="${c.kind === "closed" ? "var(--critical)" : c.kind === "slow" ? "var(--warning)" : "var(--serious)"}" stroke-width="1.2" clip-path="url(#plot)"><title>${esc(c.cause)}: ${WHAT[c.kind] || c.kind} ${hhmm(c.start)}–${hhmm(c.end)}</title></rect>`);
+    closures.push({ c, bx, bw, by, bh });
+  }
+
+  // trains
+  const geo = [];
+  const series = (r) => (r.problems && r.problems.length ? "var(--critical)" : r.kind === "fast" ? "var(--fast)" : "var(--stop)");
+  s.push(`<g class="paths" id="paths" clip-path="url(#plot)">`);
+  for (const r of R.runs.filter((r) => r.cancelled)) {
+    const pts = timetablePath(r, km);
+    if (pts.length < 2) continue;
+    const d = pts.map((q, i) => `${i ? "L" : "M"}${x(q[0]).toFixed(1)},${y(q[1]).toFixed(1)}`).join("");
+    s.push(`<g class="run" data-unit="${esc(r.unit)}"><path d="${d}" fill="none" stroke="var(--muted)" stroke-width="1.3" stroke-dasharray="2 4" stroke-linecap="round"/></g>`);
+    geo.push({ r, xy: pts.map((q) => [x(q[0]), y(q[1])]), cancelled: true });
+  }
+  for (const { r, pts } of paths) {
+    const xy = pts.map((q) => [x(q[0]), y(q[1])]);
+    const d = xy.map((q, i) => `${i ? "L" : "M"}${q[0].toFixed(1)},${q[1].toFixed(1)}`).join("");
+    const col = series(r), bad = r.problems && r.problems.length;
+    const parts = [`<path class="line" d="${d}" fill="none" stroke="${col}" stroke-width="2" stroke-linejoin="round" stroke-linecap="round"${bad ? ' stroke-dasharray="7 4"' : ""}/>`];
+    for (const [a, b, k] of holdsOf(r, km)) parts.push(`<line x1="${x(a)}" x2="${x(b)}" y1="${y(k)}" y2="${y(k)}" stroke="${col}" stroke-width="6" stroke-linecap="round"/>`);
+    const o = r.order || {};
+    if (o.to) { const q = xy[xy.length - 1]; parts.push(`<circle cx="${q[0]}" cy="${q[1]}" r="5" fill="var(--surface)" stroke="${col}" stroke-width="2.4"/>`); }
+    if (o.from) { const q = xy[0]; parts.push(`<circle cx="${q[0]}" cy="${q[1]}" r="5" fill="var(--surface)" stroke="${col}" stroke-width="2.4"/>`); }
+    s.push(`<g class="run" data-unit="${esc(r.unit)}">${parts.join("")}</g>`);
+    geo.push({ r, xy });
+  }
+  s.push(`</g>`);
+
+  // labels: closures first, then each train once, where it collides least
+  const plot = { x0: L + 2, x1: W - Rm - 2, y0: T + 1, y1: H - B - 1 };
+  const labels = [];
+  for (const { c, bx, bw, by, bh } of closures) {
+    // a tag with the closure's kind, time and cause: inside the hatched area when it fits (wrapped), else beside it
+    const head = c.kind === "closed" ? "Closed" : c.kind === "slow" ? `Slow, +${c.extra} min` : "Track out of use";
+    const lh = fsSmall + 4;
+    const wrap = (words, maxW) => words.reduce((ls, wd) => {
+      const last = ls[ls.length - 1];
+      if (last && measure(`${last} ${wd}`, fsSmall) <= maxW) ls[ls.length - 1] = `${last} ${wd}`; else ls.push(wd);
+      return ls;
+    }, []);
+    let lines = [[head, 600], [`${hhmm(c.start)}–${hhmm(c.end)}`, 400], ...wrap((c.cause || "").split(/\s+/).filter(Boolean), bw - 22).map((t) => [t, 400])];
+    let w = Math.max(...lines.map(([t, wt]) => measure(t, fsSmall, wt))) + 14, h = lines.length * lh + 8;
+    let lx = bx + 6, ly = by + 6;
+    const stroke = c.kind === "closed" ? "var(--critical)" : c.kind === "slow" ? "var(--warning)" : "var(--serious)";
+    const tag = (ls, cx, cy, rot) => {                   // a tag of lines centred on (cx, cy), upright when rot
+      const tw = Math.max(...ls.map(([t, wt]) => measure(t, fsSmall, wt))) + 14, th = ls.length * lh + 8;
+      const [bw2, bh2] = rot ? [th, tw] : [tw, th];
+      boxes.push({ x0: cx - bw2 / 2, x1: cx + bw2 / 2, y0: cy - bh2 / 2, y1: cy + bh2 / 2 });
+      labels.push(`<g transform="translate(${cx} ${cy})${rot ? " rotate(-90)" : ""}"><rect x="${-tw / 2}" y="${-th / 2}" width="${tw}" height="${th}" rx="5" fill="var(--surface)" stroke="${stroke}" stroke-width="1"/>`
+        + ls.map(([t, wt], i) => `<text x="${-tw / 2 + 7}" y="${-th / 2 + 4 + i * lh + lh / 2 + fsSmall * 0.36}" font-size="${fsSmall}" font-weight="${wt}" fill="${i ? "var(--ink-2)" : "var(--ink)"}">${esc(t)}</text>`).join("") + "</g>");
+    };
+    if (w <= bw - 10 && h <= bh - 10) { tag(lines, bx + 6 + w / 2, by + 6 + h / 2, false); continue; }
+    const two = [[`${head} ${hhmm(c.start)}–${hhmm(c.end)}`, 600], ...(c.cause ? [[c.cause, 400]] : [])];
+    const tw = Math.max(...two.map(([t, wt]) => measure(t, fsSmall, wt))) + 14, th = two.length * lh + 8;
+    if (tw <= bw - 10 && th <= bh - 2) { tag(two, bx + 6 + tw / 2, by + bh / 2, false); continue; }
+    if (bw >= th + 8 && bh >= tw + 12) { tag(two, bx + bw / 2, by + bh / 2, true); continue; }
+    lines = [[`${head} · ${hhmm(c.start)}–${hhmm(c.end)}${c.cause ? ` · ${c.cause}` : ""}`, 600]];
+    w = measure(lines[0][0], fsSmall, 600) + 14; h = lh + 8;
+    lx = bx + bw + 6; ly = by + bh / 2 - h / 2;
+    if (lx + w > plot.x1) lx = Math.max(plot.x0, bx - w - 6);
+    boxes.push({ x0: lx, x1: lx + w, y0: ly, y1: ly + h });
+    labels.push(`<rect x="${lx}" y="${ly}" width="${w}" height="${h}" rx="5" fill="var(--surface)" stroke="${stroke}" stroke-width="1"/>`
+      + lines.map(([t, wt], i) => `<text x="${lx + 7}" y="${ly + 4 + i * lh + lh / 2 + fsSmall * 0.36}" font-size="${fsSmall}" font-weight="${wt}" fill="${i ? "var(--ink-2)" : "var(--ink)"}">${esc(t)}</text>`).join(""));
+  }
+  for (const yy of [x(R.start), x(R.end)]) boxes.push({ x0: yy - 1, x1: yy + 1, y0: T - 30, y1: T });
+  const segs = geo.filter((g) => !g.cancelled).flatMap((g, gi) => g.xy.slice(1).map((q, i) => [g.xy[i][0], g.xy[i][1], q[0], q[1], gi]));
+  const trainBox = [];
+  geo.forEach((g, gi) => {
+    if (g.cancelled) return;
+    const text = g.r.train, w = measure(text, fsTrain, 500) + 4, h = fsTrain + 2;
+    const cands = [];
+    let acc = 0;
+    const total = g.xy.slice(1).reduce((a, q, i) => a + Math.hypot(q[0] - g.xy[i][0], q[1] - g.xy[i][1]), 0);
+    for (let i = 1; i < g.xy.length; i++) {
+      const [ax, ay] = g.xy[i - 1], [bx, by] = g.xy[i];
+      const len = Math.hypot(bx - ax, by - ay);
+      if (len < 1) continue;
+      const ux = (bx - ax) / len, uy = (by - ay) / len, nx = uy, ny = -ux;   // the normal on the upper side
+      for (let d = 0; d <= len; d += 12) {
+        const px = ax + ux * d, py = ay + uy * d;
+        const off = Math.abs(nx) * w / 2 + Math.abs(ny) * h / 2 + 3;
+        const cx = px + nx * off, cy = py + ny * off;
+        cands.push({ box: { x0: cx - w / 2, x1: cx + w / 2, y0: cy - h / 2, y1: cy + h / 2 }, s: (acc + d) / Math.max(1, total) });
+      }
+      acc += len;
+    }
+    let best = null;
+    for (const c of cands) {
+      const b = c.box;
+      if (b.x0 < plot.x0 || b.x1 > plot.x1 || b.y0 < plot.y0 || b.y1 > plot.y1) continue;
+      if (boxes.some((o) => overlap(o, b)) || trainBox.some((o) => overlap(o, b))) continue;
+      let pen = c.s * 4;
+      for (const [ax, ay, bx, by, gj] of segs) {
+        if (Math.max(ax, bx) < b.x0 || Math.min(ax, bx) > b.x1 || Math.max(ay, by) < b.y0 || Math.min(ay, by) > b.y1) continue;
+        if (segHitsBox(ax, ay, bx, by, b)) pen += gj === gi ? 6 : 3;
+      }
+      if (!best || pen < best.pen) best = { ...c, pen };
+    }
+    if (!best) return;
+    trainBox.push({ x0: best.box.x0 - 2, x1: best.box.x1 + 2, y0: best.box.y0 - 1, y1: best.box.y1 + 1 });
+    labels.push(`<text x="${(best.box.x0 + best.box.x1) / 2}" y="${(best.box.y0 + best.box.y1) / 2 + fsTrain * 0.36}" text-anchor="middle" font-size="${fsTrain}" font-weight="500" fill="var(--ink-2)" class="halo num">${esc(text)}</text>`);
+  });
+
+  // the window's edges
+  s.push(`<line x1="${x(R.start)}" x2="${x(R.start)}" y1="${T - 4}" y2="${H - B}" stroke="var(--ink)" stroke-width="1.4"/>`);
+  if (R.end < t1) s.push(`<line x1="${x(R.end)}" x2="${x(R.end)}" y1="${T - 4}" y2="${H - B}" stroke="var(--ink)" stroke-width="1.4"/>`);
+  s.push(`<text x="${x(R.start) + 6}" y="${T - 27}" font-size="${fsSmall}" fill="var(--ink-2)">window opens</text>`);
+  if (R.end < t1) {
+    const msg = "window closes · lateness after it is handed on";
+    const right = x(R.end) + 6 + measure(msg, fsSmall) < W - Rm;
+    s.push(`<text x="${right ? x(R.end) + 6 : x(R.end) - 6}" y="${T - 27}" text-anchor="${right ? "start" : "end"}" font-size="${fsSmall}" fill="var(--ink-2)">${right ? msg : "window closes"}</text>`);
+  }
+  s.push(labels.join(""));
+
+  const svg = $("#chart");
+  svg.setAttribute("viewBox", `0 0 ${W} ${H}`);
+  svg.setAttribute("width", W);
+  svg.setAttribute("height", H);
+  svg.innerHTML = s.join("");
+  S.geo = geo;
+  S.frame = { x, y, t0, t1, L, T, W, H, B, Rm, km };
+}
+
+// ---- hover: the nearest train, and its train set ---------------------------------------------------------------
+
+function nearest(mx, my) {
+  let best = null, bd = 12;
+  for (const g of S.geo || []) {
+    for (let i = 1; i < g.xy.length; i++) {
+      const [ax, ay] = g.xy[i - 1], [bx, by] = g.xy[i];
+      const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy || 1;
+      const u = Math.max(0, Math.min(1, ((mx - ax) * dx + (my - ay) * dy) / L2));
+      const d = Math.hypot(mx - ax - u * dx, my - ay - u * dy);
+      if (d < bd) { bd = d; best = g; }
+    }
+  }
+  return best;
+}
+
+function tipHTML(r) {
+  const col = r.problems && r.problems.length ? "var(--critical)" : r.kind === "fast" ? "var(--fast)" : "var(--stop)";
+  const origin = r.route[0], dest = r.route[r.route.length - 1];
+  const dep = r.sched_dep[0] !== null ? hhmm(r.sched_dep[0]) : "";
+  const lines = [`<div><span class="key" style="border-color:${col}"></span><b class="num">${esc(r.train)}</b> <span class="m">${r.kind === "fast" ? "fast" : "stopping"} train · set ${esc(r.unit)}</span></div>`,
+    `<div class="m">${esc(origin)} ${dep} → ${esc(dest)}</div>`];
+  if (r.cancelled) lines.push(`<div><b>cancelled</b> · ${r.unserved} stops not served</div>`);
+  else lines.push(`<div><b class="num">${fmt(r.delay)}</b> <span class="m">stop-minutes late</span> · <b class="num">${fmt(r.unserved)}</b> <span class="m">stops not served</span></div>`);
+  const o = orderText(r.order);
+  if (o) lines.push(`<div><span class="m">plan:</span> ${esc(o)}</div>`);
+  if (r.problems && r.problems.length) lines.push(`<div style="color:var(--critical)">breaks: ${esc(r.problems.join(", "))}</div>`);
+  return lines.join("");
+}
+
+function onMove(e) {
+  const svg = $("#chart"), tip = $("#tip"), wrap = $("#chartwrap");
+  const rect = svg.getBoundingClientRect();
+  const sx = S.frame ? S.frame.W / rect.width : 1;
+  const mx = (e.clientX - rect.left) * sx, my = (e.clientY - rect.top) * sx;
+  const g = nearest(mx, my);
+  const group = $("#paths");
+  if (!g) { tip.hidden = true; group && group.classList.remove("focus"); return; }
+  group.classList.add("focus");
+  for (const el of group.querySelectorAll(".run")) el.classList.toggle("on", el.dataset.unit === g.r.unit);
+  tip.innerHTML = tipHTML(g.r);
+  tip.hidden = false;
+  const wr = wrap.getBoundingClientRect();
+  const left = e.clientX - wr.left + wrap.scrollLeft + 14, top = e.clientY - wr.top + 14;
+  tip.style.left = `${Math.min(left, wrap.scrollLeft + wr.width - tip.offsetWidth - 4)}px`;
+  tip.style.top = `${top}px`;
+}
+
+// ---- the panels around the chart -----------------------------------------------------------------------------
+
+function legendKey(kind) {
+  const line = (stroke, dash = "", w = 2) => `<svg width="22" height="10" aria-hidden="true"><line x1="1" y1="5" x2="21" y2="5" stroke="${stroke}" stroke-width="${w}" stroke-linecap="round" ${dash ? `stroke-dasharray="${dash}"` : ""}/></svg>`;
+  const rect = (fill, stroke) => `<svg width="20" height="12" aria-hidden="true"><rect x="1" y="1" width="18" height="10" rx="2" fill="${fill}" stroke="${stroke}"/></svg>`;
+  return {
+    stop: line("var(--stop)"), fast: line("var(--fast)"), bad: line("var(--critical)", "7 4"), cancel: line("var(--muted)", "2 4", 1.4),
+    hold: line("var(--ink-2)", "", 6), turn: `<svg width="14" height="14" aria-hidden="true"><circle cx="7" cy="7" r="5" fill="var(--surface)" stroke="var(--ink-2)" stroke-width="2.2"/></svg>`,
+    single: rect("var(--single)", "var(--grid)"), closed: rect("url(#lg-closed)", "var(--critical)"),
+    slow: rect("var(--warning)", "var(--warning)"), track: rect("var(--serious)", "var(--serious)"),
+  }[kind];
+}
+
+function renderPanels(R) {
+  const where = (c) => {
+    const names = Object.fromEntries(R.points.map((p) => [p.code, p.name]));
+    const a = c.where[0], b = c.where[c.where.length - 1];
+    return a === b ? names[a] : `${names[a]} – ${names[b]}`;
+  };
+  const dis = R.closures.map((c) => `${where(c)} ${WHAT[c.kind] || c.kind}${c.kind === "slow" ? ` (+${c.extra} min)` : ""} ${hhmm(c.start)}–${hhmm(c.end)}${c.cause ? ` (${c.cause})` : ""}`);
+  $("#title").textContent = `${longDay(R.day)}, ${hhmm(R.start)}–${hhmm(R.end)}`;
+  const turned = R.short_turned, cx = R.cancelled;
+  const decisions = [turned ? `${turned} short-turn${turned === 1 ? "" : "s"}` : "", cx ? `${cx} cancellation${cx === 1 ? "" : "s"}` : ""].filter(Boolean).join(", ");
+  $("#sub").textContent = `${dis.join("; ") || "No closures"} · ${TIER[R.difficulty] || R.difficulty} · ${R.runs.length} trains. `
+    + (FIGURE ? `${R.plan_id === "optimal" ? "The proven-optimal plan (CP-SAT)" : R.plan}: cost ${fmt(R.cost)} stop-minutes${decisions ? `, ${decisions}` : ""}.` : `Plan: ${R.plan}.`);
+  const nb = R.violations.length;
+  $("#badge").innerHTML = R.feasible ? `<span class="badge ok"><i>✓</i>legal plan</span>`
+    : `<span class="badge bad"><i>✕</i>${nb} rule break${nb === 1 ? "" : "s"}: scores under 0.2</span>`;
+  const over = R.cost !== null && R.optimal_cost ? R.cost - R.optimal_cost : null;
+  const stat = (k, v, small = "") => `<div class="stat"><span class="k">${k}</span><span class="v num">${v}${small ? `<small>${small}</small>` : ""}</span></div>`;
+  $("#stats").innerHTML = FIGURE ? "" : [
+    stat("Reward", R.reward.toFixed(3)),
+    stat("Cost, stop-minutes", R.cost !== null ? fmt(R.cost) : `${fmt(R.cost_if_legal)}`, R.cost === null ? "if it were legal" : over > 0 ? `+${fmt(over)} over the optimum` : "the optimum"),
+    stat("Optimum", fmt(R.optimal_cost), `floor ${fmt(R.floor_cost)}`),
+    stat("Delay", fmt(R.cost_parts.delay), "stop-min"),
+    stat("Stops not served", fmt(R.cost_parts.unserved / (R.rules.cancel_cost || 30))),
+    stat("Short-turns", fmt(R.short_turned)), stat("Cancelled", fmt(R.cancelled)),
+  ].join("");
+  const br = $("#breaks");
+  br.hidden = !nb;
+  br.innerHTML = R.violations.slice(0, 12).map((v) => `<li>${esc(v.time || "")} ${esc((v.rule || "").replace(/_/g, " "))}: ${esc(v.detail || "")}</li>`).join("")
+    + (nb > 12 ? `<li>… and ${nb - 12} more</li>` : "");
+
+  const kinds = new Set(R.closures.map((c) => c.kind));
+  const anyHold = R.runs.some((r) => r.order && r.order.hold && Object.keys(r.order.hold).length);
+  const anyTurn = R.runs.some((r) => r.order && (r.order.to || r.order.from));
+  const items = [["stop", "stopping train"], ["fast", "fast train"]];
+  if (R.runs.some((r) => r.problems && r.problems.length)) items.push(["bad", "breaks a rule"]);
+  if (anyHold) items.push(["hold", "held by the plan"]);
+  if (anyTurn) items.push(["turn", "short-turn (run ends or starts early)"]);
+  if (R.cancelled) items.push(["cancel", "cancelled (its timetable path)"]);
+  items.push(["single", "single track"]);
+  for (const k of ["closed", "slow", "track"]) if (kinds.has(k)) items.push([k, WHAT[k]]);
+  $("#legend").innerHTML = `<svg width="0" height="0" style="position:absolute"><defs><pattern id="lg-closed" width="5" height="5" patternUnits="userSpaceOnUse" patternTransform="rotate(45)"><rect width="5" height="5" fill="var(--critical)" fill-opacity="0.12"/><line x1="0" y1="0" x2="0" y2="5" stroke="var(--critical)" stroke-opacity="0.6" stroke-width="1.6"/></pattern></defs></svg>`
+    + items.map(([k, t]) => `<span>${legendKey(k)}${esc(t)}</span>`).join("");
+
+  const rows = [...R.runs].sort((a, b) => (a.sched_dep[0] ?? 0) - (b.sched_dep[0] ?? 0));
+  $("#table").innerHTML = `<thead><tr><th>Train</th><th>Set</th><th>Type</th><th>Timetable</th><th>Plan</th><th class="n">Delay (stop-min)</th><th class="n">Stops not served</th><th>Rule breaks</th></tr></thead><tbody>`
+    + rows.map((r) => `<tr><td class="num">${esc(r.train)}</td><td>${esc(r.unit)}</td><td>${r.kind === "fast" ? "fast" : "stopping"}</td>`
+      + `<td>${esc(r.route[0])} ${r.sched_dep[0] !== null ? hhmm(r.sched_dep[0]) : ""} → ${esc(r.route[r.route.length - 1])}</td><td>${esc(orderText(r.order))}</td>`
+      + `<td class="n">${fmt(r.delay)}</td><td class="n">${fmt(r.unserved)}</td><td>${esc((r.problems || []).join(", "))}</td></tr>`).join("") + "</tbody>";
+}
+
+// ---- loading ---------------------------------------------------------------------------------------------------
+
+function setURL() {
+  if (EMBED && !params.has("embed")) return;
+  const p = new URLSearchParams();
+  if (params.has("embed")) p.set("embed", "1");
+  p.set("task", $("#task").value);
+  p.set("plan", $("#plan").value);
+  history.replaceState(null, "", `?${p}`);
+}
+
+async function loadPlans(taskId, want) {
+  const plans = await json(`/api/tasks/${encodeURIComponent(taskId)}/plans`);
+  const groups = { ref: [], model: [], live: [] };
+  for (const p of plans) {
+    const g = p.id.startsWith("run:") ? "model" : p.id.startsWith("episode:") ? "live" : "ref";
+    const r = p.reward === null || p.reward === undefined ? "" : ` · ${Number(p.reward).toFixed(3)}`;
+    groups[g].push(`<option value="${esc(p.id)}">${esc(p.label)}${r}</option>`);
+  }
+  $("#plan").innerHTML = [["ref", "References"], ["model", "Models' submitted plans"], ["live", "Live episodes"]]
+    .filter(([k]) => groups[k].length).map(([k, n]) => `<optgroup label="${n}">${groups[k].join("")}</optgroup>`).join("");
+  $("#plan").value = plans.some((p) => p.id === want) ? want : "optimal";
+}
+
+async function refresh() {
+  const task = $("#task").value, plan = $("#plan").value;
+  $("#open3d").href = `/twin/?task=${encodeURIComponent(task)}&plan=${encodeURIComponent(plan)}`;
+  setURL();
+  try {
+    S.R = await json(`/api/tasks/${encodeURIComponent(task)}/replay?plan=${encodeURIComponent(plan)}`);
+    renderPanels(S.R);
+    draw();
+  } catch (err) {
+    $("#title").innerHTML = `<span class="err">${esc(err.message)}</span>`;
+  }
+}
+
+(async () => {
+  if (EMBED) $("#nav").hidden = true;
+  if (FIGURE) { document.body.classList.add("figure"); $("#controls").hidden = true; $("#tablebox").hidden = true; }
+  if (params.get("theme")) document.documentElement.dataset.theme = params.get("theme");
+  try {
+    S.tasks = await json("/api/tasks");
+  } catch (err) {
+    $("#title").innerHTML = `<span class="err">${esc(err.message)}</span>`;
+    return;
+  }
+  const group = (split) => S.tasks.filter((t) => t.split === split).map((t) =>
+    `<option value="${esc(t.task_id)}">${shortDay(t.day)} ${t.start}–${t.end} · ${esc(TIER[t.difficulty] || t.difficulty)} · ${t.runs} trains</option>`).join("");
+  const splits = [...new Set(S.tasks.map((t) => t.split))].sort((a, b) => (a === "eval" ? -1 : b === "eval" ? 1 : a.localeCompare(b)));
+  $("#task").innerHTML = splits.map((sp) => `<optgroup label="${esc(sp)} split">${group(sp)}</optgroup>`).join("");
+  const want = params.get("task") || FEATURED;
+  $("#task").value = S.tasks.some((t) => t.task_id === want) ? want : S.tasks[0].task_id;
+  await loadPlans($("#task").value, params.get("plan") || "optimal");
+  $("#task").onchange = async () => { await loadPlans($("#task").value, $("#plan").value); refresh(); };
+  $("#plan").onchange = refresh;
+  const svg = $("#chart");
+  svg.addEventListener("pointermove", onMove);
+  svg.addEventListener("pointerleave", () => { $("#tip").hidden = true; $("#paths")?.classList.remove("focus"); });
+  let rt;
+  window.addEventListener("resize", () => { clearTimeout(rt); rt = setTimeout(draw, 120); });
+  await refresh();
+  document.body.dataset.ready = "1";
+})();
+</script>
+</body>
+</html>

openenv/rail_openenv/web/twin/SOURCES.md

@@ -0,0 +1,45 @@
+# The line twin: sources
+
+`twin.json.gz` is built by `envs/rail_ops/tools/twin/build_twin.py` (`fetch`, then `build`). Frame: metres east and
+north of 53.22 N, 6.19 E (equirectangular), stored as integer decimetres.
+
+| What | Source and licence |
+|---|---|
+| track (every rail way near the line: main line, passing loops, yards), platforms, level crossings, station positions | © OpenStreetMap contributors, [ODbL 1.0](https://www.openstreetmap.org/copyright) (Overpass API, data of July-October 2026) |
+| 42,654 buildings (within 700 m of the line), land cover, water, roads and cycle paths, tree rows and trees, wind turbines, windmills, towers, place names | © OpenStreetMap contributors, ODbL 1.0 (same queries) |
+| which platform each direction uses at every station, and the usual terminal tracks | Rijden de Treinen train archive, January-June 2025 (planned platforms; CC BY 4.0, "Rijden de Treinen") |
+| train times | `rail_core.replay`: the grader's own simulation of the plan (`check.simulate`) |
+
+## Real, derived and drawn
+
+**Real:**
+- Track geometry, switches and station layout, as mapped in OSM. Trains follow it per car, so they take the curves
+  and the loop tracks.
+- Each direction's platform at each station, from the record: Hurdegaryp 1 eastbound / 2 westbound, Feanwâlden 2 / 1,
+  De Westereen 2 / 1, Buitenpost 1 / 2, Grijpskerk 2 / 1, Zuidhorn 1 / 2.
+- Leeuwarden bays 6b and 8, the tracks Leeuwarden - Groningen trains used there.
+- The times: every arrival, departure and passing minute is the simulation's. Between them the picture moves
+  smoothly: zero speed at stops, passing speed kept through points the train does not stop at.
+
+**Derived:**
+- Groningen. OSM maps the station as rebuilt (Spoorzone works, 2026): tracks 5 and 6, which the record's 5a and 6a
+  trains used, end at buffer stops on the west side, so no train from Leeuwarden can reach them. The twin stands those
+  trains on OSM tracks 2 and 3, the island platform beside them that is reachable from the west.
+- Terminal track per train: the record's usual split by train type (Leeuwarden: westbound fast trains to 8, stopping
+  trains to 6b; Groningen: fast 6a, stopping 5a). A second train on the same track stands behind the first.
+- Which of the two tracks a train uses at a passing station: its direction's platform, or the other one when that is
+  taken or the train is turning back there.
+- Level crossing barriers close about 35 seconds before a train reaches the crossing and open once it has passed.
+- Signals: one at each entry of every single-track section, red while a train is inside or the section is closed.
+  They show the rule the grader enforces; they are not the line's real signals.
+
+**Drawn (illustrative):**
+- Building heights: OSM `height` or `building:levels` where tagged, else by building type (a house 7 m, a barn 8 m,
+  a warehouse 9 m).
+- Heights of landmarks without a tag: windmills 16 m, wind turbines a 60 m hub, towers 25 m.
+- Trees: the mapped trees and tree rows, plus woods filled at about one tree per 120 m² (capped at 60,000).
+- Train models: every train is drawn as a two-car unit (about 55 m), white, with a blue stripe for stopping trains and
+  orange for fast ones. The record does not say which unit ran which train.
+- The sky and the sun: the solar position for the task's date and minute at the line (local time, CET/CEST).
+
+The replay never changes a cost or a reward. The viewer loads three.js 0.180 from the jsDelivr CDN.

openenv/rail_openenv/web/twin/app.js

@@ -0,0 +1,286 @@
+// The line twin: pick a task and a plan, and watch it run on the real line. Data: /api (rail_core.replay, the grader's
+// own simulation) and ./twin.json.gz (OpenStreetMap). URL: ?task=<id>&plan=<id>&t=<HH:MM>&follow=<unit>&cam=map|chase|cab
+
+import { Line } from "./geo.js";
+import { buildSim, hhmm } from "./motion.js";
+import { CostChart, SERIES, TrainGraph } from "./graph.js";
+import { KIND_COLOR, TwinScene } from "./scene.js";
+
+const $ = (s) => document.querySelector(s);
+const params = new URLSearchParams(location.search);
+const S = { t: 0, playing: false, speed: 60, sim: null, R: null, opt: null, sel: null, cam: "map", lastEvent: -1 };
+const TIER = { real: "real disruption", blockage: "blockage", loop: "lost passing track", compound: "compound" };
+const FEATURED = "gnlw-2025-03-10-0700-210m-blockage-0";
+
+async function json(url) {
+  const r = await fetch(url);
+  if (!r.ok) throw new Error(`${url}: ${r.status} ${await r.text()}`);
+  return r.json();
+}
+
+async function loadTwin() {
+  const r = await fetch("./twin.json.gz");
+  if (!r.ok) throw new Error(`twin.json.gz: HTTP ${r.status}`);
+  const buf = new Uint8Array(await r.arrayBuffer());
+  if (buf[0] === 0x1f && buf[1] === 0x8b) {
+    const stream = new Blob([buf]).stream().pipeThrough(new DecompressionStream("gzip"));
+    return JSON.parse(await new Response(stream).text());
+  }
+  return JSON.parse(new TextDecoder().decode(buf));             // a proxy already decoded it
+}
+
+function parseClock(v, R) {
+  const m = /^(\d{1,2}):(\d{2})$/.exec(v || "");
+  if (!m) return null;
+  let t = +m[1] * 60 + +m[2];
+  if (t < R.start - 120) t += 1440;
+  return t;
+}
+
+function weekday(day) {
+  const d = new Date(`${day}T12:00:00Z`);
+  return d.toLocaleDateString("en-GB", { weekday: "long", day: "numeric", month: "long", year: "numeric", timeZone: "UTC" });
+}
+
+function setURL() {
+  const p = new URLSearchParams();
+  p.set("task", $("#task").value);
+  p.set("plan", $("#plan").value);
+  p.set("t", hhmm(S.t));
+  if (S.sel) p.set("follow", S.sel);
+  if (S.cam !== "map") p.set("cam", S.cam);
+  history.replaceState(null, "", `?${p}`);
+  $("#graphlink").href = `/viewer/?task=${encodeURIComponent($("#task").value)}&plan=${encodeURIComponent($("#plan").value)}`;
+}
+
+// --- panels ----------------------------------------------------------------------------------------------------
+
+function renderScenario(R) {
+  const where = (c) => [...new Set([c.where[0], c.where[c.where.length - 1]])].join("–");
+  const what = { closed: "closed", slow: "slow running", track: "one platform track out of use" };
+  const items = R.closures.map((c) => `<li><b>${where(c)}</b> ${what[c.kind] || c.kind}${c.kind === "slow" ? ` (+${c.extra} min)` : ""}, `
+    + `${hhmm(c.start)}–${hhmm(c.end)}<div class="note">${c.cause || ""}${c.real ? " · from the record" : ""}</div></li>`).join("");
+  const notes = (R.notices || []).slice(0, 3).map((n) => `<li class="note">${n}</li>`).join("");
+  $("#scenario").innerHTML = `<div class="day">${weekday(R.day)}</div>
+    <div class="muted">${hhmm(R.start)}–${hhmm(R.end)} · ${R.runs.length} trains<span class="tier">${TIER[R.difficulty] || R.difficulty}</span></div>
+    <ul>${items}${notes}</ul>`;
+}
+
+function renderResult(R) {
+  const rb = R.violations.length;
+  const pct = R.cost !== null && R.optimal_cost ? Math.round((R.cost / R.optimal_cost - 1) * 100) : null;
+  const viol = R.violations.slice(0, 40).map((v, i) => `<li data-i="${i}">${v.time || ""} ${v.rule.replace("_", " ")}: ${v.detail}</li>`).join("");
+  $("#result").innerHTML = `<div class="plan-name">${R.plan}</div>
+    <div class="hero">${R.reward.toFixed(3)}<small>reward</small></div>
+    <div class="badge ${R.feasible ? "ok" : "bad"}">${R.feasible ? "legal plan" : `${rb} rule break${rb === 1 ? "" : "s"}: scores under 0.2`}</div>
+    <dl>
+      <dt>Cost</dt><dd>${R.cost !== null ? R.cost.toLocaleString() : `${R.cost_if_legal.toLocaleString()} if it were legal`}${pct !== null && pct > 0 ? ` (+${pct}% over the optimum)` : ""}</dd>
+      <dt>Optimum</dt><dd>${R.optimal_cost.toLocaleString()} (floor ${R.floor_cost.toLocaleString()})</dd>
+      <dt>Delay</dt><dd>${R.cost_parts.delay.toLocaleString()} stop-min</dd>
+      <dt>Unserved</dt><dd>${(R.cost_parts.unserved / (R.rules.cancel_cost || 30)).toLocaleString()} stops (${R.cost_parts.unserved.toLocaleString()})</dd>
+      <dt>Handed on</dt><dd>${R.cost_parts.handed_on.toLocaleString()}</dd>
+      <dt>Cancelled</dt><dd>${R.cancelled} runs · ${R.short_turned} turned short</dd>
+    </dl>
+    ${rb ? `<ul class="viol">${viol}</ul>` : ""}`;
+  for (const li of document.querySelectorAll("#result .viol li")) {
+    li.onclick = () => {
+      const v = R.violations[+li.dataset.i];
+      const t = parseClock(v.time, R);
+      if (t !== null) seek(t - 1);
+      if (v.trains && v.trains[0]) selectRun(v.trains[0]);
+    };
+  }
+}
+
+function renderTrains(states) {
+  const ol = $("#trains");
+  const rows = states.slice().sort((a, b) => a.unit.localeCompare(b.unit));
+  $("#ntrains").textContent = `${rows.length} train sets`;
+  const html = rows.map((s) => {
+    const d = Math.round(s.delay);
+    return `<li data-u="${s.unit}" class="${S.sel === s.unit ? "sel" : ""}"><i class="chip" style="background:${KIND_COLOR[s.kind]}"></i>`
+      + `<span class="num">${s.train}</span><span class="muted">${s.dir === "E" ? "→ Groningen" : "← Leeuwarden"}</span>`
+      + `<span class="dl ${d > 0 ? "late" : ""}">${d > 0 ? `+${d} min` : "on time"}</span><span class="st">${s.status}</span></li>`;
+  }).join("");
+  if (ol.dataset.html !== html) {
+    ol.innerHTML = html;
+    ol.dataset.html = html;
+    for (const li of ol.children) li.onclick = () => select(li.dataset.u, true);
+  }
+  const cx = S.sim.cancelled();
+  $("#cxl-h").hidden = !cx.length;
+  $("#cancelled").innerHTML = cx.map((r) => `<li><i class="chip" style="background:${KIND_COLOR[r.kind]}"></i>`
+    + `<span class="num">${r.train}</span><span>${r.route[0]} ${hhmm(r.sched_dep[0])} → ${r.route[r.route.length - 1]}</span>`
+    + `<span>${r.stops.filter(Boolean).length} stops</span></li>`).join("");
+}
+
+function toast(ev) {
+  const box = $("#toasts");
+  const el = document.createElement("div");
+  el.className = `toast ${ev.kind}`;
+  el.innerHTML = `<time>${hhmm(ev.t)}</time>${ev.text}`;
+  box.prepend(el);
+  while (box.children.length > 4) box.lastChild.remove();
+  setTimeout(() => { el.style.opacity = 0; setTimeout(() => el.remove(), 700); }, 4200);
+}
+
+// --- selection and cameras -------------------------------------------------------------------------------------
+
+let scene, graph, cost;
+
+function select(unit, fly) {
+  S.sel = unit;
+  scene.selected = unit;
+  graph.sel = unit;
+  graph.draw();
+  if (fly && unit) setCam(S.cam === "cab" ? "cab" : "chase");
+  setURL();
+}
+
+function selectRun(train) {
+  const r = S.R.runs.find((x) => x.train === train);
+  if (r) select(r.unit, true);
+}
+
+function setCam(mode) {
+  S.cam = mode;
+  for (const [id, m] of [["#cam-map", "map"], ["#cam-follow", "chase"], ["#cam-cab", "cab"]]) $(id).classList.toggle("on", S.cam === m);
+  if (mode === "map") scene.viewAll();
+  else if (S.sel) scene.follow(S.sel, mode);
+  else {
+    const first = S.sim.statesAt(S.t).find((s) => s.moving) || S.sim.statesAt(S.t)[0];
+    if (first) { select(first.unit, false); scene.follow(first.unit, mode); }
+  }
+  setURL();
+}
+
+function seek(t) {
+  S.t = Math.max(S.sim.t0, Math.min(S.sim.t1, t));
+  S.lastEvent = S.R.events.findIndex((e) => e.t !== null && e.t > S.t) - 1;
+  if (S.lastEvent < -1) S.lastEvent = S.R.events.length - 1;
+}
+
+// --- loading a task and a plan ----------------------------------------------------------------------------
+
+async function loadPlans(taskId, want) {
+  const plans = await json(`/api/tasks/${encodeURIComponent(taskId)}/plans`);
+  $("#plan").innerHTML = plans.map((p) => `<option value="${p.id}">${p.label}${p.reward !== null && p.reward !== undefined ? ` · ${(+p.reward).toFixed(3)}` : ""}</option>`).join("");
+  const model = plans.find((p) => p.id.startsWith("run:"));
+  $("#plan").value = plans.some((p) => p.id === want) ? want : model ? model.id : "optimal";
+}
+
+async function loadReplay(keepTime) {
+  const taskId = $("#task").value, planId = $("#plan").value;
+  const [R, opt] = await Promise.all([
+    json(`/api/tasks/${encodeURIComponent(taskId)}/replay?plan=${encodeURIComponent(planId)}`),
+    planId === "optimal" ? null : json(`/api/tasks/${encodeURIComponent(taskId)}/replay?plan=optimal`),
+  ]);
+  const sim = buildSim(R);
+  const prevT = S.t;
+  S.R = R; S.sim = sim; S.opt = opt || R;
+  if (!scene) {
+    scene = new TwinScene($("#stage"), TWIN, new Line(TWIN, R.points));
+    // a click on a train follows it; the end of a drag (panning the map) is not a click
+    let down = null;
+    const el = scene.labels.domElement;
+    el.addEventListener("pointerdown", (e) => { down = [e.clientX, e.clientY]; });
+    el.addEventListener("click", (e) => {
+      if (down && Math.hypot(e.clientX - down[0], e.clientY - down[1]) > 5) return;
+      const u = scene.pick(e.clientX, e.clientY);
+      if (u) select(u, true);
+    });
+    window.twin = { state: S, scene, seek, select, setCam };     // for the browser console and the viewer checks
+  }
+  scene.setReplay(R, sim);
+  graph.set(R, sim.t0, sim.t1);
+  const series = [{ name: planId === "optimal" ? "optimum" : "this plan", costs: R.costs, color: SERIES.plan }];
+  if (opt) series.push({ name: "optimum", costs: opt.costs, color: "#898781", dashed: true });
+  cost.set(series, sim.t0, sim.t1);
+  renderScenario(R);
+  renderResult(R);
+  const clock = parseClock(params.get("t"), R);
+  seek(keepTime ? prevT : clock !== null && !S.booted ? clock : sim.t0);
+  S.booted = true;
+  if (S.sel && !sim.units.some((u) => u.id === S.sel)) S.sel = null;
+  setURL();
+}
+
+// --- main loop ---------------------------------------------------------------------------------------------
+
+let TWIN;
+let last = performance.now(), lastList = 0;
+
+function frame(now) {
+  const dt = Math.min(0.5, (now - last) / 1000);
+  last = now;
+  if (S.sim) {
+    if (S.playing) {
+      S.t += dt * S.speed / 60;
+      if (S.t >= S.sim.t1) { S.t = S.sim.t1; S.playing = false; $("#play").textContent = "▶"; }
+      // the plan's moments as they happen
+      while (S.lastEvent + 1 < S.R.events.length && S.R.events[S.lastEvent + 1].t !== null && S.R.events[S.lastEvent + 1].t <= S.t) {
+        S.lastEvent++;
+        if (S.speed <= 120) toast(S.R.events[S.lastEvent]);
+      }
+    }
+    const states = S.sim.statesAt(S.t);
+    scene.update(S.t, states, dt);
+    graph.setTime(S.t);
+    cost.setTime(S.t);
+    $("#clock b").textContent = `${hhmm(S.t)}:${String(Math.floor((S.t % 1) * 60)).padStart(2, "0")}`;
+    $("#clock span").textContent = `cost so far ${S.sim.costAt(S.t).toLocaleString()}`;
+    if (now - lastList > 250) { renderTrains(states); lastList = now; }
+    scene.render();
+  }
+  requestAnimationFrame(frame);
+}
+
+async function main() {
+  $("#loadmsg").textContent = "OpenStreetMap: track, stations, buildings…";
+  const [twin, tasks] = await Promise.all([loadTwin(), json("/api/tasks")]);
+  TWIN = twin;
+  const label = (t) => `${t.day} ${t.start}–${t.end} · ${TIER[t.difficulty] || t.difficulty} · ${t.runs} trains${t.model_plans ? " · ★" : ""}`;
+  const group = (split) => tasks.filter((t) => t.split === split).sort((a, b) => (b.model_plans - a.model_plans) || a.task_id.localeCompare(b.task_id));
+  $("#task").innerHTML = ["eval", "train"].map((sp) => `<optgroup label="${sp === "eval" ? "Eval (★ has a model's plan)" : "Train"}">`
+    + group(sp).map((t) => `<option value="${t.task_id}">${label(t)}</option>`).join("") + "</optgroup>").join("");
+  const want = params.get("task");
+  $("#task").value = tasks.some((t) => t.task_id === want) ? want : tasks.some((t) => t.task_id === FEATURED) ? FEATURED : tasks[0].task_id;
+  $("#station").innerHTML += twin.stations.map((s) => `<option value="${s.code}">${s.name}</option>`).join("");
+  graph = new TrainGraph($("#graph"), $("#gtip"), (t) => seek(t), (u) => select(u, false));
+  cost = new CostChart($("#cost"), $("#ctip"), (t) => seek(t));
+  $("#loadmsg").textContent = "The plan: every train's simulated times…";
+  await loadPlans($("#task").value, params.get("plan"));
+  await loadReplay(false);
+  if (params.get("follow")) select(params.get("follow"), false);
+  if (params.get("cam") && params.get("cam") !== "map") setCam(params.get("cam"));
+  $("#loading").classList.add("done");
+
+  $("#task").onchange = async () => { S.sel = null; scene.selected = null; await loadPlans($("#task").value, $("#plan").value); await loadReplay(false); setCam("map"); };
+  $("#plan").onchange = () => loadReplay(true);
+  $("#play").onclick = () => { S.playing = !S.playing; if (S.playing && S.t >= S.sim.t1) seek(S.sim.t0); $("#play").textContent = S.playing ? "⏸" : "▶"; };
+  $("#restart").onclick = () => seek(S.sim.t0);
+  $("#speed").onchange = () => { S.speed = +$("#speed").value; };
+  $("#cam-map").onclick = () => setCam("map");
+  $("#cam-follow").onclick = () => setCam("chase");
+  $("#cam-cab").onclick = () => setCam("cab");
+  $("#panels").onclick = () => { document.body.classList.toggle("clean"); $("#panels").classList.toggle("on", document.body.classList.contains("clean")); };
+  $("#station").onchange = () => { if ($("#station").value) { S.cam = "map"; scene.viewStation($("#station").value); $("#station").value = ""; } };
+  window.addEventListener("keydown", (e) => {
+    if (e.target.tagName === "SELECT") return;
+    if (e.code === "Space") { e.preventDefault(); $("#play").click(); }
+    else if (e.code === "ArrowRight") seek(S.t + (e.shiftKey ? 10 : 1));
+    else if (e.code === "ArrowLeft") seek(S.t - (e.shiftKey ? 10 : 1));
+    else if (e.code === "Home") seek(S.sim.t0);
+    else if (e.key === "m") setCam("map");
+    else if (e.key === "f") setCam("chase");
+    else if (e.key === "c") setCam("cab");
+    else if (e.key === "h") $("#panels").click();
+  });
+  setInterval(setURL, 2000);
+  requestAnimationFrame(frame);
+}
+
+main().catch((e) => {
+  $("#loadmsg").textContent = `Could not start: ${e.message}`;
+  console.error(e);
+});

openenv/rail_openenv/web/twin/geo.js

@@ -0,0 +1,138 @@
+// The line on the map: routes (OSM track paths built by tools/twin/build_twin.py) and where a network km lies on them.
+//
+// A route is one direction's lane from a terminal track to the other terminal track, through the platform tracks that
+// direction uses in the record. Every network point has an anchor (its distance along the route), so km -> place is
+// piecewise linear between anchors. A train that stands on the other track at a station (a turned train, or a second
+// train there) blends onto the other direction's route inside that station's zone: fully between the switches that
+// bound a loop, with a ramp where the zone ends on double track (a crossover).
+//
+// Frame: metres east (x) and north (y) of the twin origin. No DOM and no three.js here (node-testable).
+
+export const CANONICAL = { E: "E-8-5a", W: "W-5a-8" };
+const RAMP_SWITCH = 0.03;    // km: zones bounded by a switch, where the two tracks meet
+const RAMP_CROSS = 0.25;     // km: zones that end on double track
+
+export function smoothstep(u) {
+  const x = Math.min(1, Math.max(0, u));
+  return x * x * (3 - 2 * x);
+}
+
+export class Route {
+  constructor(key, data, kmOf) {
+    this.key = key;
+    this.dir = data.dir;
+    const p = data.p;
+    const n = p.length / 2;
+    this.x = new Float64Array(n);
+    this.y = new Float64Array(n);
+    this.s = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+      this.x[i] = p[2 * i] / 10;
+      this.y[i] = p[2 * i + 1] / 10;
+      if (i) this.s[i] = this.s[i - 1] + Math.hypot(this.x[i] - this.x[i - 1], this.y[i] - this.y[i - 1]);
+    }
+    this.length = this.s[n - 1];
+    // anchors sorted by km (the route's s grows with km eastbound, shrinks westbound)
+    this.anchors = Object.entries(data.anchors)
+      .filter(([c]) => kmOf[c] !== undefined)
+      .map(([c, s]) => [kmOf[c], s])
+      .sort((a, b) => a[0] - b[0]);
+  }
+
+  sAtKm(km) {
+    const a = this.anchors;
+    if (km <= a[0][0]) return a[0][1] + (km - a[0][0]) * 1000 * (this.dir === "E" ? 1 : -1);
+    for (let i = 1; i < a.length; i++) {
+      if (km <= a[i][0]) {
+        const [k0, s0] = a[i - 1], [k1, s1] = a[i];
+        return s0 + (s1 - s0) * (km - k0) / (k1 - k0);
+      }
+    }
+    const [kl, sl] = a[a.length - 1];
+    return sl + (km - kl) * 1000 * (this.dir === "E" ? 1 : -1);
+  }
+
+  kmAtS(s) {
+    const a = this.dir === "E" ? this.anchors : [...this.anchors].reverse();
+    if (s <= a[0][1]) return a[0][0] + (s - a[0][1]) / 1000 * (this.dir === "E" ? 1 : -1);
+    for (let i = 1; i < a.length; i++) {
+      if (s <= a[i][1]) {
+        const [k0, s0] = a[i - 1], [k1, s1] = a[i];
+        return k0 + (k1 - k0) * (s - s0) / (s1 - s0);
+      }
+    }
+    const [kl, sl] = a[a.length - 1];
+    return kl + (s - sl) / 1000 * (this.dir === "E" ? 1 : -1);
+  }
+
+  // [x, y] at distance s (clamped to the route)
+  pointAtS(s) {
+    const S = this.s;
+    const n = S.length;
+    if (s <= 0) return [this.x[0], this.y[0]];
+    if (s >= this.length) return [this.x[n - 1], this.y[n - 1]];
+    let lo = 0, hi = n - 1;
+    while (hi - lo > 1) {
+      const mid = (lo + hi) >> 1;
+      if (S[mid] <= s) lo = mid; else hi = mid;
+    }
+    const L = S[hi] - S[lo];
+    const t = L > 0 ? (s - S[lo]) / L : 0;
+    return [this.x[lo] + t * (this.x[hi] - this.x[lo]), this.y[lo] + t * (this.y[hi] - this.y[lo])];
+  }
+
+  pointAtKm(km) {
+    return this.pointAtS(this.sAtKm(km));
+  }
+}
+
+export class Line {
+  // twin: the decoded twin.json; points: [{code, km}] from the replay (the network)
+  constructor(twin, points) {
+    this.kmOf = Object.fromEntries(points.map((p) => [p.code, p.km]));
+    this.routes = {};
+    for (const [k, d] of Object.entries(twin.routes)) this.routes[k] = new Route(k, d, this.kmOf);
+    this.zones = twin.zones || {};
+  }
+
+  routeKey(dir, lw, gn) {
+    return dir === "E" ? `E-${lw}-${gn}` : `W-${gn}-${lw}`;
+  }
+
+  route(dir, lw, gn) {
+    return this.routes[this.routeKey(dir, lw, gn)] || this.routes[CANONICAL[dir]];
+  }
+
+  // weight in [0, 1] of the other track at km, for a train standing on track `lane` at station `code`
+  blendWeight(code, km) {
+    const z = this.zones[code];
+    if (!z) return 0;
+    const [k0, k1, sw0, sw1] = z;
+    if (km < k0 || km > k1) return 0;
+    const r0 = sw0 ? RAMP_SWITCH : RAMP_CROSS, r1 = sw1 ? RAMP_SWITCH : RAMP_CROSS;
+    return Math.min(smoothstep((km - k0) / r0), smoothstep((k1 - km) / r1));
+  }
+
+  // [x, y] of a point km along a train's route; lanes: {station: "E" | "W"} where it uses that track
+  place(dir, lw, gn, km, lanes) {
+    const own = this.route(dir, lw, gn);
+    const p = own.pointAtKm(km);
+    if (!lanes) return p;
+    for (const [code, lane] of Object.entries(lanes)) {
+      if (lane === dir) continue;
+      const w = this.blendWeight(code, km);
+      if (w <= 0) continue;
+      const q = this.routes[CANONICAL[lane]].pointAtKm(km);
+      return [p[0] + w * (q[0] - p[0]), p[1] + w * (q[1] - p[1])];
+    }
+    return p;
+  }
+
+  // points along a train: [[x, y], ...] at the given distances (metres) ahead (+) or behind (-) its centre, which
+  // is where the simulation puts it (a stopped train's centre is at the platform's stop point)
+  body(dir, lw, gn, kmCentre, offsets, lanes) {
+    const r = this.route(dir, lw, gn);
+    const s0 = r.sAtKm(kmCentre);
+    return offsets.map((d) => this.place(dir, lw, gn, r.kmAtS(s0 + d), lanes));
+  }
+}

openenv/rail_openenv/web/twin/graph.js

@@ -0,0 +1,313 @@
+// The two charts under the map, on 2D canvases: the train graph (time across, distance down: every train's path,
+// disruptions shaded, the moment being shown) with the plan's events on a strip below it, and the cost so far
+// against the optimum's. Both are cursors on the same clock: click or drag to move it, hover to read a value.
+
+import { hhmm } from "./motion.js";
+
+const INK = { primary: "#ffffff", secondary: "#c3c2b7", muted: "#898781", grid: "#2c2c2a", axis: "#383835",
+  surface: "#1a1a19" };
+export const SERIES = { stop: "#3987e5", fast: "#d95926", plan: "#199e70" };
+const STATUS = { critical: "#d03b3b", warning: "#fab219", serious: "#ec835a", good: "#0ca30c" };
+const GLYPH = { hold: "‖", turn: "↩", cancel: "✕", violation: "!", closure: "▼", reopen: "▲" };
+
+function fit(canvas) {
+  const r = canvas.getBoundingClientRect();
+  const dpr = Math.min(window.devicePixelRatio || 1, 2);
+  if (canvas.width !== Math.round(r.width * dpr) || canvas.height !== Math.round(r.height * dpr)) {
+    canvas.width = Math.round(r.width * dpr);
+    canvas.height = Math.round(r.height * dpr);
+  }
+  const g = canvas.getContext("2d");
+  g.setTransform(dpr, 0, 0, dpr, 0, 0);
+  return [g, r.width, r.height];
+}
+
+export class TrainGraph {
+  constructor(canvas, tip, onSeek, onPick) {
+    this.c = canvas;
+    this.tip = tip;
+    this.onSeek = onSeek;
+    this.onPick = onPick;
+    this.R = null;
+    this.t = 0;
+    this.sel = null;
+    this.hover = null;
+    let drag = false;
+    canvas.addEventListener("pointerdown", (e) => { drag = true; canvas.setPointerCapture(e.pointerId); this.seekAt(e, true); });
+    canvas.addEventListener("pointermove", (e) => { if (drag) this.seekAt(e, false); this.hoverAt(e); });
+    canvas.addEventListener("pointerup", () => { drag = false; });
+    canvas.addEventListener("pointerleave", () => { this.hover = null; this.tip.hidden = true; this.draw(); });
+  }
+
+  set(R, t0, t1) {
+    this.R = R;
+    this.t0 = t0;
+    this.t1 = t1;
+    this.km = Object.fromEntries(R.points.map((p) => [p.code, p.km]));
+    this.kmMax = Math.max(...R.points.map((p) => p.km));
+    // each served run as a polyline of (minute, km)
+    this.paths = R.runs.filter((r) => !r.cancelled).map((r) => {
+      const pts = [];
+      if (r.started && r.fixed_from !== null && r.fixed_from !== undefined) pts.push([r.fixed_from, this.km[r.route[r.fixed_to - 1]]]);
+      const from = r.started ? r.fixed_to : r.first;
+      for (let i = from; i <= r.last; i++) {
+        const k = this.km[r.route[i]];
+        if (r.arr[i] !== null && r.arr[i] !== undefined && !(i === from && !r.started)) pts.push([r.arr[i], k]);
+        if (r.dep[i] !== null && r.dep[i] !== undefined && i < r.last) pts.push([r.dep[i], k]);
+      }
+      return { train: r.train, unit: r.unit, kind: r.kind, pts, bad: r.problems.length > 0 };
+    });
+    this.draw();
+  }
+
+  frame() {
+    const [g, w, h] = fit(this.c);
+    const L = 44, Rp = 10, T = 8, B = 30, strip = 16;
+    return { g, w, h, L, Rp, T, B, strip, gh: h - T - B - strip,
+      x: (t) => L + (t - this.t0) / (this.t1 - this.t0) * (w - L - Rp),
+      tx: (x) => this.t0 + (x - L) / (w - L - Rp) * (this.t1 - this.t0),
+      y: (km) => T + km / this.kmMax * (h - T - B - strip) };
+  }
+
+  seekAt(e, pick) {
+    if (!this.R) return;
+    const f = this.frame();
+    const r = this.c.getBoundingClientRect();
+    const t = Math.max(this.t0, Math.min(this.t1, f.tx(e.clientX - r.left)));
+    this.onSeek(t);
+    if (pick && this.hover) this.onPick(this.hover.unit);
+  }
+
+  hoverAt(e) {
+    if (!this.R) return;
+    const f = this.frame();
+    const r = this.c.getBoundingClientRect();
+    const mx = e.clientX - r.left, my = e.clientY - r.top;
+    let best = null, bd = 10;
+    for (const p of this.paths) {
+      for (let i = 1; i < p.pts.length; i++) {
+        const [ta, ka] = p.pts[i - 1], [tb, kb] = p.pts[i];
+        const ax = f.x(ta), ay = f.y(ka), bx = f.x(tb), by = f.y(kb);
+        const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy || 1;
+        const u = Math.max(0, Math.min(1, ((mx - ax) * dx + (my - ay) * dy) / L2));
+        const d = Math.hypot(mx - ax - u * dx, my - ay - u * dy);
+        if (d < bd) { bd = d; best = { ...p, t: ta + u * (tb - ta), km: ka + u * (kb - ka) }; }
+      }
+    }
+    this.hover = best;
+    if (best) {
+      const code = Object.entries(this.km).reduce((a, [c, k]) => (Math.abs(k - best.km) < Math.abs(a[1] - best.km) ? [c, k] : a), ["", 1e9]);
+      const near = Math.abs(code[1] - best.km) < 0.3 ? `at ${code[0]}` : `km ${best.km.toFixed(1)}`;
+      this.tip.innerHTML = `<b>${best.train}</b> ${best.kind === "fast" ? "fast" : "stopping"} · ${hhmm(best.t)} ${near}`;
+      this.tip.style.left = `${Math.min(r.width - 180, mx + 12)}px`;
+      this.tip.style.top = `${my - 28}px`;
+      this.tip.hidden = false;
+    } else {
+      this.tip.hidden = true;
+    }
+    this.draw();
+  }
+
+  draw() {
+    if (!this.R) return;
+    const f = this.frame();
+    const { g, w, h, L, Rp, T, B, strip } = f;
+    g.clearRect(0, 0, w, h);
+    g.font = "11px system-ui, -apple-system, 'Segoe UI', sans-serif";
+    // disruptions
+    for (const c of this.R.closures) {
+      const a = this.km[c.where[0]], b = this.km[c.where[c.where.length - 1]];
+      const k0 = c.kind === "track" ? a - 0.4 : Math.min(a, b), k1 = c.kind === "track" ? a + 0.4 : Math.max(a, b);
+      g.fillStyle = c.kind === "closed" ? STATUS.critical : c.kind === "slow" ? STATUS.warning : STATUS.serious;
+      g.globalAlpha = 0.22;
+      g.fillRect(f.x(c.start), f.y(k0), f.x(c.end) - f.x(c.start), Math.max(3, f.y(k1) - f.y(k0)));
+      g.globalAlpha = 1;
+    }
+    // stations: hairlines and names
+    g.textAlign = "right";
+    g.textBaseline = "middle";
+    let lastY = -Infinity;
+    for (const p of this.R.points) {
+      const y = f.y(p.km);
+      g.strokeStyle = INK.grid;
+      g.lineWidth = 1;
+      g.beginPath(); g.moveTo(L, y + 0.5); g.lineTo(w - Rp, y + 0.5); g.stroke();
+      const major = p.kind === "terminal" || p.turn;              // terminals and turn points first
+      if (p.kind !== "junction" && (y - lastY >= 11 || major)) {
+        g.fillStyle = major ? INK.secondary : INK.muted;
+        g.fillText(p.code, L - 6, y);
+        lastY = y;
+      }
+    }
+    // hours
+    g.textAlign = "center";
+    g.textBaseline = "top";
+    const step = this.t1 - this.t0 > 300 ? 60 : 30;
+    for (let t = Math.ceil(this.t0 / step) * step; t <= this.t1; t += step) {
+      const x = f.x(t);
+      g.strokeStyle = INK.grid;
+      g.beginPath(); g.moveTo(x + 0.5, T); g.lineTo(x + 0.5, T + f.gh); g.stroke();
+      g.fillStyle = INK.muted;
+      g.fillText(hhmm(t), x, h - B + strip + 6);
+    }
+    // the window's start and end
+    g.strokeStyle = INK.axis;
+    for (const t of [this.R.start, this.R.end]) {
+      const x = f.x(t);
+      g.beginPath(); g.moveTo(x + 0.5, T); g.lineTo(x + 0.5, T + f.gh); g.stroke();
+    }
+    // train paths
+    const focus = this.sel ?? (this.hover && this.hover.unit);
+    for (const p of this.paths) {
+      const on = !focus || p.unit === focus;
+      g.strokeStyle = SERIES[p.kind] || SERIES.stop;
+      g.globalAlpha = on ? 1 : 0.28;
+      g.lineWidth = focus && p.unit === focus ? 3 : 1.5;
+      g.lineJoin = "round";
+      g.beginPath();
+      p.pts.forEach(([t, k], i) => (i ? g.lineTo(f.x(t), f.y(k)) : g.moveTo(f.x(t), f.y(k))));
+      g.stroke();
+    }
+    g.globalAlpha = 1;
+    // rule breaks: a cross where and when each happens
+    g.strokeStyle = STATUS.critical;
+    g.lineWidth = 2;
+    for (const v of this.R.violations) {
+      if (!v.time || !v.where) continue;
+      const [hh, mm] = v.time.split(":").map(Number);
+      let t = hh * 60 + mm;
+      if (t < this.R.start - 120) t += 1440;
+      const ends = v.where.split("-").filter((c) => this.km[c] !== undefined);
+      if (!ends.length) continue;
+      const k = ends.reduce((a, c) => a + this.km[c], 0) / ends.length;
+      const x = f.x(t), y = f.y(k);
+      g.beginPath(); g.moveTo(x - 4, y - 4); g.lineTo(x + 4, y + 4); g.moveTo(x + 4, y - 4); g.lineTo(x - 4, y + 4); g.stroke();
+    }
+    // events strip
+    const sy = T + f.gh + 4;
+    g.textAlign = "center";
+    g.textBaseline = "top";
+    g.font = "bold 11px system-ui, -apple-system, 'Segoe UI', sans-serif";
+    for (const ev of this.R.events) {
+      if (ev.t === null || ev.t === undefined) continue;
+      const x = f.x(ev.t);
+      g.fillStyle = ev.kind === "violation" || ev.kind === "closure" ? STATUS.critical : ev.kind === "reopen" ? STATUS.good : INK.secondary;
+      g.fillText(GLYPH[ev.kind] || "·", x, sy);
+    }
+    // the cursor
+    const x = f.x(this.t);
+    g.strokeStyle = INK.primary;
+    g.lineWidth = 1.5;
+    g.beginPath(); g.moveTo(x, T); g.lineTo(x, T + f.gh + strip); g.stroke();
+  }
+
+  setTime(t) {
+    this.t = t;
+    this.draw();
+  }
+}
+
+export class CostChart {
+  constructor(canvas, tip, onSeek) {
+    this.c = canvas;
+    this.tip = tip;
+    this.onSeek = onSeek;
+    this.t = 0;
+    canvas.addEventListener("pointermove", (e) => this.hoverAt(e));
+    canvas.addEventListener("pointerleave", () => { this.tip.hidden = true; });
+    canvas.addEventListener("pointerdown", (e) => {
+      const f = this.frame(), r = canvas.getBoundingClientRect();
+      this.onSeek(Math.max(this.t0, Math.min(this.t1, f.tx(e.clientX - r.left))));
+    });
+  }
+
+  // series: [{name, costs: [[t, amount], ...], color, dashed}]
+  set(series, t0, t1) {
+    this.series = series.map((s) => {
+      let sum = 0;
+      const steps = [[t0, 0]];
+      for (const [t, a] of s.costs) { sum += a; steps.push([t, sum]); }
+      return { ...s, steps, total: sum };
+    });
+    this.t0 = t0;
+    this.t1 = t1;
+    this.max = Math.max(10, ...this.series.map((s) => s.total)) * 1.08;
+    this.draw();
+  }
+
+  frame() {
+    const [g, w, h] = fit(this.c);
+    const L = 44, Rp = 92, T = 22, B = 22;
+    return { g, w, h, L, Rp, T, B,
+      x: (t) => L + (t - this.t0) / (this.t1 - this.t0) * (w - L - Rp),
+      tx: (x) => this.t0 + (x - L) / (w - L - Rp) * (this.t1 - this.t0),
+      y: (v) => h - B - v / this.max * (h - T - B) };
+  }
+
+  valueAt(s, t) {
+    let v = 0;
+    for (const [tt, sum] of s.steps) { if (tt > t) break; v = sum; }
+    return v;
+  }
+
+  hoverAt(e) {
+    if (!this.series) return;
+    const f = this.frame(), r = this.c.getBoundingClientRect();
+    const t = Math.max(this.t0, Math.min(this.t1, f.tx(e.clientX - r.left)));
+    this.tip.innerHTML = `${hhmm(t)}<br>` + this.series.map((s) => `${s.name}: <b>${this.valueAt(s, t).toLocaleString()}</b>`).join("<br>");
+    this.tip.style.left = `${Math.min(r.width - 150, e.clientX - r.left + 12)}px`;
+    this.tip.style.top = "6px";
+    this.tip.hidden = false;
+  }
+
+  draw() {
+    if (!this.series) return;
+    const f = this.frame();
+    const { g, w, h, L, Rp, T, B } = f;
+    g.clearRect(0, 0, w, h);
+    g.font = "11px system-ui, -apple-system, 'Segoe UI', sans-serif";
+    g.fillStyle = INK.secondary;
+    g.textAlign = "left";
+    g.textBaseline = "top";
+    g.fillText("Cost so far (stop-minutes)", L, 4);
+    // y grid: three hairlines
+    g.textAlign = "right";
+    g.textBaseline = "middle";
+    for (let i = 0; i <= 3; i++) {
+      const v = (this.max / 1.08) * i / 3;
+      const y = Math.round(f.y(v)) + 0.5;
+      g.strokeStyle = i ? INK.grid : INK.axis;
+      g.beginPath(); g.moveTo(L, y); g.lineTo(w - Rp, y); g.stroke();
+      g.fillStyle = INK.muted;
+      g.fillText(Math.round(v).toLocaleString(), L - 6, y);
+    }
+    // the series as step lines, with the total labelled at the end
+    for (const s of this.series) {
+      g.strokeStyle = s.color;
+      g.lineWidth = 2;
+      g.setLineDash(s.dashed ? [5, 4] : []);
+      g.beginPath();
+      let prev = null;
+      for (const [t, v] of s.steps) {
+        const x = f.x(Math.min(this.t1, t)), y = f.y(v);
+        if (prev === null) g.moveTo(x, y); else { g.lineTo(x, prev); g.lineTo(x, y); }
+        prev = y;
+      }
+      g.lineTo(f.x(this.t1), prev);
+      g.stroke();
+      g.setLineDash([]);
+      g.fillStyle = INK.primary;
+      g.textAlign = "left";
+      g.fillText(`${s.name} ${s.total.toLocaleString()}`, w - Rp + 6, Math.max(T, Math.min(h - B, f.y(s.total))));
+    }
+    const x = f.x(this.t);
+    g.strokeStyle = INK.primary;
+    g.lineWidth = 1.5;
+    g.beginPath(); g.moveTo(x, T); g.lineTo(x, h - B); g.stroke();
+  }
+
+  setTime(t) {
+    this.t = t;
+    this.draw();
+  }
+}

openenv/rail_openenv/web/twin/index.html

@@ -0,0 +1,80 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>RailSimEnv line twin</title>
+<link rel="icon" href="data:,">
+<link rel="stylesheet" href="style.css">
+<script type="importmap">
+{
+  "imports": {
+    "three": "https://cdn.jsdelivr.net/npm/three@0.180.0/build/three.module.js",
+    "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.180.0/examples/jsm/"
+  }
+}
+</script>
+</head>
+<body>
+<div id="stage"></div>
+
+<header id="bar">
+  <div class="brand"><b>RailSimEnv</b><span>Leeuwarden – Groningen</span></div>
+  <label class="pick"><span>Task</span><select id="task" aria-label="Task"></select></label>
+  <label class="pick"><span>Plan</span><select id="plan" aria-label="Plan"></select></label>
+  <div class="transport">
+    <button id="restart" title="Back to the start (Home)" aria-label="Back to the start">⏮</button>
+    <button id="play" title="Play / pause (Space)" aria-label="Play">▶</button>
+    <select id="speed" title="Playback speed" aria-label="Playback speed">
+      <option value="1">1×</option><option value="10">10×</option><option value="30">30×</option>
+      <option value="60" selected>60×</option><option value="120">120×</option><option value="300">300×</option>
+    </select>
+    <div id="clock" aria-live="off"><b>--:--</b><span></span></div>
+  </div>
+  <div class="cams" role="group" aria-label="Camera">
+    <button id="cam-map" class="on" title="The whole line (M)">Line</button>
+    <button id="cam-follow" title="Follow the selected train (F)">Follow</button>
+    <button id="cam-cab" title="Driver's view of the selected train (C)">Cab</button>
+    <select id="station" aria-label="Go to a station"><option value="">Station…</option></select>
+  </div>
+  <button id="panels" title="Hide or show the panels (H)">Panels</button>
+  <a class="graphlink" id="graphlink" href="/viewer/" title="This plan on the train graph">Train graph ↗</a>
+  <a class="graphlink" href="/explorer/" title="Every model's plan on every eval task">Eval explorer ↗</a>
+</header>
+
+<aside id="left" class="panel">
+  <section id="scenario"></section>
+  <section id="result"></section>
+  <section class="legend">
+    <div><i class="chip" style="background:#3987e5"></i>Stopping train <i class="chip" style="background:#d95926"></i>Fast train</div>
+    <div><i class="bar closed"></i>Closed <i class="bar slow"></i>Slow <i class="bar track"></i>Track out of use</div>
+    <div><i class="bar single"></i>Single track <i class="bar double"></i>Double track (from far away)</div>
+    <div class="muted">Signals guard each single-track section: red while a train is in it or it is closed.</div>
+  </section>
+</aside>
+
+<aside id="right" class="panel">
+  <h2>Trains <span id="ntrains" class="muted"></span></h2>
+  <ol id="trains"></ol>
+  <h3 id="cxl-h" hidden>Cancelled</h3>
+  <ol id="cancelled"></ol>
+</aside>
+
+<footer id="bottom" class="panel">
+  <div class="graphwrap">
+    <div class="chart-h"><b>Train graph</b><span class="muted">time across, distance down · click to jump, hover to read</span></div>
+    <canvas id="graph"></canvas>
+    <div id="gtip" class="tip" hidden></div>
+  </div>
+  <div class="costwrap">
+    <canvas id="cost"></canvas>
+    <div id="ctip" class="tip" hidden></div>
+  </div>
+</footer>
+
+<div id="toasts" aria-live="polite"></div>
+<div id="loading"><div><b>Building the line</b><p id="loadmsg">OpenStreetMap: track, stations, buildings…</p></div></div>
+<noscript>The line twin needs JavaScript and WebGL.</noscript>
+<script type="module" src="app.js"></script>
+</body>
+</html>

openenv/rail_openenv/web/twin/motion.js

@@ -0,0 +1,398 @@
+// Trains in time: where every train set is at any moment under a plan, from the replay's simulated times
+// (rail_core.replay, which uses the grader's own simulate). Nothing here changes a time: positions between the
+// simulated minutes are a smooth monotone curve (stopped trains have zero speed, passing trains keep theirs).
+//
+// A train set's window is a chain of segments: it stands (at a station, a turn point, a terminal), moves (one run, or
+// the part of it the plan keeps), stands again. Track allocation is for the picture only:
+//   - terminals: the record's usual tracks (Leeuwarden 6b/8, Groningen 5a/6a by train type), a second train on the
+//     same track stands behind the first;
+//   - two-track stations: each direction's own platform (as in the record); a train that finds it taken, or a turned
+//     train, uses the other track.
+//
+// No DOM and no three.js here (node-testable). Times are minutes after midnight of the service day; km as the network.
+
+export const SLOT_KM = 0.065;      // a second train on a terminal track stands this far behind the first
+export const TRAIN_M = 55;         // a two-car unit, metres
+const PAD = 0.5;                   // minutes of margin when sharing a station track
+
+export function lwTrack(run, arriving) {
+  // record (Jan-Jun 2025): westbound arrivals fast -> 8, stopping -> 6b; eastbound departures fast -> 6b, stop -> 8
+  if (arriving) return run.kind === "fast" ? "8" : "6b";
+  return run.kind === "fast" ? "6b" : "8";
+}
+
+export function gnTrack(run) {
+  return run.kind === "fast" ? "6a" : "5a";    // record: fast trains mostly 6a, stopping trains 5a
+}
+
+export function hhmm(m) {
+  if (m === null || m === undefined || !Number.isFinite(m)) return "--:--";
+  const t = Math.floor(m + 1e-9);
+  return `${String(Math.floor(t / 60) % 24).padStart(2, "0")}:${String(t % 60).padStart(2, "0")}`;
+}
+
+// --- monotone cubic Hermite through (t, x) knots; stop knots have zero slope ---------------------------------
+
+export function hermite(knots) {
+  const n = knots.length;
+  const t = knots.map((k) => k.t), x = knots.map((k) => k.x), m = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    if (knots[i].stop) continue;
+    const d0 = i > 0 ? (x[i] - x[i - 1]) / (t[i] - t[i - 1]) : null;
+    const d1 = i < n - 1 ? (x[i + 1] - x[i]) / (t[i + 1] - t[i]) : null;
+    if (d0 === null) m[i] = d1;
+    else if (d1 === null) m[i] = d0;
+    else if (d0 * d1 <= 0) m[i] = 0;
+    else {
+      const h0 = t[i] - t[i - 1], h1 = t[i + 1] - t[i];
+      const w1 = 2 * h1 + h0, w2 = h1 + 2 * h0;
+      m[i] = (w1 + w2) / (w1 / d0 + w2 / d1);
+    }
+  }
+  return { t, x, m };
+}
+
+export function evalHermite(H, tq) {
+  const { t, x, m } = H;
+  const n = t.length;
+  if (n === 1 || tq <= t[0]) return [x[0], 0];
+  if (tq >= t[n - 1]) return [x[n - 1], 0];
+  let lo = 0, hi = n - 1;
+  while (hi - lo > 1) {
+    const mid = (lo + hi) >> 1;
+    if (t[mid] <= tq) lo = mid; else hi = mid;
+  }
+  const h = t[hi] - t[lo];
+  const u = (tq - t[lo]) / h, u2 = u * u, u3 = u2 * u;
+  const pos = (2 * u3 - 3 * u2 + 1) * x[lo] + (u3 - 2 * u2 + u) * h * m[lo] + (-2 * u3 + 3 * u2) * x[hi]
+    + (u3 - u2) * h * m[hi];
+  const vel = ((6 * u2 - 6 * u) * x[lo] + (3 * u2 - 4 * u + 1) * h * m[lo] + (-6 * u2 + 6 * u) * x[hi]
+    + (3 * u2 - 2 * u) * h * m[hi]) / h;
+  return [pos, vel];
+}
+
+// --- the simulation picture ------------------------------------------------------------------------------------
+
+export function buildSim(R) {
+  const kmOf = Object.fromEntries(R.points.map((p) => [p.code, p.km]));
+  const point = Object.fromEntries(R.points.map((p) => [p.code, p]));
+  const codes = R.points.map((p) => p.code);
+  const west = codes[0], east = codes[codes.length - 1];
+  const runOf = new Map(R.runs.map((r) => [r.train, r]));
+  const units = [];
+
+  for (const u of R.units) {
+    const runs = u.runs.map((id) => runOf.get(id)).filter(Boolean);
+    const segs = [];
+    let at = u.at, since = R.start, prev = null;
+    for (const r of runs) {
+      if (r.cancelled) continue;
+      const s = r.first, e = r.last;
+      const k = r.started ? r.fixed_to : s;
+      let t0;
+      if (r.started && r.fixed_from !== null && r.fixed_from !== undefined) {
+        t0 = r.fixed_from;                                   // already running when the window starts
+      } else {
+        const where = r.route[k];
+        const dep = r.dep[k];
+        // an illegal plan can start a run where its train set is not (a continuity break): the set waits where it
+        // is and jumps when the run leaves, as the grader's simulation has it
+        const standAt = prev && at && at !== where ? at : where;
+        segs.push({ type: "stand", code: standAt, t0: Math.min(since, dep), t1: dep, prev, next: r });
+        t0 = dep;
+      }
+      segs.push({ type: "move", run: r, dir: r.dir, t0, t1: r.arr[e], k, s, e, lanes: {} });
+      at = r.route[e];
+      since = r.arr[e];
+      prev = r;
+    }
+    if (at) segs.push({ type: "stand", code: at, t0: since, t1: Infinity, prev, next: null });
+    units.push({ id: u.id, runs, segs });
+  }
+
+  // terminals: which track, and which slot on it
+  const slotUse = {};
+  const standsAtTerminals = [];
+  for (const un of units) {
+    un.segs.forEach((sg, i) => {
+      if (sg.type !== "stand" || (sg.code !== west && sg.code !== east)) return;
+      let track;
+      if (sg.code === west) track = sg.prev && sg.prev.dir === "W" ? lwTrack(sg.prev, true) : sg.next ? lwTrack(sg.next, false) : "8";
+      else track = sg.prev && sg.prev.dir === "E" ? gnTrack(sg.prev) : sg.next ? gnTrack(sg.next) : "5a";
+      sg.track = track;
+      standsAtTerminals.push([sg, i, un]);
+    });
+  }
+  standsAtTerminals.sort((a, b) => a[0].t0 - b[0].t0);
+  for (const [sg] of standsAtTerminals) {
+    const key = `${sg.code}:${sg.track}`;
+    const used = (slotUse[key] ||= []);
+    let slot = 0;
+    while (used.some(([k, a, b]) => k === slot && a < sg.t1 && sg.t0 < b)) slot++;
+    used.push([slot, sg.t0, sg.t1]);
+    sg.slot = slot;
+    sg.km = kmOf[sg.code] + (sg.code === west ? 1 : -1) * slot * SLOT_KM;
+  }
+  // moves inherit the terminal tracks of the stands around them
+  for (const un of units) {
+    un.segs.forEach((sg, i) => {
+      if (sg.type !== "move") return;
+      const r = sg.run, before = un.segs[i - 1], after = un.segs[i + 1];
+      sg.lw = r.dir === "E" ? lwTrack(r, false) : lwTrack(r, true);
+      sg.gn = gnTrack(r);
+      sg.startKm = null; sg.endKm = null;
+      if (before && before.type === "stand" && before.track) {
+        if (before.code === west) sg.lw = before.track; else sg.gn = before.track;
+        sg.startKm = before.km;
+      }
+      if (after && after.type === "stand" && after.track) {
+        if (after.code === west) sg.lw = after.track; else sg.gn = after.track;
+        sg.endKm = after.km;
+      }
+    });
+    for (const sg of un.segs) {
+      if (sg.type === "stand" && sg.km === undefined) sg.km = kmOf[sg.code];
+    }
+  }
+
+  // two-track stations: each direction's platform, or the other one when it is taken
+  const occ = {};      // code -> [{t0, t1, prefer, apply(lane)}]
+  const twoTrack = (c) => point[c] && point[c].tracks === 2 && !point[c].directional;
+  for (const un of units) {
+    un.segs.forEach((sg, i) => {
+      if (sg.type === "stand" && twoTrack(sg.code)) {
+        const prefer = sg.prev ? sg.prev.dir : sg.next ? sg.next.dir : "E";
+        const before = un.segs[i - 1], after = un.segs[i + 1];
+        (occ[sg.code] ||= []).push({
+          t0: sg.t0, t1: Math.min(sg.t1, sg.t0 + 24 * 60), prefer,
+          apply: (lane) => {
+            sg.lane = lane;
+            if (before && before.type === "move") before.lanes[sg.code] = lane;
+            if (after && after.type === "move") after.lanes[sg.code] = lane;
+          },
+        });
+      } else if (sg.type === "move") {
+        const r = sg.run;
+        const moving = r.started && r.fixed_from !== null && r.fixed_from !== undefined;
+        const from = moving ? sg.k - 1 : r.started ? sg.k : sg.s;     // the first point it leaves in the window
+        for (let j = from + 1; j < sg.e; j++) {
+          const c = r.route[j];
+          if (!twoTrack(c) || r.arr[j] === null) continue;
+          (occ[c] ||= []).push({ t0: r.arr[j], t1: r.dep[j] ?? r.arr[j], prefer: r.dir,
+            apply: (lane) => { sg.lanes[c] = lane; } });
+        }
+      }
+    });
+  }
+  for (const list of Object.values(occ)) {
+    list.sort((a, b) => a.t0 - b.t0);
+    const taken = { E: [], W: [] };
+    for (const o of list) {
+      const free = (lane) => !taken[lane].some(([a, b]) => a - PAD < o.t1 && o.t0 < b + PAD);
+      const lane = free(o.prefer) ? o.prefer : free(o.prefer === "E" ? "W" : "E") ? (o.prefer === "E" ? "W" : "E")
+        : o.prefer;
+      taken[lane].push([o.t0, o.t1]);
+      o.apply(lane);
+    }
+  }
+
+  // knots for every move
+  for (const un of units) {
+    for (const sg of un.segs) {
+      if (sg.type !== "move") continue;
+      const r = sg.run, kn = [];
+      const push = (t, x, stop) => {
+        if (t === null || t === undefined) return;
+        const last = kn[kn.length - 1];
+        if (last && t <= last.t + 1e-9) {
+          if (Math.abs(x - last.x) < 1e-9) { last.stop = last.stop || stop; return; }
+          t = last.t + 0.05;                                   // never two places at one instant
+        }
+        kn.push({ t, x, stop });
+      };
+      const kmAt = (j) => {
+        if (j === sg.e && sg.endKm !== null) return sg.endKm;
+        if (j === (r.started ? sg.k : sg.s) && !r.started && sg.startKm !== null) return sg.startKm;
+        return kmOf[r.route[j]];
+      };
+      if (r.started && r.fixed_from !== null && r.fixed_from !== undefined) {
+        push(r.fixed_from, kmOf[r.route[sg.k - 1]], !!r.stops[sg.k - 1]);
+      }
+      const first = r.started ? sg.k : sg.s;
+      for (let j = first; j <= sg.e; j++) {
+        const x = kmAt(j);
+        if (j === first && !(r.started && r.fixed_from !== null && r.fixed_from !== undefined)) {
+          if (r.started) push(r.arr[j], x, true);
+          push(r.dep[j], x, true);
+        } else if (j === sg.e) {
+          push(r.arr[j], x, true);
+        } else if (r.stopped[j]) {
+          push(r.arr[j], x, true);
+          push(r.dep[j], x, true);
+        } else {
+          push(r.arr[j], x, false);
+        }
+      }
+      sg.H = hermite(kn);
+      sg.knots = kn;
+      sg.t0 = kn[0].t;
+      sg.t1 = kn[kn.length - 1].t;
+    }
+    // keep stands contiguous with the moves around them
+    un.segs.forEach((sg, i) => {
+      if (sg.type !== "stand") return;
+      const before = un.segs[i - 1], after = un.segs[i + 1];
+      if (before && before.type === "move") sg.t0 = before.t1;
+      if (after && after.type === "move") sg.t1 = after.t0;
+    });
+  }
+
+  const tEnd = Math.max(R.end, ...units.flatMap((u) => u.segs.filter((s) => s.type === "move").map((s) => s.t1)));
+  return new Sim(R, units, kmOf, point, tEnd);
+}
+
+export class Sim {
+  constructor(R, units, kmOf, point, tEnd) {
+    this.R = R;
+    this.units = units;
+    this.kmOf = kmOf;
+    this.point = point;
+    this.t0 = R.start;
+    this.t1 = tEnd;
+    this.codes = R.points.map((p) => p.code);
+  }
+
+  segAt(un, t) {
+    const segs = un.segs;
+    if (!segs.length) return null;
+    let i = 0;
+    while (i < segs.length - 1 && t >= segs[i].t1) i++;
+    return segs[i];
+  }
+
+  // where a train set is and what it is doing at minute t
+  stateAt(un, t) {
+    const sg = this.segAt(un, t);
+    if (!sg) return null;
+    if (sg.type === "stand") {
+      const facing = sg.prev ? sg.prev.dir : sg.next ? sg.next.dir : "E";
+      const ref = sg.prev || sg.next;
+      return {
+        unit: un.id, km: sg.km, dir: facing, moving: false, speed: 0, code: sg.code,
+        lw: sg.code === this.codes[0] && sg.track ? sg.track : ref ? lwTrack(ref, facing === "W") : "8",
+        gn: sg.code === this.codes[this.codes.length - 1] && sg.track ? sg.track : ref ? gnTrack(ref) : "5a",
+        lanes: sg.lane ? { [sg.code]: sg.lane } : null, train: sg.next ? sg.next.train : sg.prev ? sg.prev.train : "",
+        kind: ref ? ref.kind : "stop", status: this.standStatus(sg, t), delay: this.standDelay(sg),
+        run: sg.next || sg.prev,
+      };
+    }
+    const [km, v] = evalHermite(sg.H, t);
+    return {
+      unit: un.id, km, dir: sg.dir, moving: Math.abs(v) > 1e-4, speed: Math.abs(v) * 60, code: this.atPoint(sg, t),
+      lw: sg.lw, gn: sg.gn, lanes: Object.keys(sg.lanes).length ? sg.lanes : null, train: sg.run.train,
+      kind: sg.run.kind, status: this.moveStatus(sg, t, km), delay: this.moveDelay(sg, t), run: sg.run,
+    };
+  }
+
+  atPoint(sg, t) {
+    const kn = sg.knots;
+    for (let i = 0; i < kn.length - 1; i++) {
+      if (kn[i].stop && kn[i + 1].stop && Math.abs(kn[i].x - kn[i + 1].x) < 1e-9 && kn[i].t <= t && t <= kn[i + 1].t) {
+        return this.codeAtKm(kn[i].x);
+      }
+    }
+    return null;
+  }
+
+  codeAtKm(km) {
+    let best = null, d = Infinity;
+    for (const [c, k] of Object.entries(this.kmOf)) {
+      if (Math.abs(k - km) < d) { d = Math.abs(k - km); best = c; }
+    }
+    return d < 0.3 ? best : null;
+  }
+
+  moveDelay(sg, t) {
+    const r = sg.run;
+    let late = 0;
+    for (let j = 0; j < r.route.length; j++) {
+      const a = r.arr[j] ?? r.dep[j];
+      const sch = r.sched_arr[j] ?? r.sched_dep[j];
+      if (a === null || a === undefined || sch === null || sch === undefined) continue;
+      if (a <= t) late = a - sch;
+    }
+    return Math.max(0, late);
+  }
+
+  standDelay(sg) {
+    const r = sg.next;
+    if (!r) return 0;
+    const j = r.started ? r.fixed_to : r.first;
+    return Math.max(0, (r.dep[j] ?? 0) - (r.sched_dep[j] ?? r.dep[j] ?? 0));
+  }
+
+  moveStatus(sg, t, km) {
+    const r = sg.run;
+    const code = this.atPoint(sg, t);
+    if (code) {
+      const j = r.route.indexOf(code);
+      const hold = r.order && r.order.hold && r.order.hold[code];
+      const dep = r.dep[j];
+      if (hold && dep !== null && dep > (r.sched_dep[j] ?? dep)) return `held at ${code} until ${hold} (plan)`;
+      if (r.stops[j]) return `at ${code}, leaves ${hhmm(dep)}`;
+      return `waiting at ${code}, leaves ${hhmm(dep)}`;
+    }
+    let j = 0;
+    while (j < r.route.length - 1 && (r.arr[j + 1] === null || r.arr[j + 1] <= t)) j++;
+    const nextStop = r.route.slice(j + 1, sg.e + 1).find((c, i) => r.stops[j + 1 + i]) || r.route[sg.e];
+    const to = r.route[sg.e];
+    return `to ${to}${to !== r.route[r.route.length - 1] ? " (turned short)" : ""}, next ${nextStop}`;
+  }
+
+  standStatus(sg, t) {
+    if (!sg.next) return `at ${sg.code}: done for this window`;
+    const r = sg.next;
+    const j = r.started ? r.fixed_to : r.first;
+    const hold = r.order && r.order.hold && r.order.hold[sg.code];
+    if (hold && r.dep[j] > (r.sched_dep[j] ?? r.dep[j])) return `held at ${sg.code} until ${hold} (plan), then ${r.train}`;
+    if (sg.prev && sg.prev.last < sg.prev.route.length - 1 && sg.prev.route[sg.prev.last] === sg.code) {
+      return `turned back at ${sg.code}; runs ${r.train} at ${hhmm(r.dep[j])}`;
+    }
+    return `at ${sg.code}; runs ${r.train} at ${hhmm(r.dep[j])}`;
+  }
+
+  // every train set's state at t (those with a window)
+  statesAt(t) {
+    return this.units.map((u) => this.stateAt(u, t)).filter(Boolean);
+  }
+
+  // cancelled runs (shown in the list, never on the map)
+  cancelled() {
+    return this.R.runs.filter((r) => r.cancelled);
+  }
+
+  // which sections hold a train between their end points at t: index -> [unit ids]
+  occupancy(states) {
+    const occ = {};
+    const pts = this.R.points;
+    for (const s of states) {
+      for (let i = 0; i < pts.length - 1; i++) {
+        if (s.km > pts[i].km + 0.03 && s.km < pts[i + 1].km - 0.03) {
+          (occ[i] ||= []).push(s.unit);
+          break;
+        }
+      }
+    }
+    return occ;
+  }
+
+  // the cost accrued by minute t (the replay's cost events, which add up to the grader's cost)
+  costAt(t) {
+    let sum = 0;
+    for (const c of this.R.costs) {
+      if (c[0] > t) break;
+      sum += c[1];
+    }
+    return sum;
+  }
+}

openenv/rail_openenv/web/twin/scene.js

@@ -0,0 +1,765 @@
+// The live part of the line twin: sky and sun for the task's date and time, the trains, the signals that guard each
+// single-track section, the level crossings, the disruptions, labels, and the cameras. The scenery is world.js.
+//
+// It only draws: positions come from motion.js (the simulated times), places from geo.js (the OSM track).
+
+import * as THREE from "three";
+import { MapControls } from "three/addons/controls/MapControls.js";
+import { Line2 } from "three/addons/lines/Line2.js";
+import { LineGeometry } from "three/addons/lines/LineGeometry.js";
+import { LineMaterial } from "three/addons/lines/LineMaterial.js";
+import { CSS2DObject, CSS2DRenderer } from "three/addons/renderers/CSS2DRenderer.js";
+
+import { CANONICAL } from "./geo.js";
+import { animateWorld, buildWorld } from "./world.js";
+
+// series colours, validated for the dark interface (dataviz reference palette, dark slots 1 and 2)
+export const KIND_COLOR = { stop: "#3987e5", fast: "#d95926" };
+export const STATUS = { critical: "#d03b3b", warning: "#fab219", serious: "#ec835a", good: "#0ca30c" };
+const CAR = 26.5, GAP = 1.0, BOGIE = 9.5;
+const LAT = 53.22, LON = 6.19;
+
+// --- sun ---------------------------------------------------------------------------------------------------------
+
+function amsterdamOffset(day) {
+  // CET (UTC+1), CEST (UTC+2) from the last Sunday of March to the last Sunday of October
+  const [y, m, d] = day.split("-").map(Number);
+  const lastSunday = (month) => { const t = new Date(Date.UTC(y, month, 0)); return t.getUTCDate() - t.getUTCDay(); };
+  const date = Date.UTC(y, m - 1, d);
+  const start = Date.UTC(y, 2, lastSunday(3)), end = Date.UTC(y, 9, lastSunday(10));
+  return date >= start && date < end ? 2 : 1;
+}
+
+export function sunPosition(day, minute) {
+  // NOAA's simplified solar position: elevation and azimuth (from north, clockwise), degrees
+  const [y, m, d] = day.split("-").map(Number);
+  const n = Math.round((Date.UTC(y, m - 1, d) - Date.UTC(y, 0, 0)) / 864e5);
+  const utcMin = minute - amsterdamOffset(day) * 60;
+  const g = (2 * Math.PI / 365) * (n - 1 + (utcMin / 60 - 12) / 24);
+  const eq = 229.18 * (0.000075 + 0.001868 * Math.cos(g) - 0.032077 * Math.sin(g) - 0.014615 * Math.cos(2 * g)
+    - 0.040849 * Math.sin(2 * g));
+  const decl = 0.006918 - 0.399912 * Math.cos(g) + 0.070257 * Math.sin(g) - 0.006758 * Math.cos(2 * g)
+    + 0.000907 * Math.sin(2 * g) - 0.002697 * Math.cos(3 * g) + 0.00148 * Math.sin(3 * g);
+  const tst = utcMin + eq + 4 * LON;
+  const ha = (tst / 4 - 180) * Math.PI / 180;
+  const lat = LAT * Math.PI / 180;
+  const cosZ = Math.sin(lat) * Math.sin(decl) + Math.cos(lat) * Math.cos(decl) * Math.cos(ha);
+  const zen = Math.acos(Math.max(-1, Math.min(1, cosZ)));
+  let az = Math.atan2(Math.sin(ha), Math.cos(ha) * Math.sin(lat) - Math.tan(decl) * Math.cos(lat)) + Math.PI;
+  az = (az + 2 * Math.PI) % (2 * Math.PI);
+  return { elevation: 90 - zen * 180 / Math.PI, azimuth: az * 180 / Math.PI };
+}
+
+// --- trains --------------------------------------------------------------------------------------------------
+
+function carGeometries() {
+  const s = new THREE.Shape();
+  s.moveTo(-1.42, 1.15); s.lineTo(1.42, 1.15); s.lineTo(1.42, 3.25);
+  s.quadraticCurveTo(1.4, 3.92, 0.85, 3.98); s.lineTo(-0.85, 3.98); s.quadraticCurveTo(-1.4, 3.92, -1.42, 3.25);
+  s.closePath();
+  const body = new THREE.ExtrudeGeometry(s, { depth: CAR - 2.2, bevelEnabled: false });
+  body.rotateY(Math.PI / 2);
+  body.translate(-(CAR - 2.2) / 2 - 1.1, 0, 0);         // spans -CAR/2 .. CAR/2 - 2.2 (the nose adds 2.2)
+  const side = new THREE.Shape();
+  side.moveTo(0, 1.15); side.lineTo(0, 3.98); side.lineTo(0.7, 3.92); side.lineTo(1.75, 2.35); side.lineTo(2.2, 1.6);
+  side.lineTo(2.2, 1.15); side.closePath();
+  const nose = new THREE.ExtrudeGeometry(side, { depth: 2.84, bevelEnabled: false });
+  nose.translate(CAR / 2 - 2.2, 0, -1.42);
+  const screen = new THREE.PlaneGeometry(1.95, 2.4);
+  screen.rotateY(Math.PI / 2);
+  screen.rotateZ(-0.98);
+  screen.translate(CAR / 2 - 2.2 + 1.24, 3.12, 0);
+  const band = new THREE.BoxGeometry(CAR - 4.4, 0.8, 2.88);
+  band.translate(-1.1, 2.6, 0);
+  const stripe = new THREE.BoxGeometry(CAR - 2.6, 0.26, 2.87);
+  stripe.translate(-1.0, 1.62, 0);
+  const bogie = new THREE.BoxGeometry(2.7, 0.75, 2.2);
+  const lamp = new THREE.CircleGeometry(0.16, 10);
+  lamp.rotateY(Math.PI / 2);
+  return { body, nose, screen, band, stripe, bogie, lamp };
+}
+
+class TrainMesh {
+  constructor(shared, kind) {
+    const { geo, mats } = shared;
+    this.group = new THREE.Group();
+    this.cars = [];
+    for (let c = 0; c < 2; c++) {
+      const car = new THREE.Group();
+      const inner = new THREE.Group();            // car 1 is car 0 turned round: both ends are cabs
+      if (c === 1) inner.rotation.y = Math.PI;
+      for (const [g, m] of [[geo.body, mats.body], [geo.nose, mats.body], [geo.screen, mats.glass],
+        [geo.band, mats.glass], [geo.stripe, mats.stripe[kind]]]) {
+        const mesh = new THREE.Mesh(g, m);
+        mesh.castShadow = true;
+        inner.add(mesh);
+      }
+      for (const x of [-BOGIE, BOGIE]) {
+        const b = new THREE.Mesh(geo.bogie, mats.bogie);
+        b.position.set(x, 0.62, 0);
+        inner.add(b);
+      }
+      const lamps = [];
+      for (const z of [-0.95, 0.95]) {
+        const l = new THREE.Mesh(geo.lamp, mats.head);
+        l.position.set(CAR / 2 + 0.01, 1.55, z);
+        inner.add(l);
+        lamps.push(l);
+      }
+      car.add(inner);
+      car.userData.lamps = lamps;
+      this.group.add(car);
+      this.cars.push(car);
+    }
+    this.halo = new THREE.Mesh(new THREE.RingGeometry(31, 32.5, 64), mats.halo);
+    this.halo.rotation.x = -Math.PI / 2;
+    this.halo.position.y = 0.4;
+    this.halo.visible = false;
+    this.group.add(this.halo);
+    this.glow = new THREE.Sprite(mats.glow);
+    this.glow.scale.set(24, 24, 1);
+    this.group.add(this.glow);
+    const el = document.createElement("div");
+    el.className = "tlabel";
+    this.label = new CSS2DObject(el);
+    this.label.position.set(0, 9, 0);
+    this.group.add(this.label);
+    this.kind = kind;
+  }
+
+  setKind(shared, kind) {
+    if (kind === this.kind) return;
+    this.kind = kind;
+    for (const car of this.cars) car.children[0].children[4].material = shared.mats.stripe[kind];
+  }
+}
+
+// --- the scene -----------------------------------------------------------------------------------------------
+
+export class TwinScene {
+  constructor(el, twin, line) {
+    this.el = el;
+    this.twin = twin;
+    this.line = line;
+    this.renderer = new THREE.WebGLRenderer({ antialias: true, logarithmicDepthBuffer: true,
+      preserveDrawingBuffer: true });
+    this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+    this.renderer.shadowMap.enabled = true;
+    this.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+    this.renderer.toneMapping = THREE.NeutralToneMapping;
+    this.renderer.toneMappingExposure = 1.0;
+    el.appendChild(this.renderer.domElement);
+    this.labels = new CSS2DRenderer();
+    this.labels.domElement.className = "labels";
+    el.appendChild(this.labels.domElement);
+
+    this.scene = new THREE.Scene();
+    this.camera = new THREE.PerspectiveCamera(45, 1, 0.5, 300000);
+    this.controls = new MapControls(this.camera, this.labels.domElement);
+    this.controls.enableDamping = true;
+    this.controls.dampingFactor = 0.12;
+    this.controls.maxPolarAngle = Math.PI * 0.47;
+    this.controls.minDistance = 12;
+    this.controls.maxDistance = 140000;
+    this.controls.zoomToCursor = true;
+
+    this.hemi = new THREE.HemisphereLight(0xeef3ff, 0x7c7a62, 2.0);
+    this.ambient = new THREE.AmbientLight(0xffffff, 0.25);
+    this.sun = new THREE.DirectionalLight(0xffffff, 3.0);
+    this.sun.castShadow = true;
+    this.sun.shadow.mapSize.set(2048, 2048);
+    const sc = this.sun.shadow.camera;
+    sc.left = sc.bottom = -350; sc.right = sc.top = 350; sc.near = 10; sc.far = 3000;
+    this.sun.shadow.bias = -0.0004;
+    this.scene.add(this.hemi, this.ambient, this.sun, this.sun.target);
+    this.scene.fog = new THREE.Fog(0xbcd3e6, 4000, 60000);
+    this.scene.background = new THREE.Color(0xbcd3e6);
+
+    this.world = buildWorld(twin, this.scene);
+    this.shared = this.sharedAssets();
+    this.trains = new Map();
+    this.signals = [];
+    this.crossings = this.buildCrossings();
+    this.closures = [];
+    this.stationLabels = this.buildStationLabels();
+    this.placeLabels = this.buildPlaceLabels();
+    this.followId = null;
+    this.mode = "map";
+    this.lastFollow = null;
+    this.selected = null;
+    this.night = 0;
+    this.resize();
+    window.addEventListener("resize", () => this.resize());
+    this.viewAll();
+  }
+
+  sharedAssets() {
+    const geo = carGeometries();
+    const glowTex = (() => {
+      const cv = document.createElement("canvas");
+      cv.width = cv.height = 64;
+      const g = cv.getContext("2d");
+      const grd = g.createRadialGradient(32, 32, 0, 32, 32, 32);
+      grd.addColorStop(0, "rgba(255,244,214,1)"); grd.addColorStop(0.25, "rgba(255,230,170,0.5)");
+      grd.addColorStop(1, "rgba(255,220,150,0)");
+      g.fillStyle = grd; g.fillRect(0, 0, 64, 64);
+      return new THREE.CanvasTexture(cv);
+    })();
+    const mats = {
+      body: new THREE.MeshStandardMaterial({ color: 0xeef0f2, roughness: 0.45, metalness: 0.15 }),
+      glass: new THREE.MeshStandardMaterial({ color: 0x18222c, roughness: 0.15, metalness: 0.6 }),
+      bogie: new THREE.MeshLambertMaterial({ color: 0x2a2a2a }),
+      stripe: { stop: new THREE.MeshStandardMaterial({ color: KIND_COLOR.stop, roughness: 0.5 }),
+        fast: new THREE.MeshStandardMaterial({ color: KIND_COLOR.fast, roughness: 0.5 }) },
+      head: new THREE.MeshBasicMaterial({ color: 0xfff6dc }),
+      tail: new THREE.MeshBasicMaterial({ color: 0xff2a1a }),
+      halo: new THREE.MeshBasicMaterial({ color: 0xffffff, transparent: true, opacity: 0.85, depthWrite: false }),
+      glow: new THREE.SpriteMaterial({ map: glowTex, color: 0xffffff, transparent: true, opacity: 0,
+        depthWrite: false, blending: THREE.AdditiveBlending }),
+    };
+    return { geo, mats };
+  }
+
+  resize() {
+    const w = this.el.clientWidth || window.innerWidth, h = this.el.clientHeight || window.innerHeight;
+    this.renderer.setSize(w, h);
+    this.labels.setSize(w, h);
+    for (const m of [...(this.lineMats || []), ...(this.closureMats || [])]) m.resolution.set(w, h);
+    this.camera.aspect = w / h;
+    this.camera.updateProjectionMatrix();
+  }
+
+  // --- static labels -----------------------------------------------------------------------------------------
+
+  buildStationLabels() {
+    const out = [];
+    for (const st of this.twin.stations) {
+      const el = document.createElement("div");
+      el.className = "slabel";
+      el.textContent = st.name;
+      const o = new CSS2DObject(el);
+      o.position.set(st.x, 14, -st.y);
+      this.scene.add(o);
+      out.push({ code: st.code, obj: o, x: st.x, y: st.y });
+    }
+    return out;
+  }
+
+  buildPlaceLabels() {
+    const out = [];
+    const stations = new Set(this.twin.stations.map((s) => s.name.toLowerCase()));
+    for (const p of this.twin.places) {
+      if (p.r > 3) continue;
+      const el = document.createElement("div");
+      el.className = `plabel r${p.r}`;
+      el.textContent = p.n;
+      const o = new CSS2DObject(el);
+      o.position.set(p.x, 30, -p.y);
+      this.scene.add(o);
+      out.push({ obj: o, r: p.r, x: p.x, y: p.y, dup: stations.has(p.n.toLowerCase()) });
+    }
+    return out;
+  }
+
+  // --- crossings, signals, closures ------------------------------------------------------------------------
+
+  buildCrossings() {
+    const out = [];
+    const cv = document.createElement("canvas");
+    cv.width = 64; cv.height = 8;
+    const g = cv.getContext("2d");
+    for (let i = 0; i < 8; i++) { g.fillStyle = i % 2 ? "#ffffff" : "#d42a2a"; g.fillRect(i * 8, 0, 8, 8); }
+    const stripes = new THREE.CanvasTexture(cv);
+    const armMat = new THREE.MeshLambertMaterial({ map: stripes });
+    const postMat = new THREE.MeshLambertMaterial({ color: 0xdddddd });
+    const plateMat = new THREE.MeshLambertMaterial({ color: 0x3e3f42, depthTest: false, depthWrite: false });
+    const offMat = new THREE.MeshBasicMaterial({ color: 0x3a1010 });
+    this.lampOn = new THREE.MeshBasicMaterial({ color: 0xff3020 });
+    const armGeo = new THREE.BoxGeometry(5.6, 0.14, 0.14);
+    armGeo.translate(2.8, 0, 0);
+    const postGeo = new THREE.CylinderGeometry(0.08, 0.1, 1.3, 6);
+    const lampGeo = new THREE.CircleGeometry(0.13, 10);
+    for (const c of this.twin.crossings) {
+      const grp = new THREE.Group();
+      grp.position.set(c.x, 0, -c.y);
+      const half = c.n * 2.4 + 2.2;
+      const plate = new THREE.Mesh(new THREE.BoxGeometry(half * 2, 0.05, 5.5), plateMat);
+      plate.rotation.y = c.r;
+      plate.position.y = 0.2;
+      plate.renderOrder = -4;                          // painted with the flat layers (see world.js)
+      grp.add(plate);
+      const arms = [], lamps = [];
+      for (const side of [1, -1]) {
+        const ux = Math.cos(c.r) * side, uy = Math.sin(c.r) * side;     // along the road, away from the track
+        const vx = -uy, vy = ux;                                         // across the road
+        const bx = ux * (half + 1.2) + vx * 3.1, by = uy * (half + 1.2) + vy * 3.1;
+        const post = new THREE.Mesh(postGeo, postMat);
+        post.position.set(bx, 0.65, -by);
+        const pivot = new THREE.Group();
+        pivot.position.set(bx, 1.05, -by);
+        pivot.rotation.y = Math.atan2(-vy, -vx);                         // arm points back across the road
+        const tilt = new THREE.Group();
+        tilt.rotation.z = Math.PI / 2;                                   // open: arm up
+        const arm = new THREE.Mesh(armGeo, armMat);
+        tilt.add(arm);
+        pivot.add(tilt);
+        for (const dz of [-0.2, 0.2]) {
+          const l = new THREE.Mesh(lampGeo, offMat);
+          l.position.set(bx + ux * 0.01, 1.25, -by + dz);
+          l.rotation.y = Math.atan2(-uy, ux) + Math.PI / 2;
+          grp.add(l);
+          lamps.push(l);
+        }
+        grp.add(post, pivot);
+        arms.push(tilt);
+      }
+      this.scene.add(grp);
+      out.push({ ...c, arms, lamps, offMat, angle: Math.PI / 2 });
+    }
+    return out;
+  }
+
+  clearReplayObjects() {
+    for (const s of this.signals) this.scene.remove(s.group);
+    for (const c of this.closures) { this.scene.remove(c.mesh); this.scene.remove(c.label); if (c.line) this.scene.remove(c.line); }
+    this.closureMats = [];
+    for (const v of this.breaks || []) { this.scene.remove(v.mesh); this.scene.remove(v.label); }
+    this.signals = [];
+    this.closures = [];
+    this.breaks = [];
+  }
+
+  buildBreaks(R) {
+    // where and when the plan breaks a rule: a red ring on the spot for a few minutes around the moment
+    const km = Object.fromEntries(R.points.map((p) => [p.code, p.km]));
+    const ringGeo = new THREE.RingGeometry(40, 48, 48);
+    ringGeo.rotateX(-Math.PI / 2);
+    const mat = new THREE.MeshBasicMaterial({ color: STATUS.critical, transparent: true, opacity: 0.9, depthTest: false,
+      depthWrite: false });
+    for (const v of R.violations) {
+      if (!v.time || !v.where) continue;
+      const [h, m] = v.time.split(":").map(Number);
+      let t = h * 60 + m;
+      if (t < R.start - 120) t += 1440;
+      const ends = v.where.split("-").filter((c) => km[c] !== undefined);
+      if (!ends.length) continue;
+      const k = ends.reduce((a, c) => a + km[c], 0) / ends.length;
+      const p = this.pose("E", k);
+      const mesh = new THREE.Mesh(ringGeo, mat);
+      mesh.position.set(p.x, 1.5, -p.y);
+      mesh.renderOrder = 6;
+      const el = document.createElement("div");
+      el.className = "vlabel";
+      el.innerHTML = `<b>${v.rule.replace("_", " ")}</b> ${v.trains.join(" · ")} at ${v.where}`;
+      const label = new CSS2DObject(el);
+      label.position.set(p.x, 30, -p.y);
+      this.scene.add(mesh, label);
+      this.breaks.push({ t, mesh, label });
+    }
+  }
+
+  pose(dir, km, lw = "8", gn = "5a", lanes = null) {
+    const p = this.line.place(dir, lw, gn, km, lanes);
+    const q = this.line.place(dir, lw, gn, km + (dir === "E" ? 0.01 : -0.01), lanes);
+    return { x: p[0], y: p[1], h: Math.atan2(q[1] - p[1], q[0] - p[0]) };
+  }
+
+  buildSignals(R) {
+    // one signal at each entry of every single-track section, on the right of the track; red while a train is
+    // inside or the section is closed
+    const km = Object.fromEntries(R.points.map((p) => [p.code, p.km]));
+    const kind = Object.fromEntries(R.points.map((p) => [p.code, p.kind]));
+    const mastGeo = new THREE.CylinderGeometry(0.09, 0.11, 4.2, 6);
+    const headGeo = new THREE.BoxGeometry(0.35, 0.95, 0.5);
+    const lampGeo = new THREE.CircleGeometry(0.12, 12);
+    const grey = new THREE.MeshLambertMaterial({ color: 0x2b2b2b });
+    this.sigRed = new THREE.MeshBasicMaterial({ color: 0xff2a1a });
+    this.sigGreen = new THREE.MeshBasicMaterial({ color: 0x28e070 });
+    this.sigOff = new THREE.MeshBasicMaterial({ color: 0x1a1a1a });
+    R.sections.forEach((sec, i) => {
+      if (!sec.single) return;
+      for (const dir of ["E", "W"]) {
+        const at = dir === "E" ? sec.a : sec.b;
+        const sign = dir === "E" ? 1 : -1;
+        const k = kind[at] === "junction" ? km[at] - sign * 0.18 : km[at] + sign * 0.12;
+        const p = this.pose(dir, k);
+        const rx = Math.sin(p.h), ry = -Math.cos(p.h);                  // right of the direction of travel
+        const group = new THREE.Group();
+        group.position.set(p.x + rx * 2.6, 0, -(p.y + ry * 2.6));
+        group.rotation.y = p.h + Math.PI;                               // the lamps face oncoming trains
+        const mast = new THREE.Mesh(mastGeo, grey);
+        mast.position.y = 2.1;
+        const head = new THREE.Mesh(headGeo, grey);
+        head.position.y = 4.3;
+        const red = new THREE.Mesh(lampGeo, this.sigOff), green = new THREE.Mesh(lampGeo, this.sigOff);
+        red.rotation.y = green.rotation.y = Math.PI / 2;
+        red.position.set(0.18, 4.52, 0); green.position.set(0.18, 4.12, 0);
+        group.add(mast, head, red, green);
+        this.scene.add(group);
+        this.signals.push({ section: i, dir, group, red, green });
+      }
+    });
+  }
+
+  buildClosures(R) {
+    const km = Object.fromEntries(R.points.map((p) => [p.code, p.km]));
+    const single = R.sections.map((s) => s.single);
+    const idx = Object.fromEntries(R.points.map((p, i) => [p.code, i]));
+    for (const c of R.closures) {
+      let k0, k1;
+      if (c.kind === "track") { k0 = km[c.where[0]] - 0.2; k1 = km[c.where[0]] + 0.2; }
+      else { k0 = Math.min(km[c.where[0]], km[c.where[c.where.length - 1]]); k1 = Math.max(km[c.where[0]], km[c.where[c.where.length - 1]]); }
+      const pos = [], index = [];
+      const lanes = ["E"];
+      const i0 = Math.min(idx[c.where[0]], idx[c.where[c.where.length - 1]]);
+      const i1 = Math.max(idx[c.where[0]], idx[c.where[c.where.length - 1]]);
+      if (c.kind === "track" || single.slice(i0, Math.max(i1, i0 + 1)).some((s) => !s)) lanes.push("W");
+      for (const lane of lanes) {
+        const base = pos.length / 3;
+        let n = 0;
+        for (let k = k0; k <= k1 + 1e-9; k += Math.max(0.005, (k1 - k0) / 400)) {
+          const p = this.pose(lane, k, "8", "5a");
+          const nx = -Math.sin(p.h) * 2.6, ny = Math.cos(p.h) * 2.6;
+          pos.push(p.x + nx, 0.45, -(p.y + ny), p.x - nx, 0.45, -(p.y - ny));
+          n++;
+        }
+        for (let j = 0; j < n - 1; j++) {
+          const v = base + 2 * j;
+          index.push(v, v + 2, v + 1, v + 1, v + 2, v + 3);
+        }
+      }
+      const g = new THREE.BufferGeometry();
+      g.setAttribute("position", new THREE.Float32BufferAttribute(pos, 3));
+      g.setIndex(index);
+      const color = c.kind === "closed" ? STATUS.critical : c.kind === "slow" ? STATUS.warning : STATUS.serious;
+      const mat = new THREE.MeshBasicMaterial({ color, transparent: true, opacity: 0.7, depthWrite: false,
+        side: THREE.DoubleSide });
+      const mesh = new THREE.Mesh(g, mat);
+      mesh.renderOrder = 5;
+      // from high up: a thick line over the overview line while it lasts
+      const lpts = [];
+      for (let k = k0; k <= k1 + 1e-9; k += Math.max(0.02, (k1 - k0) / 100)) {
+        const q = this.pose("E", Math.min(k, k1));
+        lpts.push(q.x, 1.2, -q.y);
+      }
+      const lmat = new LineMaterial({ color, linewidth: 7, depthTest: false, depthWrite: false, transparent: true });
+      lmat.resolution.set(this.el.clientWidth || 1, this.el.clientHeight || 1);
+      (this.closureMats ||= []).push(lmat);
+      const lg = new LineGeometry();
+      lg.setPositions(lpts);
+      const line = new Line2(lg, lmat);
+      line.renderOrder = -1;
+      const el = document.createElement("div");
+      el.className = `clabel ${c.kind}`;
+      const what = c.kind === "closed" ? "Closed" : c.kind === "slow" ? `Slow +${c.extra} min` : "1 track out of use";
+      el.innerHTML = `<b>${what}</b> ${c.cause || ""}`;
+      const label = new CSS2DObject(el);
+      const mid = this.pose("E", (k0 + k1) / 2);
+      label.position.set(mid.x, 22, -mid.y);
+      this.scene.add(mesh, label, line);
+      this.closures.push({ ...c, mesh, label, mat, line });
+    }
+  }
+
+  buildOverviewLine(R) {
+    // the line as seen from high up, where 3 m of track is under a pixel: white where it is single track (one train
+    // at a time between stations), grey where it is double; a dark casing under both
+    const km = Object.fromEntries(R.points.map((p) => [p.code, p.km]));
+    this.lineMats = [];
+    this.overview = new THREE.Group();
+    const mk = (color, width, order) => {
+      const m = new LineMaterial({ color, linewidth: width, depthTest: false, depthWrite: false, transparent: true });
+      m.resolution.set(this.el.clientWidth || 1, this.el.clientHeight || 1);
+      this.lineMats.push(m);
+      m.userData.order = order;
+      return m;
+    };
+    const casing = mk(0x1a1a19, 7, -3), single = mk(0xffffff, 3, -2), double = mk(0x9a9a96, 3, -2);
+    for (const sec of R.sections) {
+      const pts = [];
+      for (let k = km[sec.a]; k <= km[sec.b] + 1e-9; k += Math.max(0.02, (km[sec.b] - km[sec.a]) / 120)) {
+        const p = this.line.place("E", "8", "5a", Math.min(k, km[sec.b]));
+        pts.push(p[0], 1, -p[1]);
+      }
+      for (const mat of [casing, sec.single ? single : double]) {
+        const g = new LineGeometry();
+        g.setPositions(pts);
+        const l = new Line2(g, mat);
+        l.computeLineDistances();
+        l.renderOrder = mat.userData.order;
+        this.overview.add(l);
+      }
+    }
+    this.scene.add(this.overview);
+  }
+
+  setReplay(R, sim) {
+    this.R = R;
+    this.sim = sim;
+    if (!this.overview) this.buildOverviewLine(R);
+    this.clearReplayObjects();
+    this.buildSignals(R);
+    this.buildClosures(R);
+    this.buildBreaks(R);
+    const keep = new Set(sim.units.map((u) => u.id));
+    for (const [id, tm] of this.trains) {
+      if (!keep.has(id)) { this.scene.remove(tm.group); this.trains.delete(id); }
+    }
+    for (const u of sim.units) {
+      if (!this.trains.has(u.id)) {
+        const tm = new TrainMesh(this.shared, (u.runs[0] && u.runs[0].kind) || "stop");
+        tm.unitId = u.id;
+        tm.group.traverse((o) => { o.userData.unit = u.id; });
+        this.scene.add(tm.group);
+        this.trains.set(u.id, tm);
+      }
+    }
+    this.sunT = null;
+  }
+
+  setSun({ elevation, azimuth }) {
+    const el = THREE.MathUtils.degToRad(Math.max(elevation, -8));
+    const az = THREE.MathUtils.degToRad(azimuth);
+    this.sunDir = new THREE.Vector3(Math.sin(az) * Math.cos(el), Math.sin(Math.max(el, 0.03)), -Math.cos(az) * Math.cos(el));
+    const day = THREE.MathUtils.smoothstep(elevation, -6, 10);        // 0 night .. 1 day
+    const dusk = Math.max(0, 1 - Math.abs(elevation - 1) / 9) * (elevation > -8 ? 1 : 0);
+    this.night = 1 - day;
+    const sky = new THREE.Color(0x0d1830).lerp(new THREE.Color(0xa9c8e6), day);
+    sky.lerp(new THREE.Color(0xe39a62), dusk * 0.45);
+    this.scene.background = sky;
+    this.scene.fog.color.copy(sky);
+    this.hemi.intensity = 0.5 + 2.6 * day;
+    this.hemi.color.set(0xeef3ff).lerp(new THREE.Color(0x5a6a9a), 1 - day);
+    this.sun.intensity = 3.6 * day + 0.8 * dusk;
+    this.sun.color.set(0xffffff).lerp(new THREE.Color(0xffa060), dusk);
+    this.renderer.toneMappingExposure = 0.8 + 0.35 * day;
+    this.shared.mats.glow.opacity = 0.9 * this.night;
+  }
+
+  // --- cameras ---------------------------------------------------------------------------------------------
+
+  viewAll() {
+    const [x0, y0, x1, y1] = this.twin.bounds;
+    const cx = (x0 + x1) / 2, cy = (y0 + y1) / 2;
+    this.mode = "map";
+    this.followId = null;
+    this.controls.enabled = true;
+    // high enough that the whole line fits the width of the view, whatever its shape
+    const half = (x1 - x0) / 2 - 2000;
+    const tanH = Math.tan(THREE.MathUtils.degToRad(this.camera.fov / 2)) * this.camera.aspect;
+    const h = Math.max(20000, (half / tanH) * 0.95);
+    this.controls.target.set(cx, 0, -cy);
+    this.camera.position.set(cx, h, -cy + h * 0.44);
+    this.controls.update();
+  }
+
+  viewAt(x, y, dist = 700, pitch = 0.9) {
+    this.mode = "map";
+    this.followId = null;
+    this.controls.enabled = true;
+    this.controls.target.set(x, 0, -y);
+    this.camera.position.set(x - dist * 0.35, dist * Math.sin(pitch), -y + dist * Math.cos(pitch));
+    this.controls.update();
+  }
+
+  viewStation(code) {
+    const st = this.twin.stations.find((s) => s.code === code);
+    if (st) this.viewAt(st.x, st.y, 650, 0.75);
+  }
+
+  follow(unitId, mode = "chase") {
+    this.followId = unitId;
+    this.mode = mode;
+    this.lastFollow = null;
+    this.controls.enabled = mode !== "cab";
+    if (mode === "chase") {
+      const tm = this.trains.get(unitId);
+      if (tm) {
+        const p = tm.group.position.clone();
+        this.controls.target.copy(p);
+        this.camera.position.set(p.x - 140, 95, p.z + 160);
+        this.controls.update();
+      }
+    }
+  }
+
+  // --- per frame ---------------------------------------------------------------------------------------------
+
+  update(t, states, dtReal) {
+    const sim = this.sim;
+    if (!sim) return;
+    if (this.sunT === null || Math.abs(t - this.sunT) > 0.5) {      // the sun moves with the clock
+      this.setSun(sunPosition(this.R.day, t));
+      this.sunT = t;
+    }
+    // trains
+    const seen = new Set();
+    for (const s of states) {
+      const tm = this.trains.get(s.unit);
+      if (!tm) continue;
+      seen.add(s.unit);
+      tm.group.visible = true;
+      tm.setKind(this.shared, s.kind);
+      const offs = [CAR / 2 + GAP / 2 + BOGIE, CAR / 2 + GAP / 2 - BOGIE, -(CAR / 2 + GAP / 2) + BOGIE,
+        -(CAR / 2 + GAP / 2) - BOGIE];
+      const pts = this.line.body(s.dir, s.lw, s.gn, s.km, offs, s.lanes);
+      const mid = this.line.place(s.dir, s.lw, s.gn, s.km, s.lanes);
+      tm.group.position.set(mid[0], 0, -mid[1]);
+      for (let c = 0; c < 2; c++) {
+        const [a, b] = [pts[2 * c], pts[2 * c + 1]];          // its front and rear bogie, so cars follow curves
+        const car = tm.cars[c];
+        car.position.set((a[0] + b[0]) / 2 - mid[0], 0, -((a[1] + b[1]) / 2 - mid[1]));
+        car.rotation.y = Math.atan2(a[1] - b[1], a[0] - b[0]);
+        // head lamps on the leading cab, tail lamps behind
+        for (const l of car.userData.lamps) l.material = c === 0 ? this.shared.mats.head : this.shared.mats.tail;
+      }
+      const head = pts[0];
+      tm.glow.position.set(head[0] - mid[0], 2.0, -(head[1] - mid[1]));
+      tm.halo.visible = this.selected === s.unit;
+      tm.state = s;
+      const delay = Math.round(s.delay);
+      tm.label.element.innerHTML = `<i style="background:${KIND_COLOR[s.kind]}"></i>${s.train}`
+        + (delay > 0 ? `<span class="late">+${delay}</span>` : "");
+      tm.label.element.classList.toggle("sel", this.selected === s.unit);
+    }
+    for (const [id, tm] of this.trains) if (!seen.has(id)) tm.group.visible = false;
+
+    // signals
+    const occ = sim.occupancy(states);
+    for (const sg of this.signals) {
+      const sec = this.R.sections[sg.section];
+      const closed = this.closures.some((c) => c.kind === "closed" && t >= c.start && t < c.end
+        && this.covers(c, sec));
+      const red = closed || (occ[sg.section] && occ[sg.section].length > 0);
+      sg.red.material = red ? this.sigRed : this.sigOff;
+      sg.green.material = red ? this.sigOff : this.sigGreen;
+    }
+    // level crossings: down while a train is within ~35 s of reaching it, until it has passed
+    const soon = states.map((s) => {
+      const un = sim.units.find((u) => u.id === s.unit);
+      const f = un ? sim.stateAt(un, t + 0.6) : s;
+      return [Math.min(s.km, f.km) - 0.035, Math.max(s.km, f.km) + 0.035];
+    });
+    const blink = Math.floor(performance.now() / 450) % 2;
+    for (const c of this.crossings) {
+      const down = soon.some(([a, b]) => c.km >= a && c.km <= b);
+      const target = down ? 0 : Math.PI / 2;
+      c.angle += (target - c.angle) * Math.min(1, dtReal * 2.5);
+      for (const a of c.arms) a.rotation.z = c.angle;
+      c.lamps.forEach((l, i) => { l.material = down && (i + blink) % 2 ? this.lampOn : c.offMat; });
+    }
+    // disruptions: visible while they last, pulsing
+    const pulse = 0.45 + 0.25 * Math.sin(performance.now() / 300);
+    for (const c of this.closures) {
+      const on = t >= c.start && t < c.end;
+      c.mesh.visible = on;
+      c.label.visible = on;
+      c.mat.opacity = pulse;
+      c.line.visible = on && this.overview && this.overview.visible;
+    }
+    for (const v of this.breaks) {
+      const on = t >= v.t - 1 && t <= v.t + 3;
+      v.mesh.visible = v.label.visible = on;
+      if (on) v.mesh.scale.setScalar(1 + 0.15 * Math.sin(performance.now() / 160));
+    }
+    animateWorld(this.world, dtReal);
+    this.updateCamera();
+    this.updateLabels();
+  }
+
+  covers(c, sec) {
+    const idx = Object.fromEntries(this.R.points.map((p, i) => [p.code, i]));
+    const lo = Math.min(idx[c.where[0]], idx[c.where[c.where.length - 1]]);
+    const hi = Math.max(idx[c.where[0]], idx[c.where[c.where.length - 1]]);
+    const i = idx[sec.a];
+    return i >= lo && i < hi;
+  }
+
+  updateCamera() {
+    const tm = this.followId ? this.trains.get(this.followId) : null;
+    if (tm && tm.group.visible && tm.state) {
+      const s = tm.state;
+      if (this.mode === "cab") {
+        const pts = this.line.body(s.dir, s.lw, s.gn, s.km, [CAR + 0.5, CAR + 160], s.lanes);
+        this.camera.position.set(pts[0][0], 3.4, -pts[0][1]);
+        this.camera.lookAt(pts[1][0], 2.2, -pts[1][1]);
+      } else {
+        const p = tm.group.position;
+        if (this.lastFollow) {
+          const d = p.clone().sub(this.lastFollow);
+          this.camera.position.add(d);
+          this.controls.target.add(d);
+        }
+        this.lastFollow = p.clone();
+      }
+    }
+    if (this.mode !== "cab") this.controls.update();
+    // shadows follow the view
+    const tgt = this.mode === "cab" ? this.camera.position : this.controls.target;
+    const h = this.camera.position.y;
+    this.sun.castShadow = h < 2500;
+    this.sun.target.position.copy(tgt);
+    this.sun.position.copy(tgt).addScaledVector(this.sunDir || new THREE.Vector3(0.3, 0.8, 0.3), 1500);
+    this.scene.fog.near = Math.max(1500, h * 2);
+    this.scene.fog.far = Math.max(20000, h * 7);
+    if (this.overview) {                               // the overview line fades in as the track gets too thin to see
+      const a = THREE.MathUtils.smoothstep(h, 1200, 4000);
+      this.overview.visible = a > 0.01;
+      for (const m of this.lineMats) m.opacity = a;
+      for (const m of this.closureMats || []) m.opacity = a;
+    }
+    const trees = this.world.getObjectByName("trees");
+    if (trees) {                                       // trees only near the view: there are tens of thousands
+      trees.visible = h < 2500;
+      if (trees.visible) for (const im of trees.children) im.visible = im.userData.centre.distanceTo(tgt) < 3500 + h;
+    }
+  }
+
+  updateLabels() {
+    const cam = this.camera.position;
+    const h = cam.y;
+    const narrow = window.innerWidth < 760 && h > 20000;  // a phone's overview: terminals and turn points only
+    for (const l of this.placeLabels) {
+      const show = !l.dup && !narrow && ((l.r <= 1 && h > 2500) || (l.r === 2 && h > 900 && h < 20000) || (l.r === 3 && h < 6000 && h > 300));
+      l.obj.visible = show;
+    }
+    for (const l of this.stationLabels) {                // far stations only from high up
+      l.obj.visible = (h > 2000 || Math.hypot(l.x - cam.x, -l.y - cam.z) < 12000)
+        && (!narrow || ["LW", "HDG", "BP", "ZH", "GN"].includes(l.code));
+    }
+    for (const tm of this.trains.values()) {
+      const d = tm.group.position.distanceTo(cam);
+      tm.label.visible = tm.group.visible;
+      tm.label.element.classList.toggle("far", d > 9000);
+    }
+    for (const c of this.closures) if (c.label.visible) c.label.element.classList.toggle("far", h > 15000);
+  }
+
+  render() {
+    this.renderer.render(this.scene, this.camera);
+    this.labels.render(this.scene, this.camera);
+  }
+
+  pick(clientX, clientY) {
+    const r = this.renderer.domElement.getBoundingClientRect();
+    const v = new THREE.Vector2(((clientX - r.left) / r.width) * 2 - 1, -((clientY - r.top) / r.height) * 2 + 1);
+    const ray = new THREE.Raycaster();
+    ray.setFromCamera(v, this.camera);
+    const objs = [];
+    for (const tm of this.trains.values()) if (tm.group.visible) objs.push(tm.group);
+    const hit = ray.intersectObjects(objs, true).find((h) => h.object.userData.unit);
+    if (hit) return hit.object.userData.unit;
+    // generous fallback: the train nearest the click on screen
+    let best = null, bd = 28;
+    for (const tm of this.trains.values()) {
+      if (!tm.group.visible) continue;
+      const p = tm.group.position.clone().project(this.camera);
+      const sx = (p.x + 1) / 2 * r.width + r.left, sy = (1 - p.y) / 2 * r.height + r.top;
+      const d = Math.hypot(sx - clientX, sy - clientY);
+      if (d < bd && p.z < 1) { bd = d; best = tm.unitId; }
+    }
+    return best;
+  }
+}
+
+export { CANONICAL };

openenv/rail_openenv/web/twin/style.css

@@ -0,0 +1,161 @@
+/* The line twin's interface: dark glass panels over the 3D view (one theme: the map is the light source). */
+:root {
+  color-scheme: dark;
+  --surface-1: rgba(26, 26, 25, 0.86);
+  --surface-2: rgba(44, 44, 42, 0.92);
+  --page: #0d0d0d;
+  --text-primary: #ffffff;
+  --text-secondary: #c3c2b7;
+  --muted: #898781;
+  --grid: #2c2c2a;
+  --border: rgba(255, 255, 255, 0.10);
+  --stop: #3987e5;
+  --fast: #d95926;
+  --critical: #d03b3b;
+  --warning: #fab219;
+  --serious: #ec835a;
+  --good: #0ca30c;
+  --accent: #199e70;
+  --bottom-h: 196px;
+  --side-w: 300px;
+  --bar-h: 52px;
+}
+* { box-sizing: border-box; }
+html, body { margin: 0; height: 100%; overflow: hidden; background: var(--page); color: var(--text-primary);
+  font: 13px/1.45 system-ui, -apple-system, "Segoe UI", sans-serif; }
+#stage { position: fixed; inset: 0; }
+#stage canvas { display: block; }
+.labels { position: absolute; inset: 0; pointer-events: auto; }
+.muted { color: var(--muted); }
+button, select { font: inherit; color: var(--text-primary); background: var(--surface-2); border: 1px solid var(--border);
+  border-radius: 6px; padding: 4px 9px; cursor: pointer; }
+button:hover, select:hover { border-color: rgba(255, 255, 255, 0.28); }
+button.on { background: #f2f1ec; color: #0b0b0b; }
+select { max-width: 100%; }
+
+#bar { position: fixed; top: 0; left: 0; right: 0; height: var(--bar-h); display: flex; align-items: center; gap: 14px;
+  padding: 0 14px; background: var(--surface-1); border-bottom: 1px solid var(--border); backdrop-filter: blur(8px);
+  z-index: 5; overflow-x: auto; }
+.brand { display: flex; flex-direction: column; line-height: 1.15; white-space: nowrap; }
+.brand span { color: var(--muted); font-size: 11px; }
+.pick { display: flex; align-items: center; gap: 6px; min-width: 0; }
+.pick span { color: var(--muted); font-size: 11px; }
+#task { width: 250px; }
+#plan { width: 230px; }
+#station { width: 120px; }
+.transport { display: flex; align-items: center; gap: 6px; }
+#play { width: 38px; }
+#clock { display: flex; flex-direction: column; line-height: 1.1; min-width: 118px; font-variant-numeric: tabular-nums; }
+#clock b { font-size: 17px; }
+#clock span { color: var(--muted); font-size: 11px; }
+.cams { display: flex; gap: 4px; }
+.graphlink { color: var(--text-secondary); text-decoration: none; white-space: nowrap; }
+#panels { margin-left: auto; }
+
+.panel { position: fixed; background: var(--surface-1); border: 1px solid var(--border); border-radius: 10px;
+  backdrop-filter: blur(8px); z-index: 4; }
+#left { top: calc(var(--bar-h) + 10px); left: 10px; width: var(--side-w); max-height: calc(100% - var(--bar-h) - var(--bottom-h) - 30px);
+  overflow-y: auto; padding: 12px 14px; }
+#right { top: calc(var(--bar-h) + 10px); right: 10px; width: var(--side-w); max-height: calc(100% - var(--bar-h) - var(--bottom-h) - 30px);
+  overflow-y: auto; padding: 10px 12px; }
+#bottom { left: 10px; right: 10px; bottom: 10px; height: var(--bottom-h); display: flex; gap: 10px; padding: 8px 10px; }
+h2, h3 { margin: 4px 0 8px; font-size: 13px; font-weight: 600; }
+h3 { color: var(--text-secondary); margin-top: 12px; }
+
+#scenario .day { font-size: 15px; font-weight: 600; }
+#scenario .tier { display: inline-block; padding: 1px 7px; border-radius: 9px; background: var(--surface-2);
+  color: var(--text-secondary); font-size: 11px; margin-left: 6px; }
+#scenario ul { margin: 6px 0 0; padding-left: 16px; }
+#scenario li { margin: 2px 0; }
+#scenario .note { color: var(--text-secondary); font-size: 12px; }
+#result { margin-top: 12px; padding-top: 10px; border-top: 1px solid var(--border); }
+#result .plan-name { color: var(--text-secondary); }
+#result .hero { font-size: 30px; font-weight: 600; line-height: 1.1; margin: 4px 0; }
+#result .hero small { font-size: 12px; font-weight: 400; color: var(--muted); margin-left: 4px; }
+#result .badge { display: inline-flex; align-items: center; gap: 5px; font-size: 12px; }
+#result .badge.ok::before { content: "✓"; color: var(--good); font-weight: 700; }
+#result .badge.bad::before { content: "✕"; color: var(--critical); font-weight: 700; }
+#result dl { display: grid; grid-template-columns: auto 1fr; gap: 2px 12px; margin: 8px 0 0; }
+#result dt { color: var(--muted); }
+#result dd { margin: 0; font-variant-numeric: tabular-nums; }
+#result .viol { margin: 8px 0 0; padding: 0; list-style: none; max-height: 140px; overflow-y: auto; }
+#result .viol li { cursor: pointer; padding: 3px 0; border-top: 1px solid var(--grid); font-size: 12px; color: var(--text-secondary); }
+#result .viol li::before { content: "! "; color: var(--critical); font-weight: 700; }
+.legend { margin-top: 12px; padding-top: 10px; border-top: 1px solid var(--border); font-size: 12px; color: var(--text-secondary); }
+.legend div { margin: 3px 0; }
+.chip { display: inline-block; width: 10px; height: 10px; border-radius: 3px; margin: 0 5px 0 0; vertical-align: -1px; }
+.legend .chip + .chip, .legend i + i { margin-left: 10px; }
+.bar { display: inline-block; width: 16px; height: 6px; border-radius: 2px; margin-right: 5px; vertical-align: 1px; }
+.bar.closed { background: var(--critical); } .bar.slow { background: var(--warning); } .bar.track { background: var(--serious); }
+.bar.single { background: #ffffff; outline: 2px solid #1a1a19; } .bar.double { background: #9a9a96; outline: 2px solid #1a1a19; }
+body.clean #left, body.clean #right { display: none; }
+
+#trains, #cancelled { list-style: none; margin: 0; padding: 0; }
+#trains li, #cancelled li { display: grid; grid-template-columns: 12px auto 1fr auto; align-items: center; gap: 2px 8px;
+  padding: 6px 4px; border-top: 1px solid var(--grid); cursor: pointer; border-radius: 4px; }
+#trains li:hover { background: rgba(255, 255, 255, 0.05); }
+#trains li.sel { background: rgba(255, 255, 255, 0.10); }
+#trains .num { font-weight: 600; font-variant-numeric: tabular-nums; }
+#trains .st { grid-column: 2 / 5; color: var(--text-secondary); font-size: 12px; }
+#trains .dl { font-variant-numeric: tabular-nums; color: var(--text-secondary); }
+#trains .dl.late { color: var(--warning); }
+#cancelled li { cursor: default; color: var(--muted); }
+
+.graphwrap { position: relative; flex: 1 1 auto; min-width: 0; display: flex; flex-direction: column; }
+.costwrap { position: relative; flex: 0 0 340px; }
+.chart-h { display: flex; gap: 10px; align-items: baseline; font-size: 12px; padding-left: 44px; }
+#graph { flex: 1; width: 100%; min-height: 0; cursor: crosshair; touch-action: none; }
+#cost { width: 100%; height: 100%; cursor: crosshair; }
+.tip { position: absolute; pointer-events: none; background: #f2f1ec; color: #0b0b0b; padding: 4px 8px; border-radius: 6px;
+  font-size: 12px; white-space: nowrap; box-shadow: 0 2px 8px rgba(0, 0, 0, 0.4); z-index: 3; }
+
+/* labels in the 3D view */
+.tlabel { font-size: 11px; font-weight: 600; padding: 1px 6px 1px 4px; border-radius: 9px; background: rgba(13, 13, 13, 0.78);
+  color: #fff; white-space: nowrap; display: flex; align-items: center; gap: 4px; pointer-events: none; }
+.tlabel i { width: 7px; height: 7px; border-radius: 50%; display: inline-block; }
+.tlabel .late { color: var(--warning); font-weight: 600; }
+.tlabel.far { font-size: 10px; padding: 0 5px 0 3px; }
+.tlabel.far .late { display: none; }
+.tlabel.sel { outline: 2px solid #fff; }
+.slabel { font-size: 12px; font-weight: 600; color: #fff; background: #23408f; padding: 1px 7px; border-radius: 3px;
+  white-space: nowrap; pointer-events: none; box-shadow: 0 1px 3px rgba(0, 0, 0, 0.5); }
+.plabel { color: rgba(255, 255, 255, 0.82); text-shadow: 0 1px 3px rgba(0, 0, 0, 0.9); pointer-events: none; white-space: nowrap; }
+.plabel.r0, .plabel.r1 { font-size: 15px; font-weight: 600; letter-spacing: 0.04em; }
+.plabel.r2 { font-size: 12px; }
+.plabel.r3 { font-size: 11px; font-style: italic; }
+.clabel { font-size: 11px; color: #fff; padding: 2px 7px; border-radius: 4px; white-space: nowrap; pointer-events: none;
+  border-left: 3px solid var(--critical); background: rgba(13, 13, 13, 0.82); }
+.clabel.slow { border-color: var(--warning); } .clabel.track { border-color: var(--serious); }
+.clabel.far { font-size: 10px; }
+.vlabel { font-size: 11px; color: #fff; padding: 2px 7px; border-radius: 4px; white-space: nowrap; pointer-events: none;
+  background: var(--critical); }
+.vlabel b::before { content: "! "; }
+
+#toasts { position: fixed; left: 50%; transform: translateX(-50%); top: calc(var(--bar-h) + 12px); z-index: 6;
+  display: flex; flex-direction: column; gap: 6px; align-items: center; pointer-events: none; }
+.toast { background: var(--surface-2); border: 1px solid var(--border); border-left: 3px solid var(--text-secondary);
+  padding: 5px 10px; border-radius: 6px; font-size: 12px; max-width: min(560px, 90vw); transition: opacity 0.6s; }
+.toast.closure, .toast.violation { border-left-color: var(--critical); }
+.toast.reopen { border-left-color: var(--good); }
+.toast time { color: var(--muted); margin-right: 6px; font-variant-numeric: tabular-nums; }
+
+#loading { position: fixed; inset: 0; display: grid; place-items: center; background: var(--page); z-index: 10;
+  transition: opacity 0.5s; text-align: center; }
+#loading p { color: var(--muted); margin: 6px 0 0; }
+#loading.done { opacity: 0; pointer-events: none; }
+
+@media (max-width: 1100px) {
+  :root { --side-w: 250px; }
+  #task { width: 200px; } #plan { width: 180px; }
+  .graphlink { display: none; }
+}
+@media (max-width: 760px) {
+  :root { --bottom-h: 150px; --bar-h: 96px; }
+  #bar { flex-wrap: wrap; height: auto; min-height: var(--bar-h); padding: 6px 16px; gap: 6px 10px; }
+  .brand span { display: none; }
+  #task, #plan { width: 150px; }
+  #left, #right { display: none; }
+  #bottom { left: 6px; right: 6px; bottom: 6px; }
+  .costwrap { display: none; }
+  .chart-h .muted { display: none; }
+}

openenv/rail_openenv/web/twin/twin.json.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:11f10c84c37afd98a081fe1ea9494f1f0421a6a09c52ea24589b835cea00db31
+size 3548310

openenv/rail_openenv/web/twin/world.js

@@ -0,0 +1,514 @@
+// The static scenery of the line twin, built once from twin.json (OpenStreetMap, see SOURCES.md): ground, land cover,
+// water, roads, buildings, trees, landmarks, track and platforms. Everything is merged into a few large meshes,
+// tiled so the renderer can skip what is off screen.
+//
+// World frame: x east, z south (-north), y up, metres; the twin's (x, y) maps to (x, -y).
+
+import * as THREE from "three";
+import { mergeGeometries } from "three/addons/utils/BufferGeometryUtils.js";
+
+export const TILE = 2000;          // metres: tile size for culling
+const Y = { landcover: 0.02, farmland: 0.01, water: 0.05, waterway: 0.06, road: 0.09, platform: 0, track: 0.12 };
+
+export const COLORS = {
+  ground: 0x789a58,
+  landcover: {
+    0: 0xbfb6a4, 1: 0x82a85c, 2: 0x7fae5a, 3: 0xb4aebb, 4: 0xc8b9aa, 5: 0xa39d92, 6: 0xb3a789, 7: 0x3e6a35,
+    8: 0x7ea75a, 9: 0x8a9255, 10: 0x6d9a7f, 11: 0x6f9a55, 12: 0x7d9c6a, 13: 0xd2dbd8, 14: 0x7fa257, 15: 0x98a862,
+    16: 0xd8c99a,
+  },
+  water: 0x4d7da6,
+  road: [0x4c4d51, 0x55565a, 0x5b5c60, 0x616265, 0x67686b, 0x6e6e70, 0x9b8b6a, 0xa2584b],
+  roadWidth: [22, 13, 10, 8, 5.5, 4, 3, 2.6],
+  waterwayWidth: [22, 14, 4, 1.8],
+  building: [
+    [0x9b5a43, 0x4a3a34], [0xa77d63, 0x585654], [0x7b5d4b, 0x3d3a36], [0x9ea3a8, 0x7c8186], [0xb8a998, 0x6f6a66],
+    [0x8a4e3b, 0x3f3936], [0xd5e2de, 0xc3d2ce], [0xb7724f, 0x4b4744],
+  ],
+  ballast: 0x8b8379, rail: 0xc4c7cb, sleeper: 0x5a4a3d, platform: 0xbab6ae, platformEdge: 0xe0bf38,
+  trunk: 0x5b4636, crown: 0x3f6b33, crown2: 0x4f7a3b,
+};
+
+const col = new THREE.Color();
+
+function decode(flat) {
+  const pts = [];
+  for (let i = 0; i < flat.length; i += 2) pts.push([flat[i] / 10, flat[i + 1] / 10]);
+  return pts;
+}
+
+function tileKey(x, y) {
+  return `${Math.floor(x / TILE)},${Math.floor(y / TILE)}`;
+}
+
+// growable typed buffers for one mesh
+class Buf {
+  constructor() { this.pos = []; this.col = []; this.uv = null; this.idx = []; }
+  get n() { return this.pos.length / 3; }
+  vert(x, y, z, c) { this.pos.push(x, y, z); this.col.push(c.r, c.g, c.b); return this.n - 1; }
+  // a triangle that faces up (+y), whichever way its vertices were given
+  up(a, b, c) {
+    const P = this.pos;
+    const ax = P[3 * a], az = P[3 * a + 2], bx = P[3 * b], bz = P[3 * b + 2], cx = P[3 * c], cz = P[3 * c + 2];
+    const ny = (bz - az) * (cx - ax) - (bx - ax) * (cz - az);
+    if (ny >= 0) this.idx.push(a, b, c); else this.idx.push(a, c, b);
+  }
+  geometry() {
+    const g = new THREE.BufferGeometry();
+    g.setAttribute("position", new THREE.Float32BufferAttribute(this.pos, 3));
+    g.setAttribute("color", new THREE.Float32BufferAttribute(this.col, 3));
+    if (this.uv) g.setAttribute("uv", new THREE.Float32BufferAttribute(this.uv, 2));
+    g.setIndex(this.n > 65535 ? new THREE.Uint32BufferAttribute(this.idx, 1) : new THREE.Uint16BufferAttribute(this.idx, 1));
+    g.computeVertexNormals();
+    g.computeBoundingSphere();
+    return g;
+  }
+}
+
+function tiled(map, key) {
+  let b = map.get(key);
+  if (!b) { b = new Buf(); map.set(key, b); }
+  return b;
+}
+
+// Flat layers (ground, land cover, water, roads, track) are painted in a fixed order before anything 3D, without
+// depth: they all lie on the ground, and centimetre offsets cannot win a depth test from kilometres away.
+function flat(material, order) {
+  material.side = THREE.DoubleSide;
+  material.depthTest = false;
+  material.depthWrite = false;
+  material.userData.order = order;
+  return material;
+}
+
+function meshes(map, material, opts = {}) {
+  const group = new THREE.Group();
+  for (const b of map.values()) {
+    if (!b.n) continue;
+    const m = new THREE.Mesh(b.geometry(), material);
+    m.receiveShadow = !!opts.receive;
+    m.castShadow = !!opts.cast;
+    if (material.userData.order !== undefined) m.renderOrder = material.userData.order;
+    group.add(m);
+  }
+  return group;
+}
+
+// flat polygons (outer ring + holes), triangulated, at height y, into tiled buffers
+function addPolygon(map, outer, holes, y, c) {
+  if (outer.length < 3) return;
+  const contour = outer.map(([x, yy]) => new THREE.Vector2(x, yy));
+  const hs = holes.map((h) => h.map(([x, yy]) => new THREE.Vector2(x, yy)));
+  let tris;
+  try {
+    tris = THREE.ShapeUtils.triangulateShape(contour, hs);
+  } catch {
+    return;
+  }
+  const all = [...outer, ...holes.flat()];
+  let cx = 0, cy = 0;
+  for (const [x, yy] of outer) { cx += x; cy += yy; }
+  const b = tiled(map, tileKey(cx / outer.length, cy / outer.length));
+  const base = b.n;
+  for (const [x, yy] of all) b.vert(x, y, -yy, c);
+  for (const [a, bb, cc] of tris) b.up(base + a, base + bb, base + cc);
+}
+
+// ribbons along polylines (roads, rivers, ditches) with mitred joins
+function addRibbon(map, pts, width, y, c, uvScale = 0) {
+  if (pts.length < 2) return;
+  const h = width / 2;
+  const n = pts.length;
+  const mid = pts[n >> 1];
+  const b = tiled(map, tileKey(mid[0], mid[1]));
+  if (uvScale && !b.uv) b.uv = [];
+  const base = b.n;
+  let along = 0;
+  for (let i = 0; i < n; i++) {
+    const p = pts[i], a = pts[Math.max(0, i - 1)], q = pts[Math.min(n - 1, i + 1)];
+    let dx = q[0] - a[0], dy = q[1] - a[1];
+    const L = Math.hypot(dx, dy) || 1;
+    dx /= L; dy /= L;
+    let nx = -dy, ny = dx, k = 1;
+    if (i > 0 && i < n - 1) {                       // mitre: keep the width constant around the corner
+      const ex = p[0] - a[0], ey = p[1] - a[1], el = Math.hypot(ex, ey) || 1;
+      const sx = -ey / el, sy = ex / el;
+      k = 1 / Math.max(0.35, nx * sx + ny * sy);
+    }
+    if (i > 0) along += Math.hypot(p[0] - pts[i - 1][0], p[1] - pts[i - 1][1]);
+    b.vert(p[0] + nx * h * k, y, -(p[1] + ny * h * k), c);
+    b.vert(p[0] - nx * h * k, y, -(p[1] - ny * h * k), c);
+    if (uvScale) b.uv.push(0, along / uvScale, 1, along / uvScale);
+  }
+  for (let i = 0; i < n - 1; i++) {
+    const v = base + 2 * i;
+    b.up(v, v + 1, v + 2);
+    b.up(v + 1, v + 3, v + 2);
+  }
+}
+
+function sleeperTexture() {
+  const cv = document.createElement("canvas");
+  cv.width = 64; cv.height = 64;
+  const g = cv.getContext("2d");
+  g.fillStyle = "#8b8379"; g.fillRect(0, 0, 64, 64);
+  for (let i = 0; i < 400; i++) {                  // ballast grain
+    const v = 110 + Math.floor(Math.random() * 60);
+    g.fillStyle = `rgb(${v},${v - 6},${v - 14})`;
+    g.fillRect(Math.random() * 64, Math.random() * 64, 2, 2);
+  }
+  g.fillStyle = "#5a4a3d";
+  g.fillRect(6, 4, 52, 22);                       // one sleeper per 0.6 m (two per texture repeat of 1.2 m)
+  g.fillRect(6, 36, 52, 22);
+  const t = new THREE.CanvasTexture(cv);
+  t.wrapS = t.wrapT = THREE.RepeatWrapping;
+  t.anisotropy = 8;
+  t.colorSpace = THREE.SRGBColorSpace;
+  return t;
+}
+
+export function buildWorld(twin, scene, opts = {}) {
+  const root = new THREE.Group();
+  root.name = "world";
+  const [x0, y0, x1, y1] = twin.bounds;
+  const vc = (o = {}) => new THREE.MeshLambertMaterial({ vertexColors: true, ...o });
+
+  // ground
+  const ground = new THREE.Mesh(new THREE.PlaneGeometry(x1 - x0 + 600000, y1 - y0 + 600000),
+    flat(new THREE.MeshLambertMaterial({ color: COLORS.ground }), -10));
+  ground.renderOrder = -10;
+  ground.rotation.x = -Math.PI / 2;
+  ground.position.set((x0 + x1) / 2, 0, -(y0 + y1) / 2);
+  ground.receiveShadow = true;
+  root.add(ground);
+
+  // land cover: farmland and meadows get a slight per-field tint, so the parcel pattern shows
+  const lc = new Map();
+  let i = 0;
+  for (const p of twin.landcover) {
+    const base = COLORS.landcover[p.c] ?? COLORS.ground;
+    col.setHex(base);
+    if (p.c === 14 || p.c === 15 || p.c === 1) col.offsetHSL(((i * 37) % 11 - 5) * 0.004, 0, ((i * 53) % 9 - 4) * 0.008);
+    addPolygon(lc, decode(p.o), p.i.map(decode), p.c >= 14 ? Y.farmland : Y.landcover, col.clone());
+    i++;
+  }
+  root.add(meshes(lc, flat(vc(), -9), { receive: true }));
+
+  // water: lakes, canals and rivers as areas, ditches and drains as ribbons
+  const wat = new Map();
+  col.setHex(COLORS.water);
+  for (const p of twin.water) addPolygon(wat, decode(p.o), p.i.map(decode), Y.water, col);
+  for (const w of twin.waterways) addRibbon(wat, decode(w.p), COLORS.waterwayWidth[w.c] ?? 2, Y.waterway, col);
+  const waterMat = flat(new THREE.MeshPhongMaterial({ vertexColors: true, shininess: 80, specular: 0x334455 }), -8);
+  root.add(meshes(wat, waterMat));
+
+  // roads (Dutch cycle paths in their red asphalt)
+  const rd = new Map();
+  for (const r of [...twin.roads].sort((a, b) => b.c - a.c)) {
+    col.setHex(COLORS.road[r.c] ?? COLORS.road[4]);
+    addRibbon(rd, decode(r.p), COLORS.roadWidth[r.c] ?? 4, Y.road + (7 - r.c) * 0.004, col);
+  }
+  root.add(meshes(rd, flat(vc(), -7), { receive: true }));
+
+  // buildings: walls and flat roofs, coloured by kind
+  const bl = new Map();
+  const B = twin.buildings;
+  const wall = new THREE.Color(), roof = new THREE.Color();
+  for (let k = 0; k < B.p.length; k++) {
+    const ring = decode(B.p[k]);
+    if (ring.length < 3) continue;
+    const h = B.h[k];
+    const [wc, rc] = COLORS.building[B.k[k]] ?? COLORS.building[0];
+    wall.setHex(wc).offsetHSL(0, 0, ((k * 29) % 7 - 3) * 0.012);
+    roof.setHex(rc);
+    let cx = 0, cy = 0;
+    for (const [x, y] of ring) { cx += x; cy += y; }
+    const b = tiled(bl, tileKey(cx / ring.length, cy / ring.length));
+    // orientation: walls face outwards whichever way the ring runs
+    let area = 0;
+    for (let j = 0; j < ring.length; j++) {
+      const [ax, ay] = ring[j], [bx, by] = ring[(j + 1) % ring.length];
+      area += ax * by - bx * ay;
+    }
+    const ccw = area > 0;
+    for (let j = 0; j < ring.length; j++) {
+      const [ax, ay] = ring[j], [bx, by] = ring[(j + 1) % ring.length];
+      const v = b.n;
+      b.vert(ax, 0, -ay, wall); b.vert(bx, 0, -by, wall); b.vert(bx, h, -by, wall); b.vert(ax, h, -ay, wall);
+      if (ccw) b.idx.push(v, v + 1, v + 2, v, v + 2, v + 3);
+      else b.idx.push(v, v + 2, v + 1, v, v + 3, v + 2);
+    }
+    let tris;
+    try { tris = THREE.ShapeUtils.triangulateShape(ring.map(([x, y]) => new THREE.Vector2(x, y)), []); }
+    catch { tris = []; }
+    const v0 = b.n;
+    for (const [x, y] of ring) b.vert(x, h, -y, roof);
+    for (const [a, bb, c] of tris) b.up(v0 + a, v0 + bb, v0 + c);
+  }
+  const buildings = meshes(bl, vc({ flatShading: true }), { cast: true, receive: true });
+  buildings.name = "buildings";
+  root.add(buildings);
+
+  // track: ballast with sleepers, then the two rails (1435 mm gauge)
+  const tex = sleeperTexture();
+  const bal = new Map(), rails = new Map();
+  const white = new THREE.Color(0xffffff), steel = new THREE.Color(COLORS.rail);
+  for (const t of twin.tracks) {
+    const pts = decode(t.p);
+    addRibbon(bal, pts, t.k ? 2.8 : 3.2, Y.track, white, 1.2);
+    for (const off of [-0.7175, 0.7175]) {
+      const shifted = offsetLine(pts, off);
+      addRibbon(rails, shifted, 0.075, Y.track + 0.17, steel);
+    }
+  }
+  root.add(meshes(bal, flat(new THREE.MeshLambertMaterial({ map: tex, vertexColors: true }), -6), { receive: true }));
+  root.add(meshes(rails, flat(new THREE.MeshPhongMaterial({ vertexColors: true, shininess: 90, specular: 0x999999 }), -5)));
+
+  // platforms: 76 cm high, concrete, with the yellow safety line
+  const pl = new Map(), edge = new Map();
+  for (const p of twin.platforms) {
+    const ring = decode(p.p);
+    if (ring.length < 3) continue;
+    extrude(pl, ring, 0.76, new THREE.Color(COLORS.platform));
+    addRibbon(edge, offsetRing(ring, -0.6), 0.1, 0.78, new THREE.Color(COLORS.platformEdge));
+  }
+  root.add(meshes(pl, vc(), { receive: true, cast: true }));
+  root.add(meshes(edge, vc()));
+
+  // trees: rows (Frisian alder rows and hedgerows), single trees, woods
+  root.add(buildTrees(twin, opts.treeCap ?? 60000));
+  root.add(buildLandmarks(twin, opts));
+  scene.add(root);
+  return root;
+}
+
+function offsetLine(pts, d) {
+  const out = [];
+  for (let i = 0; i < pts.length; i++) {
+    const a = pts[Math.max(0, i - 1)], b = pts[Math.min(pts.length - 1, i + 1)];
+    const dx = b[0] - a[0], dy = b[1] - a[1], L = Math.hypot(dx, dy) || 1;
+    out.push([pts[i][0] - dy / L * d, pts[i][1] + dx / L * d]);
+  }
+  return out;
+}
+
+function offsetRing(ring, d) {
+  const closed = [...ring, ring[0]];
+  return offsetLine(closed, d);
+}
+
+function extrude(map, ring, h, c) {
+  let cx = 0, cy = 0;
+  for (const [x, y] of ring) { cx += x; cy += y; }
+  const b = tiled(map, tileKey(cx / ring.length, cy / ring.length));
+  let area = 0;
+  for (let j = 0; j < ring.length; j++) {
+    const [ax, ay] = ring[j], [bx, by] = ring[(j + 1) % ring.length];
+    area += ax * by - bx * ay;
+  }
+  for (let j = 0; j < ring.length; j++) {
+    const [ax, ay] = ring[j], [bx, by] = ring[(j + 1) % ring.length];
+    const v = b.n;
+    b.vert(ax, 0, -ay, c); b.vert(bx, 0, -by, c); b.vert(bx, h, -by, c); b.vert(ax, h, -ay, c);
+    if (area > 0) b.idx.push(v, v + 1, v + 2, v, v + 2, v + 3); else b.idx.push(v, v + 2, v + 1, v, v + 3, v + 2);
+  }
+  let tris;
+  try { tris = THREE.ShapeUtils.triangulateShape(ring.map(([x, y]) => new THREE.Vector2(x, y)), []); }
+  catch { tris = []; }
+  const v0 = b.n;
+  for (const [x, y] of ring) b.vert(x, h, -y, c);
+  for (const [a, bb, cc] of tris) b.up(v0 + a, v0 + bb, v0 + cc);
+}
+
+// deterministic pseudo-random (no Math.random in the scenery: the same twin always looks the same)
+function rng(seed) {
+  let s = seed >>> 0;
+  return () => ((s = (s * 1664525 + 1013904223) >>> 0) / 4294967296);
+}
+
+function treeGeometry() {
+  const trunk = new THREE.CylinderGeometry(0.18, 0.25, 3, 4);
+  trunk.translate(0, 1.5, 0);
+  const crown = new THREE.IcosahedronGeometry(2.6, 0);
+  crown.scale(1, 1.25, 1);
+  crown.translate(0, 5.2, 0);
+  const paint = (g, c) => {
+    const n = g.attributes.position.count, arr = new Float32Array(n * 3);
+    col.setHex(c);
+    for (let i = 0; i < n; i++) arr.set([col.r, col.g, col.b], i * 3);
+    g.setAttribute("color", new THREE.BufferAttribute(arr, 3));
+    return g;
+  };
+  const flatGeo = (g) => (g.index ? g.toNonIndexed() : g);
+  const a = paint(flatGeo(trunk), COLORS.trunk), b = paint(flatGeo(crown), COLORS.crown);
+  const g = new THREE.BufferGeometry();
+  for (const name of ["position", "normal", "color"]) {
+    const x = a.attributes[name], y = b.attributes[name];
+    const arr = new Float32Array(x.array.length + y.array.length);
+    arr.set(x.array); arr.set(y.array, x.array.length);
+    g.setAttribute(name, new THREE.BufferAttribute(arr, x.itemSize));
+  }
+  g.computeVertexNormals();
+  return g;
+}
+
+function buildTrees(twin, cap) {
+  const spots = [];
+  const r = rng(7);
+  for (const row of twin.trees.rows) {
+    const pts = decode(row);
+    for (let i = 1; i < pts.length; i++) {
+      const [ax, ay] = pts[i - 1], [bx, by] = pts[i];
+      const L = Math.hypot(bx - ax, by - ay);
+      for (let d = r() * 7; d < L; d += 6.5 + r() * 2) spots.push([ax + (bx - ax) * d / L, ay + (by - ay) * d / L]);
+    }
+  }
+  const P = twin.trees.points;
+  for (let i = 0; i < P.length; i += 2) spots.push([P[i] / 10, P[i + 1] / 10]);
+  for (const p of twin.landcover) {                   // woods: scattered trees, up to one per 120 m2
+    if (p.c !== 7) continue;
+    const ring = decode(p.o);
+    let minx = Infinity, miny = Infinity, maxx = -Infinity, maxy = -Infinity;
+    for (const [x, y] of ring) { minx = Math.min(minx, x); maxx = Math.max(maxx, x); miny = Math.min(miny, y); maxy = Math.max(maxy, y); }
+    const step = 11;
+    for (let x = minx; x < maxx; x += step) {
+      for (let y = miny; y < maxy; y += step) {
+        const px = x + r() * step, py = y + r() * step;
+        if (inside(px, py, ring)) spots.push([px, py]);
+        if (spots.length > cap) break;
+      }
+    }
+  }
+  const group = new THREE.Group();
+  group.name = "trees";
+  const byTile = new Map();
+  for (const s of spots.slice(0, cap)) {
+    const k = tileKey(s[0], s[1]);
+    if (!byTile.has(k)) byTile.set(k, []);
+    byTile.get(k).push(s);
+  }
+  const geo = treeGeometry();
+  const mat = new THREE.MeshLambertMaterial({ vertexColors: true, flatShading: true });
+  const m4 = new THREE.Matrix4(), q = new THREE.Quaternion(), sc = new THREE.Vector3(), pos = new THREE.Vector3();
+  const up = new THREE.Vector3(0, 1, 0);
+  for (const list of byTile.values()) {
+    const im = new THREE.InstancedMesh(geo, mat, list.length);
+    list.forEach(([x, y], j) => {
+      const s = 0.7 + r() * 0.6;
+      q.setFromAxisAngle(up, r() * Math.PI * 2);
+      m4.compose(pos.set(x, 0, -y), q, sc.set(s, s * (0.85 + r() * 0.4), s));
+      im.setMatrixAt(j, m4);
+      const v = 0.82 + r() * 0.3;                    // brightness only: keeps green crowns and brown trunks
+      im.setColorAt(j, col.setRGB(v, v * (0.98 + r() * 0.06), v));
+    });
+    im.computeBoundingSphere();
+    im.castShadow = true;
+    im.userData.centre = new THREE.Vector3(list[0][0], 0, -list[0][1]);
+    group.add(im);
+  }
+  return group;
+}
+
+function inside(x, y, ring) {
+  let c = false;
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    const [xi, yi] = ring[i], [xj, yj] = ring[j];
+    if ((yi > y) !== (yj > y) && x < (xj - xi) * (y - yi) / (yj - yi) + xi) c = !c;
+  }
+  return c;
+}
+
+// windmills (the Frisian polder mills), wind turbines, water towers. Static parts are merged into one mesh per
+// material; blades and sails are instanced and turn in animateWorld().
+function buildLandmarks(twin) {
+  const group = new THREE.Group();
+  group.name = "landmarks";
+  const parts = { white: [], body: [], cap: [], brick: [] };
+  const rotors = [];
+  const m4 = new THREE.Matrix4(), q = new THREE.Quaternion(), up = new THREE.Vector3(0, 1, 0);
+  const put = (kind, geo, x, y, z, yaw = 0) => {
+    m4.compose(new THREE.Vector3(x, y, z), q.setFromAxisAngle(up, yaw), new THREE.Vector3(1, 1, 1));
+    parts[kind].push((geo.index ? geo.toNonIndexed() : geo).applyMatrix4(m4));
+  };
+  const YAW = 0.6;                                     // facing the prevailing south-westerly
+  for (const m of twin.landmarks) {
+    const x = m.x, z = -m.y;
+    const dx = Math.cos(YAW), dz = -Math.sin(YAW);     // the rotor side, in the world frame
+    if (m.k === "turbine") {
+      const h = Math.max(40, Math.min(m.h, 140));
+      put("white", new THREE.CylinderGeometry(1.2, 2.2, h, 10), x, h / 2, z);
+      put("white", new THREE.BoxGeometry(6, 3, 3), x, h + 1, z, YAW);
+      rotors.push({ kind: "blade", n: 3, len: h * 0.45, hub: new THREE.Vector3(x + dx * 3.2, h + 1, z + dz * 3.2), speed: 1.6,
+        phase: (x * 0.013) % 6.28 });
+    } else if (m.k === "mill") {
+      const h = Math.max(8, Math.min(m.h, 30));
+      put("body", new THREE.CylinderGeometry(2.2, 4.2, h * 0.7, 8), x, h * 0.35, z);
+      put("cap", new THREE.ConeGeometry(2.8, h * 0.18, 8), x, h * 0.79, z);
+      rotors.push({ kind: "sail", n: 4, len: h * 0.55, hub: new THREE.Vector3(x + dx * 2.8, h * 0.72, z + dz * 2.8), speed: 0.5,
+        phase: (x * 0.017) % 6.28 });
+    } else if (m.k === "water_tower") {
+      const h = Math.max(15, Math.min(m.h, 50));
+      put("brick", new THREE.CylinderGeometry(3, 3.5, h * 0.75, 12), x, h * 0.375, z);
+      put("brick", new THREE.CylinderGeometry(7, 5, h * 0.25, 16), x, h * 0.875, z);
+    } else {
+      const h = Math.max(10, Math.min(m.h, 120));
+      put("white", new THREE.CylinderGeometry(1.5, 2.5, h, 8), x, h / 2, z);
+    }
+  }
+  const mats = {
+    white: new THREE.MeshLambertMaterial({ color: 0xf2f2f0 }),
+    body: new THREE.MeshLambertMaterial({ color: 0x4a4038, flatShading: true }),
+    cap: new THREE.MeshLambertMaterial({ color: 0x2f3a30, flatShading: true }),
+    brick: new THREE.MeshLambertMaterial({ color: 0x8c5a45, flatShading: true }),
+  };
+  for (const [k, list] of Object.entries(parts)) {
+    if (!list.length) continue;
+    const mesh = new THREE.Mesh(mergeGeometries(list), mats[k]);
+    mesh.castShadow = true;
+    group.add(mesh);
+  }
+  // one instanced mesh per rotor part; unit length along +y from the hub
+  const bladeGeo = new THREE.BoxGeometry(0.012, 1, 0.035);
+  bladeGeo.translate(0, 0.5, 0);
+  const sailGeo = mergeGeometries([new THREE.PlaneGeometry(0.004, 1).translate(0, 0.5, 0).toNonIndexed(),
+    new THREE.PlaneGeometry(0.075, 0.78).translate(0, 0.56, 0.035).toNonIndexed()]);
+  sailGeo.rotateY(Math.PI / 2);
+  const inst = {};
+  for (const [kind, geo, mat] of [["blade", bladeGeo, mats.white],
+    ["sail", sailGeo, new THREE.MeshLambertMaterial({ color: 0xe8e0d0, side: THREE.DoubleSide })]]) {
+    const count = rotors.filter((r) => r.kind === kind).reduce((a, r) => a + r.n, 0);
+    if (!count) continue;
+    const im = new THREE.InstancedMesh(geo, mat, count);
+    im.frustumCulled = false;
+    group.add(im);
+    inst[kind] = im;
+  }
+  group.userData = { rotors, inst, t: 0 };
+  setRotors(group, 0);
+  return group;
+}
+
+const _m = new THREE.Matrix4(), _r = new THREE.Matrix4(), _y = new THREE.Matrix4(), _s = new THREE.Matrix4();
+
+function setRotors(group, t) {
+  const { rotors, inst } = group.userData;
+  const idx = { blade: 0, sail: 0 };
+  _y.makeRotationY(0.6);
+  for (const r of rotors) {
+    const im = inst[r.kind];
+    for (let k = 0; k < r.n; k++) {
+      _r.makeRotationX(r.phase + t * r.speed + (k * 2 * Math.PI) / r.n);
+      _s.makeScale(r.len, r.len, r.len);
+      _m.makeTranslation(r.hub.x, r.hub.y, r.hub.z).multiply(_y).multiply(_r).multiply(_s);
+      im.setMatrixAt(idx[r.kind]++, _m);
+    }
+  }
+  for (const im of Object.values(inst)) im.instanceMatrix.needsUpdate = true;
+}
+
+export function animateWorld(root, dtReal) {
+  const lm = root.getObjectByName("landmarks");
+  if (!lm) return;
+  lm.userData.t += dtReal;
+  setRotors(lm, lm.userData.t);
+}

requirements.txt

@@ -0,0 +1,2 @@
+openenv==0.7.0
+fastmcp>=3,<4

runs/2026-10-08-glm-5-3-flash-eval45/index.json

@@ -0,0 +1,4831 @@
+{
+ "run": "2026-10-08-glm-5-3-flash-eval45",
+ "episodes": [
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-01-20-1800-180m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-01-20",
+   "runs": 24,
+   "reward": 0.066667,
+   "submitted": true,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 664,
+   "floor_cost": 539,
+   "greedy_cost": 2501,
+   "real_cost": 64,
+   "hardness": {
+    "runs": 24,
+    "sets": 6,
+    "stops": 147,
+    "conflicts": 11,
+    "single_track": 5,
+    "headway": 3,
+    "platforms": 0,
+    "closed": 3,
+    "decisions": 43,
+    "holds": 36,
+    "short_turns": 7,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 125,
+    "optimal": 664,
+    "greedy_gap": 0.7999,
+    "closed_min": 46,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": true,
+    "late_sets": 1
+   },
+   "violations": 24,
+   "agent_turns": 12,
+   "checks": 6,
+   "seconds": 3979.1,
+   "input_tokens": 3090635,
+   "cache_read_tokens": 2529856,
+   "cache_write_tokens": 0,
+   "output_tokens": 500205,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37466",
+     "to": "HDG"
+    },
+    {
+     "train": "37357",
+     "to": "HDG",
+     "hold": {
+      "FWD": "18:51"
+     }
+    },
+    {
+     "train": "37468",
+     "from": "HDG"
+    },
+    {
+     "train": "37459",
+     "hold": {
+      "FWD": "19:02"
+     }
+    },
+    {
+     "train": "37461",
+     "hold": {
+      "FWD": "19:05"
+     }
+    },
+    {
+     "train": "37359",
+     "to": "HDG",
+     "hold": {
+      "ZH": "18:40",
+      "BP": "19:02"
+     }
+    },
+    {
+     "train": "37470",
+     "from": "HDG"
+    },
+    {
+     "train": "37361",
+     "hold": {
+      "BP": "19:05",
+      "FWD": "19:15"
+     }
+    },
+    {
+     "train": "37472",
+     "hold": {
+      "LW": "19:31"
+     }
+    },
+    {
+     "train": "37463",
+     "from": "HDG",
+     "hold": {
+      "HDG": "19:37"
+     }
+    },
+    {
+     "train": "37465",
+     "hold": {
+      "GN": "19:38"
+     }
+    },
+    {
+     "train": "37467",
+     "hold": {
+      "GN": "20:07"
+     }
+    },
+    {
+     "train": "37374",
+     "hold": {
+      "LW": "20:26"
+     }
+    },
+    {
+     "train": "37376",
+     "hold": {
+      "LW": "20:30"
+     }
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-01-21-0626-180m-real-0",
+   "split": "eval",
+   "difficulty": "real",
+   "day": "2025-01-21",
+   "runs": 29,
+   "reward": 0.0,
+   "submitted": false,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 445,
+   "floor_cost": 356,
+   "greedy_cost": 1980,
+   "real_cost": 1308,
+   "hardness": {
+    "runs": 29,
+    "sets": 7,
+    "stops": 199,
+    "conflicts": 18,
+    "single_track": 14,
+    "headway": 4,
+    "platforms": 0,
+    "closed": 0,
+    "decisions": 21,
+    "holds": 17,
+    "short_turns": 4,
+    "cancels": 0,
+    "turn_points": 1,
+    "avoidable": 89,
+    "optimal": 445,
+    "greedy_gap": 0.8,
+    "closed_min": 0,
+    "slow_min": 69,
+    "track_min": 0,
+    "single_closed": false,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 4,
+   "checks": 2,
+   "seconds": 1782.2,
+   "input_tokens": 297014,
+   "cache_read_tokens": 69888,
+   "cache_write_tokens": 0,
+   "output_tokens": 192349,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "no_tool_call",
+   "errors": 0,
+   "plan": null
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-01-22-1600-240m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-01-22",
+   "runs": 38,
+   "reward": 0.0,
+   "submitted": false,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 670,
+   "floor_cost": 627,
+   "greedy_cost": 5661,
+   "real_cost": 112,
+   "hardness": {
+    "runs": 38,
+    "sets": 7,
+    "stops": 252,
+    "conflicts": 28,
+    "single_track": 7,
+    "headway": 10,
+    "platforms": 0,
+    "closed": 11,
+    "decisions": 24,
+    "holds": 18,
+    "short_turns": 6,
+    "cancels": 0,
+    "turn_points": 3,
+    "avoidable": 43,
+    "optimal": 670,
+    "greedy_gap": 0.8,
+    "closed_min": 36,
+    "slow_min": 33,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 4,
+   "checks": 1,
+   "seconds": 2084.4,
+   "input_tokens": 301096,
+   "cache_read_tokens": 144000,
+   "cache_write_tokens": 0,
+   "output_tokens": 192680,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "no_tool_call",
+   "errors": 0,
+   "plan": null
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-01-22-1800-150m-loop-0",
+   "split": "eval",
+   "difficulty": "loop",
+   "day": "2025-01-22",
+   "runs": 25,
+   "reward": 0.0,
+   "submitted": false,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 397,
+   "floor_cost": 336,
+   "greedy_cost": 562,
+   "real_cost": 79,
+   "hardness": {
+    "runs": 25,
+    "sets": 7,
+    "stops": 158,
+    "conflicts": 18,
+    "single_track": 18,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 0,
+    "decisions": 19,
+    "holds": 19,
+    "short_turns": 0,
+    "cancels": 0,
+    "turn_points": 0,
+    "avoidable": 61,
+    "optimal": 397,
+    "greedy_gap": 0.697,
+    "closed_min": 0,
+    "slow_min": 138,
+    "track_min": 10,
+    "single_closed": false,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 2,
+   "checks": 0,
+   "seconds": 1286.8,
+   "input_tokens": 74757,
+   "cache_read_tokens": 1600,
+   "cache_write_tokens": 0,
+   "output_tokens": 128000,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "no_tool_call",
+   "errors": 0,
+   "plan": null
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-01-23-0800-210m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-01-23",
+   "runs": 34,
+   "reward": 0.1,
+   "submitted": true,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 894,
+   "floor_cost": 841,
+   "greedy_cost": 4449,
+   "real_cost": 83,
+   "hardness": {
+    "runs": 34,
+    "sets": 7,
+    "stops": 226,
+    "conflicts": 51,
+    "single_track": 17,
+    "headway": 20,
+    "platforms": 0,
+    "closed": 14,
+    "decisions": 29,
+    "holds": 18,
+    "short_turns": 11,
+    "cancels": 0,
+    "turn_points": 3,
+    "avoidable": 53,
+    "optimal": 894,
+    "greedy_gap": 0.8,
+    "closed_min": 24,
+    "slow_min": 69,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 26,
+   "agent_turns": 12,
+   "checks": 8,
+   "seconds": 2844.5,
+   "input_tokens": 2416702,
+   "cache_read_tokens": 1687296,
+   "cache_write_tokens": 0,
+   "output_tokens": 350218,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "hold": {
+      "HDG": "08:01"
+     },
+     "train": "37426"
+    },
+    {
+     "hold": {
+      "FWD": "08:04"
+     },
+     "train": "37317"
+    },
+    {
+     "hold": {
+      "LWC": "08:44"
+     },
+     "to": "BP",
+     "train": "37328"
+    },
+    {
+     "hold": {
+      "LW": "08:44",
+      "LWC": "08:48",
+      "GK": "09:14"
+     },
+     "train": "37428"
+    },
+    {
+     "hold": {
+      "BP": "08:44",
+      "FWD": "08:55"
+     },
+     "train": "37419"
+    },
+    {
+     "hold": {
+      "BP": "08:48",
+      "FWD": "08:58"
+     },
+     "train": "37421"
+    },
+    {
+     "hold": {
+      "HDG": "09:25"
+     },
+     "train": "37319"
+    },
+    {
+     "hold": {
+      "GN": "08:45",
+      "FWD": "09:18",
+      "HDG": "09:22"
+     },
+     "train": "37321"
+    },
+    {
+     "hold": {
+      "FWD": "09:20"
+     },
+     "to": "ZH",
+     "train": "37330"
+    },
+    {
+     "hold": {
+      "ZH": "09:50",
+      "HDG": "10:15"
+     },
+     "train": "37425"
+    },
+    {
+     "hold": {
+      "LW": "09:35",
+      "GK": "10:01"
+     },
+     "to": "ZH",
+     "train": "37430"
+    },
+    {
+     "hold": {
+      "LW": "09:58"
+     },
+     "train": "37334"
+    },
+    {
+     "hold": {
+      "LW": "09:59"
+     },
+     "train": "37434"
+    },
+    {
+     "from": "ZH",
+     "hold": {
+      "ZH": "10:10"
+     },
+     "train": "37427"
+    },
+    {
+     "hold": {
+      "HDG": "09:44"
+     },
+     "train": "37423"
+    },
+    {
+     "from": "BP",
+     "hold": {
+      "BP": "09:30",
+      "HDG": "09:41"
+     },
+     "train": "37323"
+    },
+    {
+     "hold": {
+      "HDG": "09:40",
+      "GK": "10:04"
+     },
+     "train": "37432"
+    },
+    {
+     "hold": {
+      "GK": "10:52"
+     },
+     "train": "37336"
+    },
+    {
+     "hold": {
+      "HDG": "10:52"
+     },
+     "train": "37327"
+    },
+    {
+     "hold": {
+      "HDG": "11:11"
+     },
+     "train": "37429"
+    },
+    {
+     "hold": {
+      "FWD": "11:05"
+     },
+     "train": "37329"
+    },
+    {
+     "hold": {
+      "HDG": "11:36"
+     },
+     "train": "37431"
+    },
+    {
+     "hold": {
+      "FWD": "11:41"
+     },
+     "train": "37331"
+    },
+    {
+     "hold": {
+      "GN": "11:27"
+     },
+     "train": "37433"
+    },
+    {
+     "hold": {
+      "LW": "11:27",
+      "DWE": "11:44"
+     },
+     "train": "37440"
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-01-23-0900-180m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-01-23",
+   "runs": 30,
+   "reward": 0.236904,
+   "submitted": true,
+   "feasible": true,
+   "cost": 1236,
+   "optimal_cost": 853,
+   "floor_cost": 704,
+   "greedy_cost": 3025,
+   "real_cost": 61,
+   "hardness": {
+    "runs": 30,
+    "sets": 7,
+    "stops": 200,
+    "conflicts": 41,
+    "single_track": 29,
+    "headway": 5,
+    "platforms": 0,
+    "closed": 7,
+    "decisions": 31,
+    "holds": 17,
+    "short_turns": 14,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 149,
+    "optimal": 853,
+    "greedy_gap": 0.8,
+    "closed_min": 23,
+    "slow_min": 150,
+    "track_min": 10,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 12,
+   "checks": 7,
+   "seconds": 3393.6,
+   "input_tokens": 2461633,
+   "cache_read_tokens": 1489088,
+   "cache_write_tokens": 0,
+   "output_tokens": 345648,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "hold": {
+      "LWC": "09:28"
+     },
+     "train": "37421"
+    },
+    {
+     "to": "HDG",
+     "train": "37321"
+    },
+    {
+     "from": "HDG",
+     "train": "37432"
+    },
+    {
+     "hold": {
+      "FWD": "09:49"
+     },
+     "to": "HDG",
+     "train": "37323"
+    },
+    {
+     "hold": {
+      "LW": "09:40"
+     },
+     "to": "BP",
+     "train": "37332"
+    },
+    {
+     "from": "HDG",
+     "train": "37434"
+    },
+    {
+     "hold": {
+      "GN": "09:27"
+     },
+     "train": "37425"
+    },
+    {
+     "hold": {
+      "ZH": "09:57"
+     },
+     "train": "37325"
+    },
+    {
+     "hold": {
+      "GK": "10:47",
+      "LW": "10:24"
+     },
+     "train": "37336"
+    },
+    {
+     "hold": {
+      "FWD": "10:32",
+      "ZH": "10:11"
+     },
+     "train": "37427"
+    },
+    {
+     "hold": {
+      "HDG": "10:37"
+     },
+     "train": "37436"
+    },
+    {
+     "from": "BP",
+     "hold": {
+      "BP": "10:33"
+     },
+     "train": "37327"
+    },
+    {
+     "hold": {
+      "FWD": "11:05",
+      "GN": "10:27"
+     },
+     "train": "37429"
+    },
+    {
+     "hold": {
+      "GN": "10:43",
+      "ZH": "11:00"
+     },
+     "train": "37329"
+    },
+    {
+     "hold": {
+      "LW": "11:28"
+     },
+     "train": "37340"
+    },
+    {
+     "hold": {
+      "FWD": "11:31",
+      "HDG": "11:38",
+      "ZH": "11:11"
+     },
+     "train": "37431"
+    },
+    {
+     "hold": {
+      "GK": "12:00",
+      "HDG": "11:38",
+      "LW": "11:31"
+     },
+     "train": "37440"
+    },
+    {
+     "hold": {
+      "GK": "11:15",
+      "LW": "10:48",
+      "ZH": "11:20"
+     },
+     "train": "37338"
+    },
+    {
+     "hold": {
+      "GN": "11:16"
+     },
+     "train": "37331"
+    },
+    {
+     "hold": {
+      "FWD": "12:04"
+     },
+     "train": "37433"
+    },
+    {
+     "hold": {
+      "LW": "11:56"
+     },
+     "train": "37342"
+    },
+    {
+     "hold": {
+      "HDG": "12:07"
+     },
+     "train": "37442"
+    },
+    {
+     "hold": {
+      "ZH": "11:36"
+     },
+     "train": "37438"
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-01-25-0630-180m-loop-0",
+   "split": "eval",
+   "difficulty": "loop",
+   "day": "2025-01-25",
+   "runs": 20,
+   "reward": 1.0,
+   "submitted": true,
+   "feasible": true,
+   "cost": 116,
+   "optimal_cost": 116,
+   "floor_cost": 102,
+   "greedy_cost": 518,
+   "real_cost": 62,
+   "hardness": {
+    "runs": 20,
+    "sets": 7,
+    "stops": 150,
+    "conflicts": 3,
+    "single_track": 3,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 0,
+    "decisions": 23,
+    "holds": 23,
+    "short_turns": 0,
+    "cancels": 0,
+    "turn_points": 0,
+    "avoidable": 14,
+    "optimal": 116,
+    "greedy_gap": 0.7993,
+    "closed_min": 0,
+    "slow_min": 69,
+    "track_min": 10,
+    "single_closed": false,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 6,
+   "checks": 3,
+   "seconds": 1156.3,
+   "input_tokens": 426953,
+   "cache_read_tokens": 273536,
+   "cache_write_tokens": 0,
+   "output_tokens": 123383,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "hold": {
+      "ZH": "08:01"
+     },
+     "train": "37424"
+    },
+    {
+     "hold": {
+      "HDG": "08:03"
+     },
+     "train": "37426"
+    },
+    {
+     "hold": {
+      "HDG": "08:33"
+     },
+     "train": "37428"
+    },
+    {
+     "hold": {
+      "FWD": "08:36"
+     },
+     "train": "37319"
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-01-25-0730-180m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-01-25",
+   "runs": 26,
+   "reward": 0.259548,
+   "submitted": true,
+   "feasible": true,
+   "cost": 1541,
+   "optimal_cost": 1302,
+   "floor_cost": 1218,
+   "greedy_cost": null,
+   "real_cost": 129,
+   "hardness": {
+    "runs": 26,
+    "sets": 7,
+    "stops": 184,
+    "conflicts": 55,
+    "single_track": 10,
+    "headway": 19,
+    "platforms": 2,
+    "closed": 24,
+    "decisions": 26,
+    "holds": 11,
+    "short_turns": 15,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 84,
+    "optimal": 1302,
+    "greedy_gap": 0.8846,
+    "closed_min": 111,
+    "slow_min": 100,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 2
+   },
+   "violations": 0,
+   "agent_turns": 9,
+   "checks": 6,
+   "seconds": 1971.4,
+   "input_tokens": 1338672,
+   "cache_read_tokens": 812224,
+   "cache_write_tokens": 0,
+   "output_tokens": 230040,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37415",
+     "to": "HDG"
+    },
+    {
+     "train": "37417",
+     "to": "HDG"
+    },
+    {
+     "train": "37419",
+     "to": "HDG"
+    },
+    {
+     "train": "37319",
+     "to": "HDG",
+     "hold": {
+      "ZH": "08:44"
+     }
+    },
+    {
+     "train": "37421",
+     "to": "HDG",
+     "hold": {
+      "GN": "08:31",
+      "FWD": "09:09"
+     }
+    },
+    {
+     "train": "37321",
+     "to": "HDG",
+     "hold": {
+      "GN": "08:43"
+     }
+    },
+    {
+     "train": "37426",
+     "from": "HDG"
+    },
+    {
+     "train": "37328",
+     "from": "HDG"
+    },
+    {
+     "train": "37330",
+     "from": "HDG"
+    },
+    {
+     "train": "37430",
+     "from": "HDG",
+     "hold": {
+      "GK": "09:28"
+     }
+    },
+    {
+     "train": "37332",
+     "from": "HDG"
+    },
+    {
+     "train": "37432",
+     "from": "HDG"
+    },
+    {
+     "train": "37428",
+     "cancel": true
+    },
+    {
+     "train": "37425",
+     "cancel": true
+    },
+    {
+     "train": "37423",
+     "hold": {
+      "GN": "08:59"
+     }
+    },
+    {
+     "train": "37323",
+     "hold": {
+      "HDG": "09:43"
+     }
+    },
+    {
+     "train": "37325",
+     "hold": {
+      "GN": "09:45",
+      "ZH": "09:57"
+     }
+    },
+    {
+     "train": "37434",
+     "hold": {}
+    },
+    {
+     "train": "37336",
+     "hold": {
+      "LW": "10:23"
+     }
+    },
+    {
+     "train": "37427",
+     "hold": {
+      "HDG": "10:34"
+     }
+    },
+    {
+     "train": "37327",
+     "hold": {
+      "HDG": "10:38"
+     }
+    },
+    {
+     "train": "37436",
+     "hold": {
+      "HDG": "10:37"
+     }
+    },
+    {
+     "train": "37429",
+     "hold": {}
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-01-25-1700-180m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-01-25",
+   "runs": 30,
+   "reward": 0.375453,
+   "submitted": true,
+   "feasible": true,
+   "cost": 430,
+   "optimal_cost": 320,
+   "floor_cost": 275,
+   "greedy_cost": 1591,
+   "real_cost": 74,
+   "hardness": {
+    "runs": 30,
+    "sets": 7,
+    "stops": 200,
+    "conflicts": 11,
+    "single_track": 0,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 11,
+    "decisions": 51,
+    "holds": 49,
+    "short_turns": 2,
+    "cancels": 0,
+    "turn_points": 1,
+    "avoidable": 45,
+    "optimal": 320,
+    "greedy_gap": 0.8,
+    "closed_min": 15,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 12,
+   "checks": 8,
+   "seconds": 3447.9,
+   "input_tokens": 2693163,
+   "cache_read_tokens": 2104128,
+   "cache_write_tokens": 0,
+   "output_tokens": 320171,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37455",
+     "hold": {
+      "HDG": "17:45"
+     }
+    },
+    {
+     "train": "37364",
+     "hold": {
+      "DWE": "17:45"
+     }
+    },
+    {
+     "train": "37464",
+     "hold": {
+      "HDG": "17:45",
+      "GK": "18:05"
+     }
+    },
+    {
+     "train": "37355",
+     "to": "HDG",
+     "hold": {
+      "BP": "17:45"
+     }
+    },
+    {
+     "train": "37466",
+     "from": "HDG"
+    },
+    {
+     "train": "37457",
+     "hold": {
+      "BP": "17:48",
+      "FWD": "18:03"
+     }
+    },
+    {
+     "train": "37357",
+     "hold": {
+      "DWE": "18:02",
+      "FWD": "18:09"
+     }
+    },
+    {
+     "train": "37366",
+     "hold": {
+      "LW": "18:00",
+      "FWD": "18:16"
+     }
+    },
+    {
+     "train": "37368",
+     "hold": {
+      "LW": "18:20",
+      "HDG": "18:29"
+     }
+    },
+    {
+     "train": "37468",
+     "hold": {
+      "LW": "18:25",
+      "FWD": "18:39"
+     }
+    },
+    {
+     "train": "37459",
+     "hold": {
+      "HDG": "18:33"
+     }
+    },
+    {
+     "train": "37359",
+     "hold": {
+      "DWE": "18:36"
+     }
+    },
+    {
+     "train": "37370",
+     "hold": {
+      "LW": "18:48"
+     }
+    },
+    {
+     "train": "37461",
+     "hold": {
+      "FWD": "18:56"
+     }
+    },
+    {
+     "train": "37470",
+     "hold": {
+      "HDG": "19:00"
+     }
+    },
+    {
+     "train": "37463",
+     "hold": {
+      "GN": "18:56"
+     }
+    },
+    {
+     "train": "37363",
+     "hold": {
+      "FWD": "19:39"
+     }
+    },
+    {
+     "train": "37472",
+     "hold": {
+      "HDG": "19:30"
+     }
+    },
+    {
+     "train": "37465",
+     "hold": {
+      "FWD": "20:00"
+     }
+    },
+    {
+     "train": "37474",
+     "hold": {
+      "HDG": "20:03"
+     }
+    },
+    {
+     "train": "37374",
+     "hold": {
+      "LW": "19:47"
+     }
+    },
+    {
+     "train": "37365",
+     "hold": {
+      "FWD": "20:06"
+     }
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-01-26-1700-210m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-01-26",
+   "runs": 16,
+   "reward": 0.559463,
+   "submitted": true,
+   "feasible": true,
+   "cost": 670,
+   "optimal_cost": 618,
+   "floor_cost": 588,
+   "greedy_cost": 928,
+   "real_cost": 58,
+   "hardness": {
+    "runs": 16,
+    "sets": 3,
+    "stops": 104,
+    "conflicts": 10,
+    "single_track": 3,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 7,
+    "decisions": 21,
+    "holds": 12,
+    "short_turns": 9,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 30,
+    "optimal": 618,
+    "greedy_gap": 0.7932,
+    "closed_min": 104,
+    "slow_min": 100,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": true,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 6,
+   "checks": 4,
+   "seconds": 1264.8,
+   "input_tokens": 495339,
+   "cache_read_tokens": 354624,
+   "cache_write_tokens": 0,
+   "output_tokens": 139962,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37353",
+     "to": "HDG"
+    },
+    {
+     "train": "37364",
+     "from": "HDG"
+    },
+    {
+     "train": "37455",
+     "to": "HDG"
+    },
+    {
+     "train": "37466",
+     "from": "HDG"
+    },
+    {
+     "train": "37459",
+     "to": "HDG"
+    },
+    {
+     "train": "37470",
+     "from": "HDG"
+    },
+    {
+     "train": "37357",
+     "to": "HDG",
+     "hold": {
+      "GN": "17:46"
+     }
+    },
+    {
+     "train": "37368",
+     "from": "HDG"
+    },
+    {
+     "train": "37361",
+     "hold": {
+      "GN": "18:46"
+     }
+    },
+    {
+     "train": "37463",
+     "hold": {
+      "HDG": "19:36"
+     }
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-02-11-0900-150m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-02-11",
+   "runs": 23,
+   "reward": 1.0,
+   "submitted": true,
+   "feasible": true,
+   "cost": 725,
+   "optimal_cost": 725,
+   "floor_cost": 721,
+   "greedy_cost": null,
+   "real_cost": 318,
+   "hardness": {
+    "runs": 23,
+    "sets": 6,
+    "stops": 152,
+    "conflicts": 32,
+    "single_track": 3,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 29,
+    "decisions": 37,
+    "holds": 23,
+    "short_turns": 14,
+    "cancels": 0,
+    "turn_points": 1,
+    "avoidable": 4,
+    "optimal": 725,
+    "greedy_gap": 0.8174,
+    "closed_min": 120,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 4,
+   "checks": 2,
+   "seconds": 899.7,
+   "input_tokens": 242522,
+   "cache_read_tokens": 147520,
+   "cache_write_tokens": 0,
+   "output_tokens": 92904,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37421",
+     "to": "HDG"
+    },
+    {
+     "train": "37332",
+     "from": "HDG",
+     "hold": {
+      "HDG": "09:21"
+     }
+    },
+    {
+     "train": "37321",
+     "hold": {
+      "FWD": "09:07"
+     },
+     "to": "HDG"
+    },
+    {
+     "train": "37432",
+     "from": "HDG"
+    },
+    {
+     "train": "37428",
+     "hold": {
+      "ZH": "09:05"
+     }
+    },
+    {
+     "train": "37323",
+     "to": "HDG"
+    },
+    {
+     "train": "37434",
+     "from": "HDG"
+    },
+    {
+     "train": "37425",
+     "to": "HDG"
+    },
+    {
+     "train": "37336",
+     "from": "HDG",
+     "hold": {
+      "HDG": "10:21"
+     }
+    },
+    {
+     "train": "37325",
+     "to": "HDG"
+    },
+    {
+     "train": "37436",
+     "from": "HDG"
+    },
+    {
+     "train": "37427",
+     "to": "HDG"
+    },
+    {
+     "train": "37338",
+     "from": "HDG",
+     "hold": {
+      "HDG": "10:51"
+     }
+    },
+    {
+     "train": "37327",
+     "to": "HDG"
+    },
+    {
+     "train": "37438",
+     "from": "HDG"
+    },
+    {
+     "train": "37429",
+     "hold": {
+      "HDG": "11:10"
+     }
+    },
+    {
+     "train": "37340",
+     "hold": {
+      "LW": "11:23"
+     }
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-02-12-0900-180m-real-0",
+   "split": "eval",
+   "difficulty": "real",
+   "day": "2025-02-12",
+   "runs": 31,
+   "reward": 0.19375,
+   "submitted": true,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 643,
+   "floor_cost": 529,
+   "greedy_cost": null,
+   "real_cost": 363,
+   "hardness": {
+    "runs": 31,
+    "sets": 7,
+    "stops": 204,
+    "conflicts": 16,
+    "single_track": 8,
+    "headway": 3,
+    "platforms": 0,
+    "closed": 5,
+    "decisions": 38,
+    "holds": 32,
+    "short_turns": 6,
+    "cancels": 0,
+    "turn_points": 3,
+    "avoidable": 114,
+    "optimal": 643,
+    "greedy_gap": 0.8452,
+    "closed_min": 30,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": false,
+    "mid_line": true,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 12,
+   "checks": 8,
+   "seconds": 2686.2,
+   "input_tokens": 2649912,
+   "cache_read_tokens": 2186880,
+   "cache_write_tokens": 0,
+   "output_tokens": 344321,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "hold": {
+      "HDG": "09:05"
+     },
+     "train": "37421"
+    },
+    {
+     "hold": {
+      "GK": "09:02"
+     },
+     "train": "37328"
+    },
+    {
+     "hold": {
+      "BP": "09:29",
+      "ZH": "09:07"
+     },
+     "train": "37423"
+    },
+    {
+     "hold": {
+      "HDG": "09:44"
+     },
+     "train": "37323"
+    },
+    {
+     "hold": {
+      "DWE": "09:31"
+     },
+     "to": "HDG",
+     "train": "37321"
+    },
+    {
+     "from": "HDG",
+     "hold": {
+      "GK": "10:05",
+      "HDG": "09:44"
+     },
+     "train": "37432"
+    },
+    {
+     "hold": {
+      "FWD": "09:30"
+     },
+     "to": "ZH",
+     "train": "37330"
+    },
+    {
+     "from": "ZH",
+     "hold": {
+      "FWD": "10:11"
+     },
+     "train": "37325"
+    },
+    {
+     "hold": {
+      "FWD": "09:33",
+      "GK": "09:52"
+     },
+     "to": "ZH",
+     "train": "37430"
+    },
+    {
+     "from": "ZH",
+     "hold": {
+      "FWD": "10:29"
+     },
+     "train": "37427"
+    },
+    {
+     "hold": {
+      "BP": "09:47",
+      "FWD": "09:38",
+      "GK": "09:55",
+      "HDG": "09:29"
+     },
+     "train": "37332"
+    },
+    {
+     "hold": {
+      "LW": "09:52"
+     },
+     "train": "37334"
+    },
+    {
+     "hold": {
+      "GK": "10:21",
+      "LW": "09:55"
+     },
+     "train": "37434"
+    },
+    {
+     "hold": {
+      "FWD": "10:05"
+     },
+     "train": "37425"
+    },
+    {
+     "hold": {
+      "FWD": "10:29"
+     },
+     "from": "ZH",
+     "train": "37427"
+    },
+    {
+     "hold": {
+      "HDG": "10:32",
+      "LW": "10:23"
+     },
+     "train": "37436"
+    },
+    {
+     "hold": {
+      "FWD": "10:35"
+     },
+     "train": "37327"
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-02-13-0954-180m-real-0",
+   "split": "eval",
+   "difficulty": "real",
+   "day": "2025-02-13",
+   "runs": 30,
+   "reward": 0.484494,
+   "submitted": true,
+   "feasible": true,
+   "cost": 233,
+   "optimal_cost": 172,
+   "floor_cost": 154,
+   "greedy_cost": 1960,
+   "real_cost": 215,
+   "hardness": {
+    "runs": 30,
+    "sets": 7,
+    "stops": 195,
+    "conflicts": 13,
+    "single_track": 3,
+    "headway": 7,
+    "platforms": 3,
+    "closed": 0,
+    "decisions": 45,
+    "holds": 45,
+    "short_turns": 0,
+    "cancels": 0,
+    "turn_points": 0,
+    "avoidable": 18,
+    "optimal": 172,
+    "greedy_gap": 0.8,
+    "closed_min": 0,
+    "slow_min": 25,
+    "track_min": 0,
+    "single_closed": false,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 6,
+   "checks": 3,
+   "seconds": 1213.7,
+   "input_tokens": 599410,
+   "cache_read_tokens": 411200,
+   "cache_write_tokens": 0,
+   "output_tokens": 164361,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37334",
+     "hold": {
+      "GK": "10:19"
+     }
+    },
+    {
+     "train": "37327",
+     "hold": {
+      "GN": "10:20",
+      "FWD": "10:44"
+     }
+    },
+    {
+     "train": "37434",
+     "hold": {
+      "GK": "10:30"
+     }
+    },
+    {
+     "train": "37429",
+     "hold": {
+      "ZH": "10:35",
+      "HDG": "11:03"
+     }
+    },
+    {
+     "train": "37329",
+     "hold": {
+      "FWD": "11:06"
+     }
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-02-13-1530-180m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-02-13",
+   "runs": 30,
+   "reward": 0.0,
+   "submitted": false,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 648,
+   "floor_cost": 588,
+   "greedy_cost": 1690,
+   "real_cost": 151,
+   "hardness": {
+    "runs": 30,
+    "sets": 7,
+    "stops": 200,
+    "conflicts": 25,
+    "single_track": 5,
+    "headway": 5,
+    "platforms": 1,
+    "closed": 14,
+    "decisions": 37,
+    "holds": 29,
+    "short_turns": 8,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 60,
+    "optimal": 648,
+    "greedy_gap": 0.8,
+    "closed_min": 24,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 4,
+   "checks": 1,
+   "seconds": 1659.6,
+   "input_tokens": 289662,
+   "cache_read_tokens": 140032,
+   "cache_write_tokens": 0,
+   "output_tokens": 192312,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "no_tool_call",
+   "errors": 0,
+   "plan": null
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-02-14-1730-210m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-02-14",
+   "runs": 33,
+   "reward": 0.0,
+   "submitted": false,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 875,
+   "floor_cost": 776,
+   "greedy_cost": null,
+   "real_cost": 191,
+   "hardness": {
+    "runs": 33,
+    "sets": 7,
+    "stops": 208,
+    "conflicts": 33,
+    "single_track": 7,
+    "headway": 19,
+    "platforms": 3,
+    "closed": 4,
+    "decisions": 35,
+    "holds": 25,
+    "short_turns": 10,
+    "cancels": 0,
+    "turn_points": 3,
+    "avoidable": 99,
+    "optimal": 875,
+    "greedy_gap": 0.8909,
+    "closed_min": 38,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": false,
+    "mid_line": true,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 2,
+   "checks": 0,
+   "seconds": 1117.8,
+   "input_tokens": 76350,
+   "cache_read_tokens": 7680,
+   "cache_write_tokens": 0,
+   "output_tokens": 128000,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "no_tool_call",
+   "errors": 0,
+   "plan": null
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-02-15-0630-180m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-02-15",
+   "runs": 20,
+   "reward": 0.542968,
+   "submitted": true,
+   "feasible": true,
+   "cost": 2419,
+   "optimal_cost": 2300,
+   "floor_cost": 2119,
+   "greedy_cost": null,
+   "real_cost": 61,
+   "hardness": {
+    "runs": 20,
+    "sets": 7,
+    "stops": 150,
+    "conflicts": 45,
+    "single_track": 0,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 45,
+    "decisions": 31,
+    "holds": 13,
+    "short_turns": 18,
+    "cancels": 0,
+    "turn_points": 3,
+    "avoidable": 181,
+    "optimal": 2300,
+    "greedy_gap": 0.87,
+    "closed_min": 160,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": true,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 11,
+   "checks": 9,
+   "seconds": 2329.4,
+   "input_tokens": 1812928,
+   "cache_read_tokens": 1286016,
+   "cache_write_tokens": 0,
+   "output_tokens": 231905,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37420",
+     "to": "BP"
+    },
+    {
+     "train": "37417",
+     "from": "BP"
+    },
+    {
+     "train": "37422",
+     "to": "BP"
+    },
+    {
+     "train": "37419",
+     "from": "BP"
+    },
+    {
+     "train": "37328",
+     "to": "BP"
+    },
+    {
+     "train": "37323",
+     "from": "BP"
+    },
+    {
+     "train": "37413",
+     "to": "ZH"
+    },
+    {
+     "train": "37424",
+     "from": "ZH"
+    },
+    {
+     "train": "37421",
+     "to": "ZH",
+     "hold": {
+      "GN": "09:19"
+     }
+    },
+    {
+     "train": "37332",
+     "from": "ZH"
+    },
+    {
+     "train": "37415",
+     "to": "ZH"
+    },
+    {
+     "train": "37426",
+     "from": "ZH"
+    },
+    {
+     "train": "37423",
+     "hold": {
+      "ZH": "09:10"
+     }
+    },
+    {
+     "train": "37319",
+     "to": "ZH"
+    },
+    {
+     "train": "37430",
+     "from": "ZH",
+     "hold": {
+      "ZH": "09:30"
+     }
+    },
+    {
+     "train": "37428",
+     "hold": {
+      "BP": "09:10"
+     }
+    },
+    {
+     "train": "37330",
+     "hold": {
+      "FWD": "09:10"
+     }
+    },
+    {
+     "train": "37321",
+     "to": "ZH",
+     "hold": {
+      "GN": "09:40"
+     }
+    },
+    {
+     "train": "37432",
+     "from": "ZH"
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-02-15-0700-240m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-02-15",
+   "runs": 32,
+   "reward": 0.0,
+   "submitted": false,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 858,
+   "floor_cost": 785,
+   "greedy_cost": 2986,
+   "real_cost": 76,
+   "hardness": {
+    "runs": 32,
+    "sets": 7,
+    "stops": 228,
+    "conflicts": 38,
+    "single_track": 4,
+    "headway": 21,
+    "platforms": 3,
+    "closed": 10,
+    "decisions": 37,
+    "holds": 31,
+    "short_turns": 6,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 73,
+    "optimal": 858,
+    "greedy_gap": 0.8,
+    "closed_min": 34,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 2
+   },
+   "violations": 0,
+   "agent_turns": 4,
+   "checks": 1,
+   "seconds": 1677.9,
+   "input_tokens": 294512,
+   "cache_read_tokens": 143360,
+   "cache_write_tokens": 0,
+   "output_tokens": 192263,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "no_tool_call",
+   "errors": 0,
+   "plan": null
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-02-15-1630-150m-loop-0",
+   "split": "eval",
+   "difficulty": "loop",
+   "day": "2025-02-15",
+   "runs": 26,
+   "reward": 0.0,
+   "submitted": false,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 275,
+   "floor_cost": 234,
+   "greedy_cost": 1464,
+   "real_cost": 35,
+   "hardness": {
+    "runs": 26,
+    "sets": 7,
+    "stops": 174,
+    "conflicts": 10,
+    "single_track": 3,
+    "headway": 5,
+    "platforms": 2,
+    "closed": 0,
+    "decisions": 52,
+    "holds": 50,
+    "short_turns": 2,
+    "cancels": 0,
+    "turn_points": 1,
+    "avoidable": 41,
+    "optimal": 275,
+    "greedy_gap": 0.8,
+    "closed_min": 0,
+    "slow_min": 25,
+    "track_min": 140,
+    "single_closed": false,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 2,
+   "checks": 0,
+   "seconds": 926.2,
+   "input_tokens": 75109,
+   "cache_read_tokens": 1600,
+   "cache_write_tokens": 0,
+   "output_tokens": 128000,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "no_tool_call",
+   "errors": 0,
+   "plan": null
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-02-16-1530-210m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-02-16",
+   "runs": 18,
+   "reward": 0.200325,
+   "submitted": true,
+   "feasible": true,
+   "cost": 679,
+   "optimal_cost": 273,
+   "floor_cost": 269,
+   "greedy_cost": 2157,
+   "real_cost": 38,
+   "hardness": {
+    "runs": 18,
+    "sets": 3,
+    "stops": 122,
+    "conflicts": 5,
+    "single_track": 2,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 3,
+    "decisions": 9,
+    "holds": 5,
+    "short_turns": 4,
+    "cancels": 0,
+    "turn_points": 1,
+    "avoidable": 4,
+    "optimal": 273,
+    "greedy_gap": 0.8,
+    "closed_min": 21,
+    "slow_min": 80,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 6,
+   "checks": 3,
+   "seconds": 2070.3,
+   "input_tokens": 735585,
+   "cache_read_tokens": 520704,
+   "cache_write_tokens": 0,
+   "output_tokens": 202536,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37458",
+     "cancel": true
+    },
+    {
+     "train": "37353",
+     "cancel": true
+    },
+    {
+     "train": "37360",
+     "to": "BP",
+     "hold": {
+      "LW": "16:48"
+     }
+    },
+    {
+     "train": "37455",
+     "from": "BP",
+     "hold": {
+      "FWD": "17:28"
+     }
+    },
+    {
+     "train": "37349",
+     "hold": {
+      "FWD": "16:09"
+     }
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-02-16-1700-210m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-02-16",
+   "runs": 16,
+   "reward": 1.0,
+   "submitted": true,
+   "feasible": true,
+   "cost": 796,
+   "optimal_cost": 796,
+   "floor_cost": 787,
+   "greedy_cost": 1089,
+   "real_cost": 90,
+   "hardness": {
+    "runs": 16,
+    "sets": 3,
+    "stops": 104,
+    "conflicts": 31,
+    "single_track": 0,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 31,
+    "decisions": 13,
+    "holds": 6,
+    "short_turns": 6,
+    "cancels": 1,
+    "turn_points": 2,
+    "avoidable": 9,
+    "optimal": 796,
+    "greedy_gap": 0.7963,
+    "closed_min": 92,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 5,
+   "checks": 3,
+   "seconds": 1182.2,
+   "input_tokens": 347239,
+   "cache_read_tokens": 169152,
+   "cache_write_tokens": 0,
+   "output_tokens": 110263,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37455",
+     "to": "ZH"
+    },
+    {
+     "train": "37466",
+     "cancel": true
+    },
+    {
+     "train": "37361",
+     "from": "ZH",
+     "hold": {
+      "ZH": "18:42"
+     }
+    },
+    {
+     "train": "37462",
+     "to": "BP"
+    },
+    {
+     "train": "37357",
+     "from": "BP",
+     "hold": {
+      "BP": "17:56"
+     }
+    },
+    {
+     "train": "37368",
+     "hold": {
+      "BP": "18:43"
+     }
+    },
+    {
+     "train": "37364",
+     "to": "BP"
+    },
+    {
+     "train": "37459",
+     "from": "BP",
+     "hold": {
+      "BP": "18:18"
+     }
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-02-16-1730-240m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-02-16",
+   "runs": 19,
+   "reward": 0.776911,
+   "submitted": true,
+   "feasible": true,
+   "cost": 673,
+   "optimal_cost": 656,
+   "floor_cost": 652,
+   "greedy_cost": null,
+   "real_cost": 147,
+   "hardness": {
+    "runs": 19,
+    "sets": 3,
+    "stops": 126,
+    "conflicts": 14,
+    "single_track": 8,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 6,
+    "decisions": 21,
+    "holds": 11,
+    "short_turns": 10,
+    "cancels": 0,
+    "turn_points": 3,
+    "avoidable": 4,
+    "optimal": 656,
+    "greedy_gap": 0.9579,
+    "closed_min": 36,
+    "slow_min": 210,
+    "track_min": 235,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 7,
+   "checks": 4,
+   "seconds": 1892.2,
+   "input_tokens": 849411,
+   "cache_read_tokens": 632000,
+   "cache_write_tokens": 0,
+   "output_tokens": 199796,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37364",
+     "to": "ZH"
+    },
+    {
+     "train": "37459",
+     "from": "ZH"
+    },
+    {
+     "train": "37357",
+     "to": "ZH",
+     "hold": {
+      "GN": "18:16"
+     }
+    },
+    {
+     "train": "37368",
+     "from": "ZH"
+    },
+    {
+     "train": "37361",
+     "to": "HDG"
+    },
+    {
+     "train": "37372",
+     "from": "HDG"
+    },
+    {
+     "train": "37365",
+     "hold": {
+      "FWD": "20:11"
+     },
+     "to": "HDG"
+    },
+    {
+     "train": "37376",
+     "from": "HDG"
+    },
+    {
+     "train": "37369",
+     "hold": {
+      "FWD": "21:11"
+     },
+     "to": "HDG"
+    },
+    {
+     "train": "37380",
+     "from": "HDG"
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-03-10-0700-210m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-03-10",
+   "runs": 34,
+   "reward": 0.0,
+   "submitted": false,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 455,
+   "floor_cost": 386,
+   "greedy_cost": null,
+   "real_cost": 157,
+   "hardness": {
+    "runs": 34,
+    "sets": 7,
+    "stops": 226,
+    "conflicts": 17,
+    "single_track": 0,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 17,
+    "decisions": 32,
+    "holds": 26,
+    "short_turns": 6,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 69,
+    "optimal": 455,
+    "greedy_gap": 0.8294,
+    "closed_min": 23,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 2,
+   "checks": 0,
+   "seconds": 919.6,
+   "input_tokens": 76613,
+   "cache_read_tokens": 0,
+   "cache_write_tokens": 0,
+   "output_tokens": 128000,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "no_tool_call",
+   "errors": 0,
+   "plan": null
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-03-11-0730-150m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-03-11",
+   "runs": 26,
+   "reward": 0.0,
+   "submitted": false,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 2043,
+   "floor_cost": 1851,
+   "greedy_cost": null,
+   "real_cost": 201,
+   "hardness": {
+    "runs": 26,
+    "sets": 7,
+    "stops": 174,
+    "conflicts": 72,
+    "single_track": 0,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 72,
+    "decisions": 35,
+    "holds": 19,
+    "short_turns": 12,
+    "cancels": 4,
+    "turn_points": 2,
+    "avoidable": 192,
+    "optimal": 2043,
+    "greedy_gap": 0.9,
+    "closed_min": 130,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 2,
+   "checks": 0,
+   "seconds": 1157.3,
+   "input_tokens": 74967,
+   "cache_read_tokens": 6976,
+   "cache_write_tokens": 0,
+   "output_tokens": 128000,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "no_tool_call",
+   "errors": 0,
+   "plan": null
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-03-12-1530-180m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-03-12",
+   "runs": 30,
+   "reward": 0.0,
+   "submitted": false,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 806,
+   "floor_cost": 730,
+   "greedy_cost": 1632,
+   "real_cost": 98,
+   "hardness": {
+    "runs": 30,
+    "sets": 7,
+    "stops": 200,
+    "conflicts": 31,
+    "single_track": 0,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 31,
+    "decisions": 36,
+    "holds": 28,
+    "short_turns": 8,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 76,
+    "optimal": 806,
+    "greedy_gap": 0.7999,
+    "closed_min": 25,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 5,
+   "checks": 2,
+   "seconds": 2063.0,
+   "input_tokens": 422539,
+   "cache_read_tokens": 151744,
+   "cache_write_tokens": 0,
+   "output_tokens": 216391,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "no_tool_call",
+   "errors": 0,
+   "plan": null
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-03-12-1730-210m-loop-0",
+   "split": "eval",
+   "difficulty": "loop",
+   "day": "2025-03-12",
+   "runs": 33,
+   "reward": 0.0,
+   "submitted": false,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 166,
+   "floor_cost": 158,
+   "greedy_cost": 826,
+   "real_cost": 64,
+   "hardness": {
+    "runs": 33,
+    "sets": 7,
+    "stops": 208,
+    "conflicts": 11,
+    "single_track": 2,
+    "headway": 8,
+    "platforms": 1,
+    "closed": 0,
+    "decisions": 35,
+    "holds": 33,
+    "short_turns": 2,
+    "cancels": 0,
+    "turn_points": 1,
+    "avoidable": 8,
+    "optimal": 166,
+    "greedy_gap": 0.8,
+    "closed_min": 0,
+    "slow_min": 0,
+    "track_min": 10,
+    "single_closed": false,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 4,
+   "checks": 1,
+   "seconds": 1521.3,
+   "input_tokens": 289611,
+   "cache_read_tokens": 134400,
+   "cache_write_tokens": 0,
+   "output_tokens": 192468,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "no_tool_call",
+   "errors": 0,
+   "plan": null
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-03-13-0706-180m-real-0",
+   "split": "eval",
+   "difficulty": "real",
+   "day": "2025-03-13",
+   "runs": 26,
+   "reward": 1.0,
+   "submitted": true,
+   "feasible": true,
+   "cost": 378,
+   "optimal_cost": 378,
+   "floor_cost": 378,
+   "greedy_cost": null,
+   "real_cost": 554,
+   "hardness": {
+    "runs": 26,
+    "sets": 6,
+    "stops": 177,
+    "conflicts": 18,
+    "single_track": 1,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 17,
+    "decisions": 27,
+    "holds": 19,
+    "short_turns": 8,
+    "cancels": 0,
+    "turn_points": 1,
+    "avoidable": 0,
+    "optimal": 378,
+    "greedy_gap": 0.8077,
+    "closed_min": 59,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 6,
+   "checks": 4,
+   "seconds": 899.1,
+   "input_tokens": 404098,
+   "cache_read_tokens": 217088,
+   "cache_write_tokens": 0,
+   "output_tokens": 89748,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37413",
+     "to": "HDG"
+    },
+    {
+     "train": "37324",
+     "from": "HDG",
+     "hold": {
+      "HDG": "07:22"
+     }
+    },
+    {
+     "train": "37313",
+     "to": "HDG"
+    },
+    {
+     "train": "37424",
+     "from": "HDG",
+     "hold": {
+      "HDG": "07:29"
+     }
+    },
+    {
+     "train": "37415",
+     "to": "HDG"
+    },
+    {
+     "train": "37326",
+     "from": "HDG",
+     "hold": {
+      "HDG": "07:52"
+     }
+    },
+    {
+     "train": "37315",
+     "to": "HDG"
+    },
+    {
+     "train": "37426",
+     "from": "HDG",
+     "hold": {
+      "HDG": "07:59"
+     }
+    },
+    {
+     "train": "37417",
+     "hold": {
+      "HDG": "08:00"
+     }
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-03-16-1630-180m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-03-16",
+   "runs": 15,
+   "reward": 1.0,
+   "submitted": true,
+   "feasible": true,
+   "cost": 1259,
+   "optimal_cost": 1259,
+   "floor_cost": 1256,
+   "greedy_cost": null,
+   "real_cost": 73,
+   "hardness": {
+    "runs": 15,
+    "sets": 3,
+    "stops": 100,
+    "conflicts": 53,
+    "single_track": 3,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 50,
+    "decisions": 15,
+    "holds": 3,
+    "short_turns": 10,
+    "cancels": 2,
+    "turn_points": 2,
+    "avoidable": 3,
+    "optimal": 1259,
+    "greedy_gap": 0.8533,
+    "closed_min": 149,
+    "slow_min": 95,
+    "track_min": 31,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 4,
+   "checks": 2,
+   "seconds": 835.2,
+   "input_tokens": 230449,
+   "cache_read_tokens": 139008,
+   "cache_write_tokens": 0,
+   "output_tokens": 91920,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37360",
+     "to": "BP"
+    },
+    {
+     "train": "37455",
+     "from": "BP"
+    },
+    {
+     "train": "37466",
+     "to": "BP"
+    },
+    {
+     "train": "37361",
+     "from": "BP"
+    },
+    {
+     "train": "37462",
+     "to": "BP"
+    },
+    {
+     "train": "37357",
+     "from": "BP",
+     "hold": {
+      "FWD": "18:05"
+     }
+    },
+    {
+     "train": "37368",
+     "to": "BP"
+    },
+    {
+     "train": "37463",
+     "from": "BP"
+    },
+    {
+     "train": "37353",
+     "to": "ZH"
+    },
+    {
+     "train": "37364",
+     "cancel": true
+    },
+    {
+     "train": "37459",
+     "cancel": true
+    },
+    {
+     "train": "37470",
+     "from": "ZH"
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-03-16-1700-210m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-03-16",
+   "runs": 16,
+   "reward": 0.0,
+   "submitted": false,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 529,
+   "floor_cost": 529,
+   "greedy_cost": 2995,
+   "real_cost": 86,
+   "hardness": {
+    "runs": 16,
+    "sets": 3,
+    "stops": 104,
+    "conflicts": 13,
+    "single_track": 8,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 5,
+    "decisions": 20,
+    "holds": 12,
+    "short_turns": 8,
+    "cancels": 0,
+    "turn_points": 1,
+    "avoidable": 0,
+    "optimal": 529,
+    "greedy_gap": 0.8,
+    "closed_min": 35,
+    "slow_min": 210,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 4,
+   "checks": 1,
+   "seconds": 1760.8,
+   "input_tokens": 278022,
+   "cache_read_tokens": 69696,
+   "cache_write_tokens": 0,
+   "output_tokens": 192030,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "no_tool_call",
+   "errors": 0,
+   "plan": null
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-04-23-1630-150m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-04-23",
+   "runs": 26,
+   "reward": 0.0,
+   "submitted": false,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 1926,
+   "floor_cost": 1782,
+   "greedy_cost": null,
+   "real_cost": 40,
+   "hardness": {
+    "runs": 26,
+    "sets": 7,
+    "stops": 174,
+    "conflicts": 18,
+    "single_track": 0,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 18,
+    "decisions": 26,
+    "holds": 12,
+    "short_turns": 14,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 144,
+    "optimal": 1926,
+    "greedy_gap": 0.8385,
+    "closed_min": 120,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": true,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 2,
+   "checks": 0,
+   "seconds": 1484.8,
+   "input_tokens": 74971,
+   "cache_read_tokens": 0,
+   "cache_write_tokens": 0,
+   "output_tokens": 128000,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "no_tool_call",
+   "errors": 0,
+   "plan": null
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-04-25-1730-210m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-04-25",
+   "runs": 33,
+   "reward": 0.212973,
+   "submitted": true,
+   "feasible": true,
+   "cost": 1607,
+   "optimal_cost": 1370,
+   "floor_cost": 1355,
+   "greedy_cost": null,
+   "real_cost": 51,
+   "hardness": {
+    "runs": 33,
+    "sets": 7,
+    "stops": 208,
+    "conflicts": 33,
+    "single_track": 5,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 28,
+    "decisions": 25,
+    "holds": 11,
+    "short_turns": 14,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 15,
+    "optimal": 1370,
+    "greedy_gap": 0.8424,
+    "closed_min": 66,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": true,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 7,
+   "checks": 4,
+   "seconds": 1667.7,
+   "input_tokens": 833434,
+   "cache_read_tokens": 601536,
+   "cache_write_tokens": 0,
+   "output_tokens": 214284,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37457",
+     "hold": {
+      "GK": "18:46"
+     },
+     "to": "BP"
+    },
+    {
+     "train": "37368",
+     "cancel": true
+    },
+    {
+     "train": "37364",
+     "to": "BP"
+    },
+    {
+     "train": "37359",
+     "from": "BP"
+    },
+    {
+     "train": "37357",
+     "to": "ZH"
+    },
+    {
+     "train": "37468",
+     "from": "ZH"
+    },
+    {
+     "train": "37459",
+     "to": "ZH"
+    },
+    {
+     "train": "37370",
+     "from": "ZH"
+    },
+    {
+     "train": "37366",
+     "to": "BP",
+     "hold": {
+      "FWD": "18:22"
+     }
+    },
+    {
+     "train": "37361",
+     "from": "BP"
+    },
+    {
+     "train": "37466",
+     "to": "BP",
+     "hold": {
+      "FWD": "18:50"
+     }
+    },
+    {
+     "train": "37463",
+     "from": "BP"
+    },
+    {
+     "train": "37464",
+     "to": "BP"
+    },
+    {
+     "train": "37461",
+     "from": "BP"
+    },
+    {
+     "train": "37363",
+     "from": "BP"
+    },
+    {
+     "train": "37470",
+     "hold": {
+      "DWE": "19:11"
+     }
+    },
+    {
+     "train": "37467",
+     "hold": {
+      "FWD": "20:26"
+     }
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-04-26-0630-180m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-04-26",
+   "runs": 20,
+   "reward": 0.200353,
+   "submitted": true,
+   "feasible": true,
+   "cost": 1692,
+   "optimal_cost": 1047,
+   "floor_cost": 980,
+   "greedy_cost": 3569,
+   "real_cost": 88,
+   "hardness": {
+    "runs": 20,
+    "sets": 7,
+    "stops": 150,
+    "conflicts": 35,
+    "single_track": 9,
+    "headway": 19,
+    "platforms": 1,
+    "closed": 6,
+    "decisions": 38,
+    "holds": 30,
+    "short_turns": 8,
+    "cancels": 0,
+    "turn_points": 3,
+    "avoidable": 67,
+    "optimal": 1047,
+    "greedy_gap": 0.8,
+    "closed_min": 59,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 10,
+   "checks": 7,
+   "seconds": 2400.5,
+   "input_tokens": 1567517,
+   "cache_read_tokens": 926144,
+   "cache_write_tokens": 0,
+   "output_tokens": 221777,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "hold": {
+      "HDG": "07:36"
+     },
+     "train": "37413"
+    },
+    {
+     "hold": {
+      "FWD": "07:34",
+      "HDG": "07:39"
+     },
+     "train": "37415"
+    },
+    {
+     "hold": {
+      "LW": "07:29",
+      "HDG": "07:37"
+     },
+     "train": "37422"
+    },
+    {
+     "to": "BP",
+     "train": "37420"
+    },
+    {
+     "from": "BP",
+     "hold": {
+      "FWD": "07:58"
+     },
+     "train": "37417"
+    },
+    {
+     "hold": {
+      "LW": "07:48"
+     },
+     "train": "37424"
+    },
+    {
+     "hold": {
+      "LW": "07:51",
+      "HDG": "08:01",
+      "GK": "08:24"
+     },
+     "train": "37426"
+    },
+    {
+     "hold": {
+      "GN": "08:12"
+     },
+     "train": "37419"
+    },
+    {
+     "hold": {
+      "GN": "08:32"
+     },
+     "train": "37421"
+    },
+    {
+     "hold": {
+      "LW": "08:17",
+      "GK": "08:49"
+     },
+     "train": "37328"
+    },
+    {
+     "hold": {
+      "GK": "08:53"
+     },
+     "train": "37428"
+    },
+    {
+     "hold": {
+      "GN": "08:29"
+     },
+     "train": "37319"
+    },
+    {
+     "hold": {
+      "LW": "09:14"
+     },
+     "train": "37430"
+    },
+    {
+     "hold": {
+      "LW": "09:18",
+      "HDG": "09:25",
+      "FWD": "09:27",
+      "DWE": "09:30",
+      "BP": "09:35",
+      "GK": "09:44",
+      "ZH": "09:47"
+     },
+     "train": "37330"
+    },
+    {
+     "hold": {
+      "LW": "09:23",
+      "BP": "09:40",
+      "GK": "09:47",
+      "ZH": "09:51"
+     },
+     "train": "37332"
+    },
+    {
+     "hold": {
+      "LW": "09:26",
+      "HDG": "09:37",
+      "ZH": "10:01"
+     },
+     "train": "37432"
+    },
+    {
+     "hold": {
+      "ZH": "09:08",
+      "FWD": "09:31"
+     },
+     "train": "37423"
+    },
+    {
+     "hold": {
+      "FWD": "09:35",
+      "LWC": "09:42"
+     },
+     "train": "37323"
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-04-26-1700-180m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-04-26",
+   "runs": 30,
+   "reward": 0.0,
+   "submitted": false,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 447,
+   "floor_cost": 433,
+   "greedy_cost": 2402,
+   "real_cost": 59,
+   "hardness": {
+    "runs": 30,
+    "sets": 7,
+    "stops": 200,
+    "conflicts": 10,
+    "single_track": 0,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 10,
+    "decisions": 31,
+    "holds": 25,
+    "short_turns": 6,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 14,
+    "optimal": 447,
+    "greedy_gap": 0.8,
+    "closed_min": 36,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 9,
+   "checks": 4,
+   "seconds": 3456.6,
+   "input_tokens": 1424299,
+   "cache_read_tokens": 663424,
+   "cache_write_tokens": 0,
+   "output_tokens": 358778,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "no_tool_call",
+   "errors": 0,
+   "plan": null
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-04-27-0800-210m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-04-27",
+   "runs": 15,
+   "reward": 0.847471,
+   "submitted": true,
+   "feasible": true,
+   "cost": 393,
+   "optimal_cost": 382,
+   "floor_cost": 378,
+   "greedy_cost": 1155,
+   "real_cost": 39,
+   "hardness": {
+    "runs": 15,
+    "sets": 3,
+    "stops": 100,
+    "conflicts": 20,
+    "single_track": 3,
+    "headway": 14,
+    "platforms": 0,
+    "closed": 3,
+    "decisions": 20,
+    "holds": 16,
+    "short_turns": 4,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 4,
+    "optimal": 382,
+    "greedy_gap": 0.8,
+    "closed_min": 36,
+    "slow_min": 80,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 4,
+   "checks": 2,
+   "seconds": 1169.0,
+   "input_tokens": 258427,
+   "cache_read_tokens": 132288,
+   "cache_write_tokens": 0,
+   "output_tokens": 127858,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37426",
+     "to": "ZH"
+    },
+    {
+     "train": "37321",
+     "from": "ZH",
+     "hold": {
+      "FWD": "09:05"
+     }
+    },
+    {
+     "train": "37328",
+     "to": "BP"
+    },
+    {
+     "train": "37423",
+     "from": "BP",
+     "hold": {
+      "FWD": "09:33"
+     }
+    },
+    {
+     "train": "37325",
+     "hold": {
+      "GN": "09:43"
+     }
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-04-27-0830-210m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-04-27",
+   "runs": 18,
+   "reward": 0.314963,
+   "submitted": true,
+   "feasible": true,
+   "cost": 1380,
+   "optimal_cost": 1283,
+   "floor_cost": 1283,
+   "greedy_cost": 1624,
+   "real_cost": 45,
+   "hardness": {
+    "runs": 18,
+    "sets": 3,
+    "stops": 122,
+    "conflicts": 10,
+    "single_track": 0,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 10,
+    "decisions": 15,
+    "holds": 3,
+    "short_turns": 12,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 0,
+    "optimal": 1283,
+    "greedy_gap": 0.7991,
+    "closed_min": 157,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": false,
+    "mid_line": true,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 3,
+   "checks": 1,
+   "seconds": 661.3,
+   "input_tokens": 142460,
+   "cache_read_tokens": 69824,
+   "cache_write_tokens": 0,
+   "output_tokens": 67383,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37430",
+     "to": "HDG"
+    },
+    {
+     "train": "37325",
+     "from": "HDG"
+    },
+    {
+     "train": "37336",
+     "to": "HDG"
+    },
+    {
+     "train": "37431",
+     "from": "HDG"
+    },
+    {
+     "train": "37321",
+     "to": "BP"
+    },
+    {
+     "train": "37332",
+     "from": "BP"
+    },
+    {
+     "train": "37427",
+     "to": "BP"
+    },
+    {
+     "train": "37438",
+     "from": "BP"
+    },
+    {
+     "train": "37423",
+     "to": "BP"
+    },
+    {
+     "train": "37434",
+     "from": "BP"
+    },
+    {
+     "train": "37329",
+     "to": "BP"
+    },
+    {
+     "train": "37340",
+     "from": "BP"
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-05-26-0730-150m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-05-26",
+   "runs": 26,
+   "reward": 0.971174,
+   "submitted": true,
+   "feasible": true,
+   "cost": 859,
+   "optimal_cost": 857,
+   "floor_cost": 848,
+   "greedy_cost": null,
+   "real_cost": 165,
+   "hardness": {
+    "runs": 26,
+    "sets": 7,
+    "stops": 174,
+    "conflicts": 24,
+    "single_track": 3,
+    "headway": 4,
+    "platforms": 0,
+    "closed": 17,
+    "decisions": 32,
+    "holds": 14,
+    "short_turns": 18,
+    "cancels": 0,
+    "turn_points": 1,
+    "avoidable": 9,
+    "optimal": 857,
+    "greedy_gap": 0.8231,
+    "closed_min": 130,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 4,
+   "checks": 1,
+   "seconds": 698.6,
+   "input_tokens": 164449,
+   "cache_read_tokens": 79360,
+   "cache_write_tokens": 0,
+   "output_tokens": 72465,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37315",
+     "to": "HDG"
+    },
+    {
+     "train": "37426",
+     "from": "HDG"
+    },
+    {
+     "train": "37417",
+     "to": "HDG"
+    },
+    {
+     "train": "37328",
+     "from": "HDG"
+    },
+    {
+     "train": "37317",
+     "to": "HDG"
+    },
+    {
+     "train": "37428",
+     "from": "HDG"
+    },
+    {
+     "train": "37419",
+     "hold": {
+      "GN": "07:57"
+     },
+     "to": "HDG"
+    },
+    {
+     "train": "37330",
+     "from": "HDG"
+    },
+    {
+     "train": "37421",
+     "to": "HDG"
+    },
+    {
+     "train": "37332",
+     "from": "HDG"
+    },
+    {
+     "train": "37321",
+     "to": "HDG"
+    },
+    {
+     "train": "37432",
+     "from": "HDG"
+    },
+    {
+     "train": "37319",
+     "to": "HDG"
+    },
+    {
+     "train": "37430",
+     "from": "HDG"
+    },
+    {
+     "train": "37423",
+     "to": "HDG"
+    },
+    {
+     "train": "37334",
+     "from": "HDG"
+    },
+    {
+     "train": "37323",
+     "to": "HDG"
+    },
+    {
+     "train": "37434",
+     "from": "HDG"
+    },
+    {
+     "train": "37326",
+     "hold": {
+      "GK": "08:09"
+     }
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-05-26-1630-150m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-05-26",
+   "runs": 26,
+   "reward": 0.722475,
+   "submitted": true,
+   "feasible": true,
+   "cost": 290,
+   "optimal_cost": 254,
+   "floor_cost": 185,
+   "greedy_cost": null,
+   "real_cost": 55,
+   "hardness": {
+    "runs": 26,
+    "sets": 7,
+    "stops": 174,
+    "conflicts": 8,
+    "single_track": 0,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 8,
+    "decisions": 27,
+    "holds": 25,
+    "short_turns": 2,
+    "cancels": 0,
+    "turn_points": 1,
+    "avoidable": 69,
+    "optimal": 254,
+    "greedy_gap": 0.8,
+    "closed_min": 10,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 8,
+   "checks": 5,
+   "seconds": 2191.8,
+   "input_tokens": 1088436,
+   "cache_read_tokens": 744512,
+   "cache_write_tokens": 0,
+   "output_tokens": 233550,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37460",
+     "hold": {
+      "BP": "17:00"
+     }
+    },
+    {
+     "train": "37360",
+     "hold": {
+      "ZH": "17:00"
+     }
+    },
+    {
+     "train": "37353",
+     "hold": {
+      "ZH": "17:00"
+     }
+    },
+    {
+     "train": "37362",
+     "hold": {
+      "FWD": "17:03",
+      "ZH": "17:20"
+     }
+    },
+    {
+     "train": "37462",
+     "hold": {
+      "FWD": "17:06"
+     }
+    },
+    {
+     "train": "37455",
+     "hold": {
+      "GN": "17:00",
+      "ZH": "17:12",
+      "FWD": "17:34"
+     }
+    },
+    {
+     "train": "37355",
+     "hold": {
+      "FWD": "17:40"
+     }
+    },
+    {
+     "train": "37364",
+     "hold": {
+      "LW": "17:26"
+     }
+    },
+    {
+     "train": "37357",
+     "hold": {
+      "ZH": "17:51"
+     }
+    },
+    {
+     "train": "37368",
+     "hold": {
+      "LW": "18:17"
+     }
+    },
+    {
+     "train": "37457",
+     "hold": {
+      "FWD": "17:57"
+     }
+    },
+    {
+     "train": "37466",
+     "hold": {
+      "HDG": "18:00"
+     }
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-05-26-1800-150m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-05-26",
+   "runs": 25,
+   "reward": 0.957344,
+   "submitted": true,
+   "feasible": true,
+   "cost": 1018,
+   "optimal_cost": 1014,
+   "floor_cost": 968,
+   "greedy_cost": null,
+   "real_cost": 41,
+   "hardness": {
+    "runs": 25,
+    "sets": 7,
+    "stops": 158,
+    "conflicts": 17,
+    "single_track": 0,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 17,
+    "decisions": 31,
+    "holds": 17,
+    "short_turns": 12,
+    "cancels": 2,
+    "turn_points": 1,
+    "avoidable": 46,
+    "optimal": 1014,
+    "greedy_gap": 0.824,
+    "closed_min": 130,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": true,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 6,
+   "checks": 4,
+   "seconds": 1307.8,
+   "input_tokens": 506659,
+   "cache_read_tokens": 369152,
+   "cache_write_tokens": 0,
+   "output_tokens": 136057,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37357",
+     "to": "HDG"
+    },
+    {
+     "train": "37459",
+     "to": "HDG"
+    },
+    {
+     "train": "37359",
+     "to": "HDG"
+    },
+    {
+     "train": "37461",
+     "to": "HDG"
+    },
+    {
+     "train": "37361",
+     "to": "HDG"
+    },
+    {
+     "train": "37463",
+     "to": "HDG"
+    },
+    {
+     "train": "37465",
+     "to": "HDG"
+    },
+    {
+     "train": "37468",
+     "from": "HDG",
+     "hold": {
+      "HDG": "18:29"
+     }
+    },
+    {
+     "train": "37370",
+     "from": "HDG",
+     "hold": {
+      "HDG": "18:51"
+     }
+    },
+    {
+     "train": "37470",
+     "from": "HDG",
+     "hold": {
+      "HDG": "18:59"
+     }
+    },
+    {
+     "train": "37372",
+     "from": "HDG",
+     "hold": {
+      "HDG": "19:21"
+     }
+    },
+    {
+     "train": "37472",
+     "from": "HDG",
+     "hold": {
+      "HDG": "19:29"
+     }
+    },
+    {
+     "train": "37374",
+     "from": "HDG",
+     "hold": {
+      "HDG": "19:51"
+     }
+    },
+    {
+     "train": "37376",
+     "from": "HDG",
+     "hold": {
+      "HDG": "20:24",
+      "GK": "20:41"
+     }
+    },
+    {
+     "train": "37467",
+     "hold": {
+      "FWD": "20:27"
+     }
+    },
+    {
+     "train": "37365",
+     "hold": {
+      "FWD": "20:22"
+     }
+    },
+    {
+     "train": "37474",
+     "hold": {
+      "LWC": "20:15"
+     }
+    },
+    {
+     "train": "37368",
+     "cancel": true
+    },
+    {
+     "train": "37363",
+     "cancel": true
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-05-27-0830-210m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-05-27",
+   "runs": 34,
+   "reward": 0.204715,
+   "submitted": true,
+   "feasible": true,
+   "cost": 1121,
+   "optimal_cost": 795,
+   "floor_cost": 768,
+   "greedy_cost": null,
+   "real_cost": 285,
+   "hardness": {
+    "runs": 34,
+    "sets": 7,
+    "stops": 226,
+    "conflicts": 28,
+    "single_track": 1,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 27,
+    "decisions": 44,
+    "holds": 30,
+    "short_turns": 12,
+    "cancels": 2,
+    "turn_points": 1,
+    "avoidable": 27,
+    "optimal": 795,
+    "greedy_gap": 0.8529,
+    "closed_min": 98,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 5,
+   "checks": 3,
+   "seconds": 1610.8,
+   "input_tokens": 428158,
+   "cache_read_tokens": 264576,
+   "cache_write_tokens": 0,
+   "output_tokens": 170879,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "hold": {
+      "HDG": "08:32"
+     },
+     "to": "ZH",
+     "train": "37428"
+    },
+    {
+     "from": "ZH",
+     "train": "37425"
+    },
+    {
+     "hold": {
+      "FWD": "08:35"
+     },
+     "train": "37319"
+    },
+    {
+     "hold": {
+      "BP": "08:36"
+     },
+     "train": "37328"
+    },
+    {
+     "hold": {
+      "BP": "09:29"
+     },
+     "to": "ZH",
+     "train": "37330"
+    },
+    {
+     "from": "ZH",
+     "train": "37325"
+    },
+    {
+     "to": "ZH",
+     "train": "37430"
+    },
+    {
+     "from": "ZH",
+     "train": "37427"
+    },
+    {
+     "hold": {
+      "BP": "10:01"
+     },
+     "to": "ZH",
+     "train": "37332"
+    },
+    {
+     "from": "ZH",
+     "train": "37327"
+    },
+    {
+     "to": "ZH",
+     "train": "37432"
+    },
+    {
+     "from": "ZH",
+     "train": "37429"
+    },
+    {
+     "cancel": true,
+     "train": "37423"
+    },
+    {
+     "cancel": true,
+     "train": "37334"
+    },
+    {
+     "cancel": true,
+     "train": "37323"
+    },
+    {
+     "cancel": true,
+     "train": "37434"
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-05-27-1700-180m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-05-27",
+   "runs": 30,
+   "reward": 0.06,
+   "submitted": true,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 791,
+   "floor_cost": 670,
+   "greedy_cost": null,
+   "real_cost": 253,
+   "hardness": {
+    "runs": 30,
+    "sets": 7,
+    "stops": 200,
+    "conflicts": 17,
+    "single_track": 0,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 17,
+    "decisions": 27,
+    "holds": 21,
+    "short_turns": 6,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 121,
+    "optimal": 791,
+    "greedy_gap": 0.8467,
+    "closed_min": 35,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": true,
+    "late_sets": 0
+   },
+   "violations": 29,
+   "agent_turns": 12,
+   "checks": 7,
+   "seconds": 3352.7,
+   "input_tokens": 2662189,
+   "cache_read_tokens": 2171520,
+   "cache_write_tokens": 0,
+   "output_tokens": 434564,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "hold": {
+      "ZH": "17:55"
+     },
+     "train": "37355"
+    },
+    {
+     "hold": {
+      "ZH": "18:02"
+     },
+     "train": "37457"
+    },
+    {
+     "hold": {
+      "BP": "17:58"
+     },
+     "train": "37364"
+    },
+    {
+     "hold": {
+      "BP": "18:04"
+     },
+     "to": "ZH",
+     "train": "37462"
+    },
+    {
+     "hold": {
+      "GN": "17:49",
+      "ZH": "18:20"
+     },
+     "train": "37357"
+    },
+    {
+     "hold": {
+      "DWE": "18:04",
+      "GK": "18:33"
+     },
+     "train": "37464"
+    },
+    {
+     "from": "ZH",
+     "hold": {
+      "FWD": "18:58",
+      "ZH": "18:41"
+     },
+     "train": "37459"
+    },
+    {
+     "hold": {
+      "FWD": "19:18",
+      "ZH": "18:55"
+     },
+     "train": "37461"
+    },
+    {
+     "hold": {
+      "FWD": "19:24",
+      "ZH": "19:05"
+     },
+     "train": "37359"
+    },
+    {
+     "hold": {
+      "LW": "18:30"
+     },
+     "to": "BP",
+     "train": "37466"
+    },
+    {
+     "hold": {
+      "BP": "18:58",
+      "FWD": "18:02"
+     },
+     "train": "37366"
+    },
+    {
+     "hold": {
+      "BP": "19:12",
+      "GK": "19:27",
+      "LW": "18:38"
+     },
+     "train": "37368"
+    },
+    {
+     "hold": {
+      "GK": "19:36"
+     },
+     "train": "37370"
+    },
+    {
+     "from": "BP",
+     "hold": {
+      "BP": "19:16",
+      "FWD": "19:36",
+      "HDG": "19:49"
+     },
+     "train": "37463"
+    },
+    {
+     "hold": {
+      "GK": "19:55"
+     },
+     "train": "37470"
+    },
+    {
+     "hold": {
+      "FWD": "20:23",
+      "ZH": "19:57"
+     },
+     "train": "37363"
+    },
+    {
+     "hold": {
+      "ZH": "19:45"
+     },
+     "train": "37465"
+    },
+    {
+     "hold": {
+      "GN": "20:16"
+     },
+     "train": "37365"
+    },
+    {
+     "hold": {
+      "BP": "20:15",
+      "GK": "20:15",
+      "LW": "19:36"
+     },
+     "train": "37372"
+    },
+    {
+     "hold": {
+      "BP": "20:32",
+      "GK": "20:46"
+     },
+     "train": "37472"
+    },
+    {
+     "hold": {
+      "BP": "20:24",
+      "GK": "20:31"
+     },
+     "train": "37374"
+    },
+    {
+     "hold": {
+      "BP": "20:22",
+      "GK": "20:29"
+     },
+     "train": "37474"
+    },
+    {
+     "hold": {
+      "ZH": "20:38"
+     },
+     "train": "37467"
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-05-27-1830-180m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-05-27",
+   "runs": 27,
+   "reward": 0.0,
+   "submitted": false,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 596,
+   "floor_cost": 560,
+   "greedy_cost": null,
+   "real_cost": 170,
+   "hardness": {
+    "runs": 27,
+    "sets": 7,
+    "stops": 162,
+    "conflicts": 25,
+    "single_track": 8,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 17,
+    "decisions": 27,
+    "holds": 17,
+    "short_turns": 10,
+    "cancels": 0,
+    "turn_points": 1,
+    "avoidable": 36,
+    "optimal": 596,
+    "greedy_gap": 0.8593,
+    "closed_min": 59,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 3,
+   "checks": 0,
+   "seconds": 1204.6,
+   "input_tokens": 88076,
+   "cache_read_tokens": 11456,
+   "cache_write_tokens": 0,
+   "output_tokens": 128020,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "no_tool_call",
+   "errors": 0,
+   "plan": null
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-05-28-1830-210m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-05-28",
+   "runs": 31,
+   "reward": 0.740479,
+   "submitted": true,
+   "feasible": true,
+   "cost": 466,
+   "optimal_cost": 436,
+   "floor_cost": 383,
+   "greedy_cost": 1271,
+   "real_cost": 69,
+   "hardness": {
+    "runs": 31,
+    "sets": 7,
+    "stops": 186,
+    "conflicts": 23,
+    "single_track": 10,
+    "headway": 11,
+    "platforms": 1,
+    "closed": 1,
+    "decisions": 36,
+    "holds": 32,
+    "short_turns": 4,
+    "cancels": 0,
+    "turn_points": 1,
+    "avoidable": 53,
+    "optimal": 436,
+    "greedy_gap": 0.8,
+    "closed_min": 10,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 11,
+   "checks": 8,
+   "seconds": 2370.8,
+   "input_tokens": 2102819,
+   "cache_read_tokens": 1567360,
+   "cache_write_tokens": 0,
+   "output_tokens": 266912,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37368",
+     "hold": {
+      "BP": "18:43"
+     }
+    },
+    {
+     "train": "37468",
+     "hold": {
+      "BP": "18:46",
+      "ZH": "18:59"
+     }
+    },
+    {
+     "train": "37359",
+     "to": "HDG"
+    },
+    {
+     "train": "37470",
+     "from": "HDG"
+    },
+    {
+     "train": "37361",
+     "to": "HDG",
+     "hold": {
+      "GN": "19:00"
+     }
+    },
+    {
+     "train": "37472",
+     "from": "HDG",
+     "hold": {
+      "HDG": "19:34"
+     }
+    },
+    {
+     "train": "37370",
+     "hold": {
+      "HDG": "18:55",
+      "GK": "19:13"
+     }
+    },
+    {
+     "train": "37463",
+     "hold": {
+      "GN": "19:03"
+     }
+    },
+    {
+     "train": "37363",
+     "hold": {
+      "ZH": "19:19",
+      "FWD": "19:37"
+     }
+    },
+    {
+     "train": "37465",
+     "hold": {
+      "GN": "19:25",
+      "FWD": "19:56"
+     }
+    },
+    {
+     "train": "37467",
+     "hold": {
+      "FWD": "20:25"
+     }
+    },
+    {
+     "train": "37374"
+    },
+    {
+     "train": "37474",
+     "hold": {
+      "LW": "19:50"
+     }
+    },
+    {
+     "train": "37365",
+     "hold": {
+      "FWD": "20:05"
+     }
+    },
+    {
+     "train": "37471",
+     "hold": {
+      "FWD": "21:25"
+     }
+    },
+    {
+     "train": "37373",
+     "hold": {
+      "FWD": "22:04"
+     }
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-05-30-0630-180m-blockage-0",
+   "split": "eval",
+   "difficulty": "blockage",
+   "day": "2025-05-30",
+   "runs": 29,
+   "reward": 0.0,
+   "submitted": false,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 454,
+   "floor_cost": 385,
+   "greedy_cost": 1397,
+   "real_cost": 1128,
+   "hardness": {
+    "runs": 29,
+    "sets": 7,
+    "stops": 201,
+    "conflicts": 13,
+    "single_track": 1,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 12,
+    "decisions": 37,
+    "holds": 33,
+    "short_turns": 4,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 69,
+    "optimal": 454,
+    "greedy_gap": 0.8,
+    "closed_min": 28,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": true,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 2,
+   "checks": 0,
+   "seconds": 1182.1,
+   "input_tokens": 75775,
+   "cache_read_tokens": 6080,
+   "cache_write_tokens": 0,
+   "output_tokens": 128000,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "no_tool_call",
+   "errors": 0,
+   "plan": null
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-05-31-0800-210m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-05-31",
+   "runs": 32,
+   "reward": 0.1875,
+   "submitted": true,
+   "feasible": false,
+   "cost": null,
+   "optimal_cost": 1179,
+   "floor_cost": 1017,
+   "greedy_cost": 5859,
+   "real_cost": 90,
+   "hardness": {
+    "runs": 32,
+    "sets": 7,
+    "stops": 218,
+    "conflicts": 43,
+    "single_track": 6,
+    "headway": 16,
+    "platforms": 2,
+    "closed": 19,
+    "decisions": 30,
+    "holds": 20,
+    "short_turns": 10,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 162,
+    "optimal": 1179,
+    "greedy_gap": 0.8,
+    "closed_min": 39,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 2
+   },
+   "violations": 3,
+   "agent_turns": 12,
+   "checks": 7,
+   "seconds": 3479.2,
+   "input_tokens": 2488326,
+   "cache_read_tokens": 1455168,
+   "cache_write_tokens": 0,
+   "output_tokens": 335738,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "hold": {
+      "GK": "08:49"
+     },
+     "train": "37419"
+    },
+    {
+     "to": "BP",
+     "train": "37426"
+    },
+    {
+     "from": "BP",
+     "hold": {
+      "BP": "09:17",
+      "FWD": "09:30"
+     },
+     "train": "37423"
+    },
+    {
+     "hold": {
+      "GN": "08:49"
+     },
+     "to": "BP",
+     "train": "37319"
+    },
+    {
+     "from": "BP",
+     "train": "37430"
+    },
+    {
+     "hold": {
+      "GN": "08:52",
+      "GK": "09:08"
+     },
+     "to": "BP",
+     "train": "37421"
+    },
+    {
+     "from": "BP",
+     "train": "37332"
+    },
+    {
+     "hold": {
+      "FWD": "08:50"
+     },
+     "train": "37328"
+    },
+    {
+     "hold": {
+      "FWD": "08:53",
+      "BP": "09:04"
+     },
+     "train": "37428"
+    },
+    {
+     "hold": {
+      "ZH": "09:07"
+     },
+     "to": "BP",
+     "train": "37321"
+    },
+    {
+     "from": "BP",
+     "train": "37432"
+    },
+    {
+     "hold": {
+      "DWE": "09:39"
+     },
+     "to": "BP",
+     "train": "37330"
+    },
+    {
+     "from": "BP",
+     "hold": {
+      "FWD": "10:11"
+     },
+     "train": "37325"
+    },
+    {
+     "hold": {
+      "ZH": "09:27"
+     },
+     "train": "37323"
+    },
+    {
+     "hold": {
+      "LW": "09:52"
+     },
+     "train": "37334"
+    },
+    {
+     "hold": {
+      "LW": "09:55",
+      "HDG": "10:04"
+     },
+     "train": "37434"
+    },
+    {
+     "hold": {
+      "FWD": "10:01"
+     },
+     "train": "37425"
+    },
+    {
+     "hold": {
+      "FWD": "10:30"
+     },
+     "train": "37427"
+    },
+    {
+     "hold": {
+      "ZH": "10:18",
+      "FWD": "10:36"
+     },
+     "train": "37327"
+    },
+    {
+     "hold": {
+      "GN": "10:26",
+      "ZH": "10:47"
+     },
+     "train": "37429"
+    },
+    {
+     "hold": {
+      "GN": "10:40",
+      "ZH": "10:51",
+      "BP": "11:03"
+     },
+     "train": "37329"
+    },
+    {
+     "hold": {
+      "LW": "10:22"
+     },
+     "train": "37336"
+    },
+    {
+     "hold": {
+      "LW": "10:25",
+      "HDG": "10:33",
+      "GK": "10:54"
+     },
+     "train": "37436"
+    },
+    {
+     "hold": {
+      "FWD": "11:30"
+     },
+     "train": "37431"
+    },
+    {
+     "hold": {
+      "LW": "11:26",
+      "HDG": "11:36"
+     },
+     "train": "37440"
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-05-31-0900-180m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-05-31",
+   "runs": 30,
+   "reward": 0.985586,
+   "submitted": true,
+   "feasible": true,
+   "cost": 227,
+   "optimal_cost": 226,
+   "floor_cost": 216,
+   "greedy_cost": 1092,
+   "real_cost": 76,
+   "hardness": {
+    "runs": 30,
+    "sets": 7,
+    "stops": 200,
+    "conflicts": 14,
+    "single_track": 3,
+    "headway": 5,
+    "platforms": 0,
+    "closed": 6,
+    "decisions": 49,
+    "holds": 45,
+    "short_turns": 4,
+    "cancels": 0,
+    "turn_points": 1,
+    "avoidable": 10,
+    "optimal": 226,
+    "greedy_gap": 0.8,
+    "closed_min": 26,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 4,
+   "checks": 2,
+   "seconds": 720.7,
+   "input_tokens": 235008,
+   "cache_read_tokens": 142912,
+   "cache_write_tokens": 0,
+   "output_tokens": 89136,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "hold": {
+      "HDG": "09:01"
+     },
+     "train": "37430"
+    },
+    {
+     "hold": {
+      "FWD": "09:05"
+     },
+     "train": "37321"
+    },
+    {
+     "to": "HDG",
+     "train": "37423"
+    },
+    {
+     "from": "HDG",
+     "train": "37334"
+    },
+    {
+     "to": "HDG",
+     "train": "37323"
+    },
+    {
+     "from": "HDG",
+     "hold": {
+      "BP": "10:15"
+     },
+     "train": "37434"
+    },
+    {
+     "hold": {
+      "GN": "09:27"
+     },
+     "train": "37425"
+    }
+   ]
+  },
+  {
+   "model": "hf:zai-org/GLM-5.3-Flash:together@default",
+   "task_id": "gnlw-2025-06-22-1600-240m-compound-0",
+   "split": "eval",
+   "difficulty": "compound",
+   "day": "2025-06-22",
+   "runs": 18,
+   "reward": 1.0,
+   "submitted": true,
+   "feasible": true,
+   "cost": 668,
+   "optimal_cost": 668,
+   "floor_cost": 668,
+   "greedy_cost": null,
+   "real_cost": 27,
+   "hardness": {
+    "runs": 18,
+    "sets": 3,
+    "stops": 108,
+    "conflicts": 22,
+    "single_track": 1,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 21,
+    "decisions": 22,
+    "holds": 16,
+    "short_turns": 4,
+    "cancels": 2,
+    "turn_points": 1,
+    "avoidable": 0,
+    "optimal": 668,
+    "greedy_gap": 0.8444,
+    "closed_min": 92,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 4,
+   "checks": 2,
+   "seconds": 760.2,
+   "input_tokens": 214568,
+   "cache_read_tokens": 139392,
+   "cache_write_tokens": 0,
+   "output_tokens": 66685,
+   "served_by": [
+    "zai-org/GLM-5.3-Flash"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37458",
+     "to": "BP"
+    },
+    {
+     "train": "37353",
+     "from": "BP"
+    },
+    {
+     "train": "37360",
+     "to": "BP"
+    },
+    {
+     "train": "37455",
+     "from": "BP"
+    },
+    {
+     "train": "37451",
+     "cancel": true
+    },
+    {
+     "train": "37462",
+     "cancel": true
+    },
+    {
+     "train": "37364",
+     "hold": {
+      "BP": "17:42"
+     }
+    }
+   ]
+  }
+ ]
+}

runs/calib-sonnet-5-5/index.json

@@ -0,0 +1,1900 @@
+{
+ "run": "calib-sonnet-5-5",
+ "episodes": [
+  {
+   "model": "claude-sonnet-5-5@high",
+   "task_id": "gnlw-2025-01-05-0800-210m-compound-0",
+   "split": "train",
+   "difficulty": "compound",
+   "day": "2025-01-05",
+   "runs": 15,
+   "reward": 0.200941,
+   "submitted": true,
+   "feasible": true,
+   "cost": 1263,
+   "optimal_cost": 892,
+   "floor_cost": 882,
+   "greedy_cost": 3955,
+   "real_cost": 42,
+   "hardness": {
+    "runs": 15,
+    "sets": 3,
+    "stops": 100,
+    "conflicts": 6,
+    "single_track": 1,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 5,
+    "decisions": 23,
+    "holds": 16,
+    "short_turns": 6,
+    "cancels": 1,
+    "turn_points": 1,
+    "avoidable": 10,
+    "optimal": 892,
+    "greedy_gap": 0.8,
+    "closed_min": 67,
+    "slow_min": 10,
+    "track_min": 31,
+    "single_closed": false,
+    "mid_line": true,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 5,
+   "checks": 4,
+   "seconds": 110.3,
+   "input_tokens": 90086,
+   "cache_read_tokens": 62969,
+   "cache_write_tokens": 27097,
+   "output_tokens": 11803,
+   "served_by": [
+    "claude-sonnet-5-5"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37426",
+     "hold": {
+      "FWD": "09:09"
+     }
+    },
+    {
+     "train": "37419",
+     "to": "BP"
+    },
+    {
+     "train": "37430",
+     "from": "BP"
+    },
+    {
+     "train": "37328",
+     "cancel": true
+    },
+    {
+     "train": "37423",
+     "cancel": true
+    },
+    {
+     "train": "37321",
+     "cancel": true
+    },
+    {
+     "train": "37332",
+     "cancel": true
+    }
+   ]
+  },
+  {
+   "model": "claude-sonnet-5-5@high",
+   "task_id": "gnlw-2025-01-07-0703-180m-real-0",
+   "split": "train",
+   "difficulty": "real",
+   "day": "2025-01-07",
+   "runs": 26,
+   "reward": 0.37582,
+   "submitted": true,
+   "feasible": true,
+   "cost": 435,
+   "optimal_cost": 335,
+   "floor_cost": 303,
+   "greedy_cost": 1021,
+   "real_cost": 414,
+   "hardness": {
+    "runs": 26,
+    "sets": 6,
+    "stops": 176,
+    "conflicts": 20,
+    "single_track": 5,
+    "headway": 9,
+    "platforms": 0,
+    "closed": 6,
+    "decisions": 34,
+    "holds": 30,
+    "short_turns": 4,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 32,
+    "optimal": 335,
+    "greedy_gap": 0.8,
+    "closed_min": 32,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 6,
+   "checks": 5,
+   "seconds": 187.8,
+   "input_tokens": 174728,
+   "cache_read_tokens": 126106,
+   "cache_write_tokens": 48598,
+   "output_tokens": 23026,
+   "served_by": [
+    "claude-sonnet-5-5"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37313",
+     "to": "HDG"
+    },
+    {
+     "train": "37424",
+     "from": "HDG"
+    },
+    {
+     "train": "37415",
+     "hold": {
+      "HDG": "07:35"
+     }
+    },
+    {
+     "train": "37315",
+     "hold": {
+      "HDG": "07:40"
+     }
+    },
+    {
+     "train": "37324",
+     "cancel": true
+    },
+    {
+     "train": "37319",
+     "cancel": true
+    }
+   ]
+  },
+  {
+   "model": "claude-sonnet-5-5@high",
+   "task_id": "gnlw-2025-01-13-1630-150m-blockage-0",
+   "split": "train",
+   "difficulty": "blockage",
+   "day": "2025-01-13",
+   "runs": 26,
+   "reward": 0.814541,
+   "submitted": true,
+   "feasible": true,
+   "cost": 256,
+   "optimal_cost": 232,
+   "floor_cost": 150,
+   "greedy_cost": 1412,
+   "real_cost": 473,
+   "hardness": {
+    "runs": 26,
+    "sets": 7,
+    "stops": 174,
+    "conflicts": 5,
+    "single_track": 0,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 5,
+    "decisions": 17,
+    "holds": 17,
+    "short_turns": 0,
+    "cancels": 0,
+    "turn_points": 0,
+    "avoidable": 82,
+    "optimal": 232,
+    "greedy_gap": 0.8,
+    "closed_min": 20,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": true,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 8,
+   "checks": 7,
+   "seconds": 226.0,
+   "input_tokens": 279241,
+   "cache_read_tokens": 221034,
+   "cache_write_tokens": 58175,
+   "output_tokens": 26644,
+   "served_by": [
+    "claude-sonnet-5-5"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37362",
+     "hold": {
+      "BP": "17:19"
+     }
+    },
+    {
+     "train": "37355",
+     "hold": {
+      "GN": "17:12"
+     }
+    },
+    {
+     "train": "37455",
+     "hold": {
+      "ZH": "17:23"
+     },
+     "to": "HDG"
+    },
+    {
+     "train": "37366",
+     "from": "HDG"
+    },
+    {
+     "train": "37462",
+     "hold": {
+      "BP": "17:22",
+      "GK": "17:29"
+     }
+    },
+    {
+     "train": "37457",
+     "hold": {
+      "GN": "17:26",
+      "FWD": "17:56"
+     }
+    },
+    {
+     "train": "37357",
+     "hold": {
+      "GN": "17:42"
+     }
+    },
+    {
+     "train": "37466",
+     "hold": {
+      "HDG": "18:00"
+     }
+    }
+   ]
+  },
+  {
+   "model": "claude-sonnet-5-5@high",
+   "task_id": "gnlw-2025-01-14-1800-150m-loop-0",
+   "split": "train",
+   "difficulty": "loop",
+   "day": "2025-01-14",
+   "runs": 25,
+   "reward": 0.553439,
+   "submitted": true,
+   "feasible": true,
+   "cost": 510,
+   "optimal_cost": 423,
+   "floor_cost": 310,
+   "greedy_cost": 1411,
+   "real_cost": 85,
+   "hardness": {
+    "runs": 25,
+    "sets": 7,
+    "stops": 158,
+    "conflicts": 19,
+    "single_track": 13,
+    "headway": 6,
+    "platforms": 0,
+    "closed": 0,
+    "decisions": 25,
+    "holds": 21,
+    "short_turns": 4,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 113,
+    "optimal": 423,
+    "greedy_gap": 0.7999,
+    "closed_min": 0,
+    "slow_min": 69,
+    "track_min": 113,
+    "single_closed": false,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 5,
+   "checks": 4,
+   "seconds": 445.4,
+   "input_tokens": 218660,
+   "cache_read_tokens": 141886,
+   "cache_write_tokens": 76754,
+   "output_tokens": 60181,
+   "served_by": [
+    "claude-sonnet-5-5"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37359",
+     "to": "HDG",
+     "hold": {
+      "DWE": "18:55",
+      "FWD": "19:00"
+     }
+    },
+    {
+     "train": "37470",
+     "from": "HDG",
+     "hold": {
+      "BP": "19:23"
+     }
+    },
+    {
+     "train": "37368",
+     "hold": {
+      "BP": "18:43"
+     }
+    },
+    {
+     "train": "37468",
+     "hold": {
+      "BP": "18:49",
+      "ZH": "19:08"
+     }
+    },
+    {
+     "train": "37463",
+     "hold": {
+      "GN": "18:56",
+      "FWD": "19:33"
+     }
+    },
+    {
+     "train": "37363",
+     "hold": {
+      "GN": "19:12"
+     }
+    },
+    {
+     "train": "37465",
+     "hold": {
+      "GN": "19:29"
+     }
+    },
+    {
+     "train": "37365",
+     "hold": {
+      "GN": "19:47"
+     }
+    },
+    {
+     "train": "37372",
+     "hold": {
+      "LW": "19:19"
+     }
+    },
+    {
+     "train": "37472",
+     "hold": {
+      "BP": "19:49"
+     }
+    },
+    {
+     "train": "37374",
+     "hold": {
+      "LW": "19:51"
+     }
+    },
+    {
+     "train": "37467",
+     "hold": {
+      "FWD": "20:28"
+     }
+    }
+   ]
+  },
+  {
+   "model": "claude-sonnet-5-5@high",
+   "task_id": "gnlw-2025-01-16-1802-180m-real-0",
+   "split": "train",
+   "difficulty": "real",
+   "day": "2025-01-16",
+   "runs": 24,
+   "reward": 0.41036,
+   "submitted": true,
+   "feasible": true,
+   "cost": 1335,
+   "optimal_cost": 1154,
+   "floor_cost": 983,
+   "greedy_cost": null,
+   "real_cost": 1127,
+   "hardness": {
+    "runs": 24,
+    "sets": 6,
+    "stops": 151,
+    "conflicts": 45,
+    "single_track": 10,
+    "headway": 32,
+    "platforms": 1,
+    "closed": 2,
+    "decisions": 21,
+    "holds": 12,
+    "short_turns": 9,
+    "cancels": 0,
+    "turn_points": 3,
+    "avoidable": 171,
+    "optimal": 1154,
+    "greedy_gap": 0.8583,
+    "closed_min": 36,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": false,
+    "mid_line": true,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 6,
+   "checks": 5,
+   "seconds": 475.8,
+   "input_tokens": 329656,
+   "cache_read_tokens": 242247,
+   "cache_write_tokens": 87385,
+   "output_tokens": 63115,
+   "served_by": [
+    "claude-sonnet-5-5"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37355",
+     "to": "HDG"
+    },
+    {
+     "train": "37466",
+     "from": "HDG",
+     "to": "ZH",
+     "hold": {
+      "HDG": "18:33"
+     }
+    },
+    {
+     "train": "37463",
+     "from": "ZH"
+    },
+    {
+     "train": "37457",
+     "to": "HDG"
+    },
+    {
+     "train": "37368",
+     "from": "HDG",
+     "hold": {
+      "HDG": "18:37",
+      "FWD": "18:40",
+      "BP": "18:49"
+     }
+    },
+    {
+     "train": "37357",
+     "to": "HDG",
+     "hold": {
+      "BP": "18:26",
+      "FWD": "18:40"
+     }
+    },
+    {
+     "train": "37468",
+     "from": "HDG",
+     "hold": {
+      "HDG": "18:47"
+     }
+    },
+    {
+     "train": "37459",
+     "hold": {
+      "GK": "18:20",
+      "BP": "18:33",
+      "FWD": "18:43"
+     }
+    },
+    {
+     "train": "37359",
+     "hold": {
+      "ZH": "18:29",
+      "FWD": "18:50"
+     }
+    },
+    {
+     "train": "37464",
+     "to": "BP"
+    },
+    {
+     "train": "37461",
+     "from": "BP",
+     "to": "HDG"
+    },
+    {
+     "train": "37372",
+     "from": "HDG"
+    },
+    {
+     "train": "37363",
+     "hold": {
+      "ZH": "19:21"
+     }
+    },
+    {
+     "train": "37365",
+     "hold": {
+      "GN": "19:40"
+     }
+    }
+   ]
+  },
+  {
+   "model": "claude-sonnet-5-5@high",
+   "task_id": "gnlw-2025-02-02-1830-180m-blockage-0",
+   "split": "train",
+   "difficulty": "blockage",
+   "day": "2025-02-02",
+   "runs": 15,
+   "reward": 0.327054,
+   "submitted": true,
+   "feasible": true,
+   "cost": 726,
+   "optimal_cost": 634,
+   "floor_cost": 634,
+   "greedy_cost": 1483,
+   "real_cost": 226,
+   "hardness": {
+    "runs": 15,
+    "sets": 3,
+    "stops": 100,
+    "conflicts": 20,
+    "single_track": 0,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 20,
+    "decisions": 20,
+    "holds": 15,
+    "short_turns": 5,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 0,
+    "optimal": 634,
+    "greedy_gap": 0.8,
+    "closed_min": 57,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 3,
+   "checks": 2,
+   "seconds": 122.4,
+   "input_tokens": 37433,
+   "cache_read_tokens": 14314,
+   "cache_write_tokens": 23107,
+   "output_tokens": 14308,
+   "served_by": [
+    "claude-sonnet-5-5"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37459",
+     "hold": {
+      "LWC": "19:37"
+     }
+    },
+    {
+     "train": "37470",
+     "cancel": true
+    },
+    {
+     "train": "37365",
+     "cancel": true
+    },
+    {
+     "train": "37361",
+     "to": "BP"
+    },
+    {
+     "train": "37372",
+     "from": "BP"
+    },
+    {
+     "train": "37463",
+     "hold": {
+      "BP": "19:37"
+     }
+    }
+   ]
+  },
+  {
+   "model": "claude-sonnet-5-5@high",
+   "task_id": "gnlw-2025-02-03-0900-150m-loop-0",
+   "split": "train",
+   "difficulty": "loop",
+   "day": "2025-02-03",
+   "runs": 26,
+   "reward": 0.735231,
+   "submitted": true,
+   "feasible": true,
+   "cost": 398,
+   "optimal_cost": 356,
+   "floor_cost": 247,
+   "greedy_cost": 2860,
+   "real_cost": 515,
+   "hardness": {
+    "runs": 26,
+    "sets": 7,
+    "stops": 174,
+    "conflicts": 20,
+    "single_track": 14,
+    "headway": 5,
+    "platforms": 1,
+    "closed": 0,
+    "decisions": 26,
+    "holds": 24,
+    "short_turns": 2,
+    "cancels": 0,
+    "turn_points": 1,
+    "avoidable": 109,
+    "optimal": 356,
+    "greedy_gap": 0.8,
+    "closed_min": 0,
+    "slow_min": 33,
+    "track_min": 131,
+    "single_closed": false,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 5,
+   "checks": 4,
+   "seconds": 389.3,
+   "input_tokens": 235299,
+   "cache_read_tokens": 159342,
+   "cache_write_tokens": 75937,
+   "output_tokens": 52360,
+   "served_by": [
+    "claude-sonnet-5-5"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37421",
+     "hold": {
+      "HDG": "09:03"
+     }
+    },
+    {
+     "train": "37321",
+     "hold": {
+      "FWD": "09:06"
+     }
+    },
+    {
+     "train": "37323",
+     "to": "HDG",
+     "hold": {
+      "GN": "09:27"
+     }
+    },
+    {
+     "train": "37425",
+     "hold": {
+      "GN": "09:30",
+      "FWD": "10:08"
+     }
+    },
+    {
+     "train": "37325",
+     "hold": {
+      "FWD": "10:14"
+     }
+    },
+    {
+     "train": "37427",
+     "hold": {
+      "FWD": "10:31"
+     }
+    },
+    {
+     "train": "37327",
+     "hold": {
+      "FWD": "10:37"
+     }
+    },
+    {
+     "train": "37430",
+     "hold": {
+      "ZH": "09:35"
+     }
+    },
+    {
+     "train": "37332",
+     "hold": {
+      "BP": "09:43"
+     }
+    },
+    {
+     "train": "37432",
+     "hold": {
+      "BP": "09:46",
+      "GK": "09:56"
+     }
+    },
+    {
+     "train": "37434",
+     "from": "HDG"
+    },
+    {
+     "train": "37436",
+     "hold": {
+      "HDG": "10:34"
+     }
+    },
+    {
+     "train": "37336",
+     "hold": {
+      "BP": "10:42"
+     }
+    }
+   ]
+  },
+  {
+   "model": "claude-sonnet-5-5@high",
+   "task_id": "gnlw-2025-02-22-0754-180m-real-0",
+   "split": "train",
+   "difficulty": "real",
+   "day": "2025-02-22",
+   "runs": 27,
+   "reward": 0.407882,
+   "submitted": true,
+   "feasible": true,
+   "cost": 401,
+   "optimal_cost": 244,
+   "floor_cost": 111,
+   "greedy_cost": 3096,
+   "real_cost": 1637,
+   "hardness": {
+    "runs": 27,
+    "sets": 7,
+    "stops": 183,
+    "conflicts": 18,
+    "single_track": 18,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 0,
+    "decisions": 28,
+    "holds": 28,
+    "short_turns": 0,
+    "cancels": 0,
+    "turn_points": 0,
+    "avoidable": 133,
+    "optimal": 244,
+    "greedy_gap": 0.8,
+    "closed_min": 0,
+    "slow_min": 180,
+    "track_min": 0,
+    "single_closed": false,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 5,
+   "checks": 4,
+   "seconds": 212.7,
+   "input_tokens": 123680,
+   "cache_read_tokens": 75327,
+   "cache_write_tokens": 48333,
+   "output_tokens": 26914,
+   "served_by": [
+    "claude-sonnet-5-5"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37419",
+     "hold": {
+      "FWD": "08:28"
+     }
+    },
+    {
+     "train": "37421",
+     "hold": {
+      "FWD": "08:59"
+     }
+    },
+    {
+     "train": "37423",
+     "hold": {
+      "FWD": "09:30"
+     }
+    },
+    {
+     "train": "37425",
+     "hold": {
+      "FWD": "10:01"
+     }
+    },
+    {
+     "train": "37427",
+     "hold": {
+      "FWD": "10:32"
+     }
+    },
+    {
+     "train": "37429",
+     "hold": {
+      "GN": "10:25",
+      "FWD": "11:03"
+     }
+    },
+    {
+     "train": "37430",
+     "hold": {
+      "HDG": "09:02"
+     }
+    },
+    {
+     "train": "37432",
+     "hold": {
+      "HDG": "09:33"
+     }
+    },
+    {
+     "train": "37434",
+     "hold": {
+      "HDG": "10:04"
+     }
+    },
+    {
+     "train": "37436",
+     "hold": {
+      "HDG": "10:35"
+     }
+    },
+    {
+     "train": "37438",
+     "hold": {
+      "HDG": "11:06"
+     }
+    },
+    {
+     "train": "37319",
+     "hold": {
+      "FWD": "08:34"
+     }
+    },
+    {
+     "train": "37321",
+     "hold": {
+      "FWD": "09:05"
+     }
+    },
+    {
+     "train": "37323",
+     "hold": {
+      "FWD": "09:36"
+     }
+    },
+    {
+     "train": "37325",
+     "hold": {
+      "GN": "09:40",
+      "FWD": "10:07"
+     }
+    },
+    {
+     "train": "37327",
+     "hold": {
+      "GN": "10:10",
+      "FWD": "10:38"
+     }
+    },
+    {
+     "train": "37329",
+     "hold": {
+      "GN": "10:42",
+      "FWD": "11:09"
+     }
+    }
+   ]
+  },
+  {
+   "model": "claude-sonnet-5-5@high",
+   "task_id": "gnlw-2025-02-27-1630-180m-compound-0",
+   "split": "train",
+   "difficulty": "compound",
+   "day": "2025-02-27",
+   "runs": 30,
+   "reward": 0.200001,
+   "submitted": true,
+   "feasible": true,
+   "cost": 2478,
+   "optimal_cost": 1035,
+   "floor_cost": 931,
+   "greedy_cost": 3334,
+   "real_cost": 96,
+   "hardness": {
+    "runs": 30,
+    "sets": 7,
+    "stops": 200,
+    "conflicts": 45,
+    "single_track": 8,
+    "headway": 20,
+    "platforms": 3,
+    "closed": 14,
+    "decisions": 41,
+    "holds": 29,
+    "short_turns": 12,
+    "cancels": 0,
+    "turn_points": 3,
+    "avoidable": 104,
+    "optimal": 1035,
+    "greedy_gap": 0.8,
+    "closed_min": 39,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 7,
+   "checks": 6,
+   "seconds": 614.6,
+   "input_tokens": 493351,
+   "cache_read_tokens": 369633,
+   "cache_write_tokens": 123690,
+   "output_tokens": 82412,
+   "served_by": [
+    "claude-sonnet-5-5"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37451",
+     "to": "HDG"
+    },
+    {
+     "train": "37362",
+     "from": "HDG",
+     "hold": {
+      "HDG": "17:09",
+      "FWD": "17:17"
+     }
+    },
+    {
+     "train": "37460",
+     "hold": {
+      "FWD": "17:09"
+     }
+    },
+    {
+     "train": "37453",
+     "hold": {
+      "BP": "17:09"
+     }
+    },
+    {
+     "train": "37353",
+     "hold": {
+      "BP": "17:16"
+     }
+    },
+    {
+     "train": "37455",
+     "hold": {
+      "GN": "16:57",
+      "BP": "17:19"
+     }
+    },
+    {
+     "train": "37462",
+     "cancel": true
+    },
+    {
+     "train": "37459",
+     "cancel": true
+    },
+    {
+     "train": "37464",
+     "hold": {
+      "LW": "17:40"
+     }
+    },
+    {
+     "train": "37364",
+     "hold": {
+      "LW": "17:45",
+      "FWD": "17:54",
+      "BP": "18:04"
+     }
+    },
+    {
+     "train": "37366",
+     "hold": {
+      "LW": "17:48",
+      "FWD": "18:02"
+     }
+    },
+    {
+     "train": "37355",
+     "hold": {
+      "GN": "17:40"
+     }
+    },
+    {
+     "train": "37457",
+     "hold": {
+      "GN": "17:43"
+     }
+    },
+    {
+     "train": "37357",
+     "hold": {
+      "GN": "17:53"
+     }
+    },
+    {
+     "train": "37466",
+     "hold": {
+      "LW": "18:25"
+     }
+    },
+    {
+     "train": "37468",
+     "hold": {
+      "LW": "18:29"
+     }
+    },
+    {
+     "train": "37368",
+     "hold": {
+      "LW": "18:34",
+      "FWD": "18:43",
+      "BP": "18:53"
+     }
+    },
+    {
+     "train": "37359",
+     "hold": {
+      "GN": "18:25",
+      "FWD": "18:54"
+     }
+    },
+    {
+     "train": "37461",
+     "hold": {
+      "GN": "18:28",
+      "FWD": "18:57"
+     }
+    },
+    {
+     "train": "37463",
+     "hold": {
+      "GN": "19:10"
+     }
+    },
+    {
+     "train": "37363",
+     "hold": {
+      "GN": "19:21",
+      "FWD": "19:44"
+     }
+    },
+    {
+     "train": "37470",
+     "hold": {
+      "LW": "19:14"
+     }
+    },
+    {
+     "train": "37372",
+     "hold": {
+      "LW": "19:19",
+      "FWD": "19:28",
+      "BP": "19:38"
+     }
+    },
+    {
+     "train": "37472",
+     "hold": {
+      "LW": "19:22",
+      "BP": "19:41"
+     }
+    }
+   ]
+  },
+  {
+   "model": "claude-sonnet-5-5@high",
+   "task_id": "gnlw-2025-03-17-0830-210m-blockage-0",
+   "split": "train",
+   "difficulty": "blockage",
+   "day": "2025-03-17",
+   "runs": 34,
+   "reward": 0.214259,
+   "submitted": true,
+   "feasible": true,
+   "cost": 821,
+   "optimal_cost": 525,
+   "floor_cost": 478,
+   "greedy_cost": null,
+   "real_cost": 508,
+   "hardness": {
+    "runs": 34,
+    "sets": 7,
+    "stops": 226,
+    "conflicts": 5,
+    "single_track": 0,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 5,
+    "decisions": 36,
+    "holds": 30,
+    "short_turns": 6,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 47,
+    "optimal": 525,
+    "greedy_gap": 0.8294,
+    "closed_min": 33,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": false,
+    "mid_line": true,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 9,
+   "checks": 8,
+   "seconds": 300.8,
+   "input_tokens": 445638,
+   "cache_read_tokens": 360486,
+   "cache_write_tokens": 85116,
+   "output_tokens": 37113,
+   "served_by": [
+    "claude-sonnet-5-5"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37421",
+     "to": "HDG",
+     "hold": {
+      "DWE": "09:24"
+     }
+    },
+    {
+     "train": "37321",
+     "to": "HDG",
+     "hold": {
+      "BP": "09:24"
+     }
+    },
+    {
+     "train": "37423",
+     "to": "HDG",
+     "hold": {
+      "GK": "09:26"
+     }
+    },
+    {
+     "train": "37323",
+     "to": "HDG",
+     "hold": {
+      "GN": "09:21",
+      "DWE": "09:43"
+     }
+    },
+    {
+     "train": "37330",
+     "to": "ZH",
+     "hold": {
+      "FWD": "09:23"
+     }
+    },
+    {
+     "train": "37430",
+     "hold": {
+      "FWD": "09:26"
+     }
+    },
+    {
+     "train": "37332",
+     "from": "HDG",
+     "hold": {
+      "HDG": "09:34",
+      "BP": "09:45"
+     }
+    },
+    {
+     "train": "37432",
+     "from": "HDG",
+     "hold": {
+      "HDG": "09:38"
+     }
+    },
+    {
+     "train": "37334",
+     "from": "HDG",
+     "hold": {
+      "GK": "10:09"
+     }
+    },
+    {
+     "train": "37434",
+     "from": "HDG"
+    },
+    {
+     "train": "37325",
+     "from": "ZH"
+    }
+   ]
+  },
+  {
+   "model": "claude-sonnet-5-5@high",
+   "task_id": "gnlw-2025-03-19-0613-180m-real-0",
+   "split": "train",
+   "difficulty": "real",
+   "day": "2025-03-19",
+   "runs": 26,
+   "reward": 1.0,
+   "submitted": true,
+   "feasible": true,
+   "cost": 38,
+   "optimal_cost": 38,
+   "floor_cost": 17,
+   "greedy_cost": 950,
+   "real_cost": 1752,
+   "hardness": {
+    "runs": 26,
+    "sets": 7,
+    "stops": 174,
+    "conflicts": 11,
+    "single_track": 1,
+    "headway": 0,
+    "platforms": 10,
+    "closed": 0,
+    "decisions": 24,
+    "holds": 24,
+    "short_turns": 0,
+    "cancels": 0,
+    "turn_points": 0,
+    "avoidable": 21,
+    "optimal": 38,
+    "greedy_gap": 0.8,
+    "closed_min": 0,
+    "slow_min": 0,
+    "track_min": 180,
+    "single_closed": false,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 3,
+   "checks": 2,
+   "seconds": 137.7,
+   "input_tokens": 50578,
+   "cache_read_tokens": 21047,
+   "cache_write_tokens": 29519,
+   "output_tokens": 17651,
+   "served_by": [
+    "claude-sonnet-5-5"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37420",
+     "hold": {
+      "HDG": "06:31"
+     }
+    },
+    {
+     "train": "37413",
+     "hold": {
+      "DWE": "06:53"
+     }
+    },
+    {
+     "train": "37313",
+     "hold": {
+      "BP": "06:58"
+     }
+    },
+    {
+     "train": "37415",
+     "hold": {
+      "DWE": "07:23"
+     }
+    },
+    {
+     "train": "37315",
+     "hold": {
+      "ZH": "07:20"
+     }
+    },
+    {
+     "train": "37417",
+     "hold": {
+      "DWE": "07:53"
+     }
+    },
+    {
+     "train": "37317",
+     "hold": {
+      "BP": "07:58"
+     }
+    },
+    {
+     "train": "37419",
+     "hold": {
+      "DWE": "08:23"
+     }
+    },
+    {
+     "train": "37319",
+     "hold": {
+      "ZH": "08:20"
+     }
+    },
+    {
+     "train": "37421",
+     "hold": {
+      "DWE": "08:53"
+     }
+    },
+    {
+     "train": "37321",
+     "hold": {
+      "BP": "08:58"
+     }
+    }
+   ]
+  },
+  {
+   "model": "claude-sonnet-5-5@high",
+   "task_id": "gnlw-2025-03-27-1800-180m-compound-0",
+   "split": "train",
+   "difficulty": "compound",
+   "day": "2025-03-27",
+   "runs": 29,
+   "reward": 0.850483,
+   "submitted": true,
+   "feasible": true,
+   "cost": 546,
+   "optimal_cost": 534,
+   "floor_cost": 518,
+   "greedy_cost": 1519,
+   "real_cost": 344,
+   "hardness": {
+    "runs": 29,
+    "sets": 7,
+    "stops": 182,
+    "conflicts": 36,
+    "single_track": 3,
+    "headway": 20,
+    "platforms": 1,
+    "closed": 12,
+    "decisions": 30,
+    "holds": 22,
+    "short_turns": 8,
+    "cancels": 0,
+    "turn_points": 1,
+    "avoidable": 16,
+    "optimal": 534,
+    "greedy_gap": 0.8,
+    "closed_min": 59,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": true,
+    "mid_line": false,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 4,
+   "checks": 3,
+   "seconds": 122.5,
+   "input_tokens": 101088,
+   "cache_read_tokens": 63335,
+   "cache_write_tokens": 37737,
+   "output_tokens": 14374,
+   "served_by": [
+    "claude-sonnet-5-5"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37457",
+     "to": "HDG"
+    },
+    {
+     "train": "37368",
+     "from": "HDG"
+    },
+    {
+     "train": "37357",
+     "to": "HDG"
+    },
+    {
+     "train": "37468",
+     "from": "HDG"
+    },
+    {
+     "train": "37459",
+     "to": "HDG",
+     "hold": {
+      "ZH": "18:11",
+      "FWD": "18:33"
+     }
+    },
+    {
+     "train": "37370",
+     "from": "HDG"
+    },
+    {
+     "train": "37359",
+     "to": "HDG"
+    },
+    {
+     "train": "37470",
+     "from": "HDG",
+     "hold": {
+      "HDG": "19:09"
+     }
+    },
+    {
+     "train": "37361",
+     "hold": {
+      "GN": "18:43"
+     }
+    },
+    {
+     "train": "37461",
+     "hold": {
+      "HDG": "19:04"
+     }
+    },
+    {
+     "train": "37365",
+     "hold": {
+      "GN": "19:40"
+     }
+    }
+   ]
+  },
+  {
+   "model": "claude-sonnet-5-5@high",
+   "task_id": "gnlw-2025-04-07-1730-240m-compound-0",
+   "split": "train",
+   "difficulty": "compound",
+   "day": "2025-04-07",
+   "runs": 35,
+   "reward": 0.735395,
+   "submitted": true,
+   "feasible": true,
+   "cost": 637,
+   "optimal_cost": 587,
+   "floor_cost": 438,
+   "greedy_cost": null,
+   "real_cost": 94,
+   "hardness": {
+    "runs": 35,
+    "sets": 7,
+    "stops": 214,
+    "conflicts": 32,
+    "single_track": 9,
+    "headway": 17,
+    "platforms": 2,
+    "closed": 4,
+    "decisions": 25,
+    "holds": 21,
+    "short_turns": 4,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 149,
+    "optimal": 587,
+    "greedy_gap": 0.84,
+    "closed_min": 30,
+    "slow_min": 0,
+    "track_min": 10,
+    "single_closed": true,
+    "mid_line": true,
+    "late_sets": 1
+   },
+   "violations": 0,
+   "agent_turns": 5,
+   "checks": 4,
+   "seconds": 299.9,
+   "input_tokens": 199091,
+   "cache_read_tokens": 133278,
+   "cache_write_tokens": 65793,
+   "output_tokens": 39094,
+   "served_by": [
+    "claude-sonnet-5-5"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37355",
+     "to": "HDG",
+     "hold": {
+      "FWD": "18:03"
+     }
+    },
+    {
+     "train": "37457",
+     "hold": {
+      "DWE": "18:01",
+      "FWD": "18:08"
+     }
+    },
+    {
+     "train": "37366",
+     "hold": {
+      "LW": "18:00",
+      "FWD": "18:11"
+     }
+    },
+    {
+     "train": "37466",
+     "from": "HDG",
+     "hold": {
+      "HDG": "18:11",
+      "FWD": "18:14"
+     }
+    },
+    {
+     "train": "37459",
+     "hold": {
+      "GN": "17:57",
+      "HDG": "18:37"
+     }
+    },
+    {
+     "train": "37359",
+     "hold": {
+      "ZH": "18:26",
+      "FWD": "18:41"
+     }
+    },
+    {
+     "train": "37368",
+     "hold": {
+      "LW": "18:26"
+     }
+    },
+    {
+     "train": "37361",
+     "hold": {
+      "GN": "18:44",
+      "FWD": "19:09"
+     }
+    },
+    {
+     "train": "37463",
+     "hold": {
+      "FWD": "19:26"
+     }
+    }
+   ]
+  },
+  {
+   "model": "claude-sonnet-5-5@high",
+   "task_id": "gnlw-2025-05-01-0800-180m-blockage-0",
+   "split": "train",
+   "difficulty": "blockage",
+   "day": "2025-05-01",
+   "runs": 30,
+   "reward": 0.428932,
+   "submitted": true,
+   "feasible": true,
+   "cost": 675,
+   "optimal_cost": 543,
+   "floor_cost": 432,
+   "greedy_cost": 1278,
+   "real_cost": 58,
+   "hardness": {
+    "runs": 30,
+    "sets": 7,
+    "stops": 200,
+    "conflicts": 8,
+    "single_track": 0,
+    "headway": 0,
+    "platforms": 0,
+    "closed": 8,
+    "decisions": 27,
+    "holds": 21,
+    "short_turns": 6,
+    "cancels": 0,
+    "turn_points": 2,
+    "avoidable": 111,
+    "optimal": 543,
+    "greedy_gap": 0.784,
+    "closed_min": 26,
+    "slow_min": 0,
+    "track_min": 0,
+    "single_closed": false,
+    "mid_line": true,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 5,
+   "checks": 4,
+   "seconds": 350.5,
+   "input_tokens": 179882,
+   "cache_read_tokens": 108749,
+   "cache_write_tokens": 71113,
+   "output_tokens": 44922,
+   "served_by": [
+    "claude-sonnet-5-5"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37419",
+     "hold": {
+      "GK": "08:36"
+     },
+     "to": "HDG"
+    },
+    {
+     "train": "37319",
+     "hold": {
+      "GN": "08:32"
+     },
+     "to": "HDG"
+    },
+    {
+     "train": "37421",
+     "hold": {
+      "GN": "08:35",
+      "BP": "08:57"
+     }
+    },
+    {
+     "train": "37321",
+     "hold": {
+      "GN": "08:46",
+      "BP": "09:04"
+     }
+    },
+    {
+     "train": "37426",
+     "hold": {
+      "DWE": "08:36"
+     },
+     "to": "ZH"
+    },
+    {
+     "train": "37423",
+     "from": "ZH",
+     "hold": {
+      "ZH": "09:04",
+      "FWD": "09:28"
+     }
+    },
+    {
+     "train": "37328",
+     "hold": {
+      "FWD": "08:37",
+      "BP": "08:49"
+     }
+    },
+    {
+     "train": "37428",
+     "hold": {
+      "FWD": "08:42",
+      "BP": "08:52"
+     }
+    },
+    {
+     "train": "37330",
+     "from": "HDG"
+    },
+    {
+     "train": "37430",
+     "from": "HDG",
+     "hold": {
+      "GK": "09:22"
+     }
+    },
+    {
+     "train": "37432",
+     "hold": {
+      "HDG": "09:31"
+     }
+    },
+    {
+     "train": "37323",
+     "hold": {
+      "GN": "09:12"
+     }
+    }
+   ]
+  },
+  {
+   "model": "claude-sonnet-5-5@high",
+   "task_id": "gnlw-2025-05-11-0800-180m-loop-0",
+   "split": "train",
+   "difficulty": "loop",
+   "day": "2025-05-11",
+   "runs": 15,
+   "reward": 0.832784,
+   "submitted": true,
+   "feasible": true,
+   "cost": 211,
+   "optimal_cost": 194,
+   "floor_cost": 149,
+   "greedy_cost": null,
+   "real_cost": 38,
+   "hardness": {
+    "runs": 15,
+    "sets": 4,
+    "stops": 86,
+    "conflicts": 3,
+    "single_track": 1,
+    "headway": 0,
+    "platforms": 2,
+    "closed": 0,
+    "decisions": 10,
+    "holds": 10,
+    "short_turns": 0,
+    "cancels": 0,
+    "turn_points": 0,
+    "avoidable": 45,
+    "optimal": 194,
+    "greedy_gap": 0.8267,
+    "closed_min": 0,
+    "slow_min": 64,
+    "track_min": 170,
+    "single_closed": false,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 4,
+   "checks": 3,
+   "seconds": 76.3,
+   "input_tokens": 56624,
+   "cache_read_tokens": 36772,
+   "cache_write_tokens": 19836,
+   "output_tokens": 8659,
+   "served_by": [
+    "claude-sonnet-5-5"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37328",
+     "hold": {
+      "BP": "08:37"
+     }
+    },
+    {
+     "train": "37423",
+     "hold": {
+      "FWD": "09:34"
+     }
+    },
+    {
+     "train": "37427",
+     "hold": {
+      "FWD": "10:35",
+      "HDG": "10:42"
+     }
+    }
+   ]
+  },
+  {
+   "model": "claude-sonnet-5-5@high",
+   "task_id": "gnlw-2025-05-20-1530-180m-loop-0",
+   "split": "train",
+   "difficulty": "loop",
+   "day": "2025-05-20",
+   "runs": 30,
+   "reward": 0.828085,
+   "submitted": true,
+   "feasible": true,
+   "cost": 144,
+   "optimal_cost": 129,
+   "floor_cost": 105,
+   "greedy_cost": 803,
+   "real_cost": 1630,
+   "hardness": {
+    "runs": 30,
+    "sets": 7,
+    "stops": 202,
+    "conflicts": 7,
+    "single_track": 1,
+    "headway": 4,
+    "platforms": 2,
+    "closed": 0,
+    "decisions": 21,
+    "holds": 21,
+    "short_turns": 0,
+    "cancels": 0,
+    "turn_points": 0,
+    "avoidable": 24,
+    "optimal": 129,
+    "greedy_gap": 0.8,
+    "closed_min": 0,
+    "slow_min": 0,
+    "track_min": 150,
+    "single_closed": false,
+    "mid_line": false,
+    "late_sets": 0
+   },
+   "violations": 0,
+   "agent_turns": 4,
+   "checks": 3,
+   "seconds": 169.6,
+   "input_tokens": 111337,
+   "cache_read_tokens": 67253,
+   "cache_write_tokens": 44068,
+   "output_tokens": 21782,
+   "served_by": [
+    "claude-sonnet-5-5"
+   ],
+   "end_reason": "submitted",
+   "errors": 0,
+   "plan": [
+    {
+     "train": "37449",
+     "hold": {
+      "HDG": "16:01"
+     }
+    },
+    {
+     "train": "37358",
+     "hold": {
+      "LW": "15:55",
+      "HDG": "16:03",
+      "FWD": "16:10"
+     }
+    },
+    {
+     "train": "37349",
+     "hold": {
+      "BP": "15:59"
+     }
+    },
+    {
+     "train": "37458",
+     "hold": {
+      "BP": "16:19"
+     }
+    }
+   ]
+  }
+ ]
+}

tasks/rail-v1-eval/manifest.json

@@ -0,0 +1,92 @@
+{
+  "name": "rail-v1-eval",
+  "split": "eval",
+  "tasks": 45,
+  "file": "tasks.jsonl",
+  "tiers": {
+    "blockage": 20,
+    "compound": 17,
+    "loop": 4,
+    "real": 4
+  },
+  "sha256": "2b4347efbc1b0aef26225aeebd451e64f4a3bf427f41a0a7e4618795d5db034b",
+  "candidates": 134,
+  "days": [
+    "2025-01-20",
+    "2025-01-21",
+    "2025-01-22",
+    "2025-01-23",
+    "2025-01-25",
+    "2025-01-26",
+    "2025-02-11",
+    "2025-02-12",
+    "2025-02-13",
+    "2025-02-14",
+    "2025-02-15",
+    "2025-02-16",
+    "2025-03-10",
+    "2025-03-11",
+    "2025-03-12",
+    "2025-03-13",
+    "2025-03-16",
+    "2025-04-23",
+    "2025-04-25",
+    "2025-04-26",
+    "2025-04-27",
+    "2025-05-26",
+    "2025-05-27",
+    "2025-05-28",
+    "2025-05-30",
+    "2025-05-31",
+    "2025-06-22"
+  ],
+  "proven_optimal": 45,
+  "runs": [
+    15,
+    38
+  ],
+  "source": "Rijden de Treinen train archive and disruptions, 2024-2025 (CC BY 4.0); OpenStreetMap (ODbL); see data/gnlw/SOURCE.md",
+  "selected_from": "pool-eval",
+  "selection": {
+    "calibration_episodes": 16,
+    "features": [
+      "runs",
+      "conflicts",
+      "decisions",
+      "holds",
+      "short_turns",
+      "turn_points",
+      "avoidable",
+      "slow_min",
+      "track_min",
+      "single_closed"
+    ],
+    "lambda": 3.0,
+    "weights": {
+      "intercept": 0.5618,
+      "runs": 0.0715,
+      "conflicts": 0.0631,
+      "decisions": -0.0708,
+      "holds": -0.0433,
+      "short_turns": -0.0466,
+      "turn_points": -0.1022,
+      "avoidable": 0.0245,
+      "slow_min": -0.0429,
+      "track_min": 0.1,
+      "single_closed": 0.0544
+    },
+    "loo_mae": 0.1343,
+    "loo_spearman": 0.6676,
+    "calibration_mean_reward": 0.5572,
+    "pool": 72,
+    "chosen": 45,
+    "per_tier": {
+      "blockage": 20,
+      "compound": 17,
+      "loop": 4,
+      "real": 4
+    },
+    "predicted_mean_chosen": 0.443,
+    "predicted_mean_pool": 0.5628
+  }
+}

tasks/rail-v1-eval/selection.json

@@ -0,0 +1,116 @@
+{
+ "calibration_episodes": 16,
+ "features": [
+  "runs",
+  "conflicts",
+  "decisions",
+  "holds",
+  "short_turns",
+  "turn_points",
+  "avoidable",
+  "slow_min",
+  "track_min",
+  "single_closed"
+ ],
+ "lambda": 3.0,
+ "weights": {
+  "intercept": 0.5618,
+  "runs": 0.0715,
+  "conflicts": 0.0631,
+  "decisions": -0.0708,
+  "holds": -0.0433,
+  "short_turns": -0.0466,
+  "turn_points": -0.1022,
+  "avoidable": 0.0245,
+  "slow_min": -0.0429,
+  "track_min": 0.1,
+  "single_closed": 0.0544
+ },
+ "loo_mae": 0.1343,
+ "loo_spearman": 0.6676,
+ "calibration_mean_reward": 0.5572,
+ "pool": 72,
+ "chosen": 45,
+ "per_tier": {
+  "blockage": 20,
+  "compound": 17,
+  "loop": 4,
+  "real": 4
+ },
+ "predicted_mean_chosen": 0.443,
+ "predicted_mean_pool": 0.5628,
+ "predictions": {
+  "gnlw-2025-02-12-0900-180m-real-0": 0.1894,
+  "gnlw-2025-04-26-0630-180m-blockage-0": 0.2287,
+  "gnlw-2025-03-16-1700-210m-compound-0": 0.2512,
+  "gnlw-2025-04-27-0830-210m-blockage-0": 0.2549,
+  "gnlw-2025-01-20-1800-180m-compound-0": 0.2581,
+  "gnlw-2025-01-26-1700-210m-compound-0": 0.273,
+  "gnlw-2025-02-14-1730-210m-blockage-0": 0.2856,
+  "gnlw-2025-02-15-0630-180m-blockage-0": 0.3048,
+  "gnlw-2025-04-27-0800-210m-compound-0": 0.3232,
+  "gnlw-2025-05-31-0900-180m-compound-0": 0.3594,
+  "gnlw-2025-01-25-1700-180m-blockage-0": 0.363,
+  "gnlw-2025-02-15-1630-150m-loop-0": 0.3773,
+  "gnlw-2025-05-30-0630-180m-blockage-0": 0.3973,
+  "gnlw-2025-02-13-0954-180m-real-0": 0.4004,
+  "gnlw-2025-02-11-0900-150m-blockage-0": 0.4051,
+  "gnlw-2025-01-23-0900-180m-compound-0": 0.4195,
+  "gnlw-2025-04-26-1700-180m-blockage-0": 0.4247,
+  "gnlw-2025-02-13-1530-180m-blockage-0": 0.4299,
+  "gnlw-2025-03-12-1730-210m-loop-0": 0.441,
+  "gnlw-2025-02-16-1730-240m-compound-0": 0.4457,
+  "gnlw-2025-05-26-0730-150m-blockage-0": 0.4553,
+  "gnlw-2025-01-25-0630-180m-loop-0": 0.4555,
+  "gnlw-2025-04-23-1630-150m-blockage-0": 0.4577,
+  "gnlw-2025-03-12-1530-180m-blockage-0": 0.4677,
+  "gnlw-2025-01-23-0800-210m-compound-0": 0.472,
+  "gnlw-2025-01-25-0730-180m-compound-0": 0.4929,
+  "gnlw-2025-05-27-0830-210m-blockage-0": 0.4951,
+  "gnlw-2025-05-26-1800-150m-blockage-0": 0.4972,
+  "gnlw-2025-03-13-0706-180m-real-0": 0.5019,
+  "gnlw-2025-06-22-1600-240m-compound-0": 0.5068,
+  "gnlw-2025-03-16-1630-180m-compound-0": 0.5089,
+  "gnlw-2025-03-10-0700-210m-blockage-0": 0.5156,
+  "gnlw-2025-02-15-0700-240m-compound-0": 0.5177,
+  "gnlw-2025-01-21-0626-180m-real-0": 0.525,
+  "gnlw-2025-02-16-1700-210m-compound-0": 0.5306,
+  "gnlw-2025-05-27-1700-180m-blockage-0": 0.5325,
+  "gnlw-2025-02-16-1530-210m-compound-0": 0.5331,
+  "gnlw-2025-01-22-1600-240m-compound-0": 0.5439,
+  "gnlw-2025-01-25-1800-150m-blockage-0": 0.5567,
+  "gnlw-2025-04-25-1730-210m-blockage-0": 0.5697,
+  "gnlw-2025-05-26-1630-150m-blockage-0": 0.5737,
+  "gnlw-2025-05-28-1830-210m-compound-0": 0.5761,
+  "gnlw-2025-01-22-1800-150m-loop-0": 0.5792,
+  "gnlw-2025-05-27-1830-180m-blockage-0": 0.5939,
+  "gnlw-2025-03-11-0730-150m-blockage-0": 0.5968,
+  "gnlw-2025-05-31-0800-210m-compound-0": 0.605,
+  "gnlw-2025-04-25-0700-210m-blockage-0": 0.6173,
+  "gnlw-2025-02-14-1830-180m-blockage-0": 0.6397,
+  "gnlw-2025-04-27-1700-210m-compound-0": 0.645,
+  "gnlw-2025-05-27-0730-150m-blockage-0": 0.6544,
+  "gnlw-2025-05-31-0630-180m-blockage-0": 0.6643,
+  "gnlw-2025-02-12-1830-180m-blockage-0": 0.6643,
+  "gnlw-2025-02-12-0700-210m-blockage-0": 0.6749,
+  "gnlw-2025-04-26-0630-210m-compound-0": 0.6751,
+  "gnlw-2025-04-25-0730-180m-compound-0": 0.6791,
+  "gnlw-2025-04-25-0630-180m-loop-0": 0.6867,
+  "gnlw-2025-04-27-1700-180m-blockage-0": 0.7217,
+  "gnlw-2025-02-12-1800-180m-compound-0": 0.7405,
+  "gnlw-2025-01-25-1830-180m-loop-0": 0.7664,
+  "gnlw-2025-03-12-0830-210m-loop-0": 0.7672,
+  "gnlw-2025-04-25-1800-180m-compound-0": 0.7813,
+  "gnlw-2025-03-14-0821-180m-real-0": 0.7952,
+  "gnlw-2025-02-15-0800-180m-loop-0": 0.8057,
+  "gnlw-2025-02-10-0830-210m-loop-0": 0.8268,
+  "gnlw-2025-01-25-0630-180m-blockage-0": 0.8333,
+  "gnlw-2025-02-14-1700-180m-loop-0": 0.834,
+  "gnlw-2025-02-14-0730-180m-compound-0": 0.8568,
+  "gnlw-2025-04-23-1700-180m-blockage-0": 0.8771,
+  "gnlw-2025-04-26-0700-240m-compound-0": 0.9031,
+  "gnlw-2025-06-22-0830-240m-compound-0": 0.9419,
+  "gnlw-2025-03-12-1700-210m-compound-0": 0.974,
+  "gnlw-2025-05-27-0830-240m-compound-0": 1.0029
+ }
+}

tasks/rail-v1-train/manifest.json

@@ -0,0 +1,106 @@
+{
+  "name": "rail-v1-train",
+  "split": "train",
+  "tasks": 159,
+  "file": "tasks.jsonl",
+  "tiers": {
+    "blockage": 65,
+    "compound": 51,
+    "loop": 39,
+    "real": 4
+  },
+  "sha256": "4b1abf5acec175d2f24c5ec6ade8721a82932eda280d514ff3d9285e0a8501b2",
+  "candidates": 292,
+  "days": [
+    "2025-01-01",
+    "2025-01-02",
+    "2025-01-03",
+    "2025-01-04",
+    "2025-01-05",
+    "2025-01-07",
+    "2025-01-08",
+    "2025-01-13",
+    "2025-01-14",
+    "2025-01-15",
+    "2025-01-16",
+    "2025-01-19",
+    "2025-01-28",
+    "2025-01-29",
+    "2025-01-30",
+    "2025-02-01",
+    "2025-02-02",
+    "2025-02-03",
+    "2025-02-04",
+    "2025-02-05",
+    "2025-02-07",
+    "2025-02-08",
+    "2025-02-19",
+    "2025-02-20",
+    "2025-02-22",
+    "2025-02-24",
+    "2025-02-26",
+    "2025-02-27",
+    "2025-02-28",
+    "2025-03-03",
+    "2025-03-06",
+    "2025-03-09",
+    "2025-03-17",
+    "2025-03-19",
+    "2025-03-20",
+    "2025-03-22",
+    "2025-03-24",
+    "2025-03-25",
+    "2025-03-26",
+    "2025-03-27",
+    "2025-03-29",
+    "2025-03-30",
+    "2025-03-31",
+    "2025-04-01",
+    "2025-04-02",
+    "2025-04-03",
+    "2025-04-04",
+    "2025-04-05",
+    "2025-04-06",
+    "2025-04-07",
+    "2025-04-08",
+    "2025-04-09",
+    "2025-04-10",
+    "2025-04-11",
+    "2025-04-12",
+    "2025-04-14",
+    "2025-04-15",
+    "2025-04-17",
+    "2025-04-19",
+    "2025-04-29",
+    "2025-04-30",
+    "2025-05-01",
+    "2025-05-03",
+    "2025-05-04",
+    "2025-05-05",
+    "2025-05-06",
+    "2025-05-07",
+    "2025-05-08",
+    "2025-05-09",
+    "2025-05-11",
+    "2025-05-12",
+    "2025-05-13",
+    "2025-05-15",
+    "2025-05-17",
+    "2025-05-19",
+    "2025-05-20",
+    "2025-05-21",
+    "2025-06-02",
+    "2025-06-04",
+    "2025-06-06",
+    "2025-06-07",
+    "2025-06-08",
+    "2025-06-09",
+    "2025-06-10"
+  ],
+  "proven_optimal": 159,
+  "runs": [
+    15,
+    38
+  ],
+  "source": "Rijden de Treinen train archive and disruptions, 2024-2025 (CC BY 4.0); OpenStreetMap (ODbL); see data/gnlw/SOURCE.md"
+}