Land PR #15 surgical fixes (Windows safety + human-play hints)

Most of PR #15 is BEHIND pr13-revised on the .py source — Wave-12/13
+ narrative-rewrite + the Phase-1 Controller landed since the PR was
authored, so picking PR #15's agent.py / eval_core.py / prompt_v2.py
/ minimap.py / one_v_one.py wholesale would revert the new tools
(capture_actor / c4_detonate / infiltrate / fire_superweapon),
the RustEnvPool compat layer, and the controller abstraction we
already have (openra_bench/controller.py is byte-identical to PR
#15's version — same Phase-1 design).

Picked surgically:
- openra_bench/playback.py — Windows-illegal filename chars in cell
names get sanitised; data: URL prefix stripped from base64 PNGs
before write. Both purely additive.
- openra_bench/scenarios/loader.py — explicit utf-8 encoding on
load_pack (Windows-locale safety). Dropped PR #15's reversion of
is_map_supported(dict) — our generator-spec handling is newer.
- openra_bench/human_labeling.py — added
_objective_regions_from_condition + _initial_type_by_id helpers
and wired them into InteractiveSession (objective-region overlay
on the Play tab, type-by-id inference for own units). PRESERVED
the fog_mode parameter (our addition; PR #15 dropped it).
Made _pb_frame robust: prompt_v2.minimap_b64 wrapped in
try/except with minimap.render_b64 fallback.
- .gitignore — added node_modules/ (for the E2E test infra landed
in the previous commit) and playback/human-*/ (tester-specific
Playback fixtures).
- README.md — taken from PR #19 (purely-additive Mission Player
section).

Skipped wholesale (PR #15 strictly behind us):
openra_bench/{agent,eval_core,minimap,prompt_v2,one_v_one,
mapgen,full_playback,handoff,human_study,playback_view,
providers,run_eval,game_knowledge}.py
PR #15's diff for these is mostly deletions of our newer code.

.gitignore

@@ -16,3 +16,9 @@ data/runs/paper-v1-**/*.partial
 data/runs/paper-v1-**/*.png
 data/runs/paper-v1-**/.logs/
 data/runs/_archive_*/
+
+# Site E2E test infra (PR #19)
+node_modules/
+
+# Local Playback fixtures (tester-specific human runs)
+playback/human-*/

README.md

@@ -21,6 +21,8 @@ Standardized benchmark and leaderboard for AI agents playing Red Alert through [
 - **Evaluation harness**: Automated N-game benchmarking with metrics collection
 - **OpenEnv rubrics**: Composable scoring (win/loss, military efficiency, economy)
 - **Replay verification**: Replay files linked to leaderboard entries
+- **Mission Player**: Static game-like website for browsing, annotating, and reviewing scenarios
+- **Bilingual**: English and Chinese scenario instructions generated deterministically
 
 ## Quick Start
 
@@ -94,6 +96,47 @@ The Gradio app exposes these API endpoints (Gradio 5+ SSE protocol):
 | `submit_with_replay` | Submit JSON + replay file |
 | `filter_leaderboard` | Query/filter leaderboard data |
 
+## Mission Player (Static Site)
+
+A game-like mission selection and annotation website in `site/`. No framework, no build step -- a single HTML file deployable to GitHub Pages.
+
+### For players / annotators
+
+Open `site/index.html` via any HTTP server:
+
+```bash
+cd site && python3 -m http.server 8765
+# Open http://localhost:8765/index.html
+```
+
+Workflow: browse scenario cards, pick a mission, read bilingual objectives (EN/ZH toggle), switch difficulty (easy/medium/hard), annotate the map with point/region tools, tag and add notes, mark complete, navigate to next mission, export annotations as JSON.
+
+### For maintainers
+
+Generate or refresh static data after scenario changes:
+
+```bash
+python site/generate.py            # generate scenarios.json + map thumbnails
+python site/generate.py --dry-run  # print counts without writing
+```
+
+Map thumbnails require the Rust engine wheel (`openra_train`). Without it, the site works with a placeholder map area; annotations still work on the placeholder.
+
+Deploy by copying `site/index.html` and `site/public/` to any static host.
+
+See `docs/IMPLEMENTATION_NOTES.md` for full details.
+
+### Running tests
+
+```bash
+# Data pipeline + coverage invariant tests (Python)
+python -m pytest tests/test_site.py tests/test_app.py -v
+
+# E2E DOM interaction tests (Node.js + jsdom)
+npm install   # first time only
+node tests/test_site_e2e.mjs
+```
+
 ## Scoring
 
 | Component | Weight | Description |

openra_bench/human_labeling.py

@@ -47,6 +47,126 @@ TurnActions = "list[HumanAction]"
 InputSource = "Callable[[dict], list[HumanAction]] | Sequence[list[HumanAction]]"
 
 
+# ── Scenario hints for human play ───────────────────────────────────
+
+_REGION_PREDICATES = {
+    "reach_region",
+    "units_in_region_gte",
+    "units_of_type_in_region_gte",
+    "all_units_in_region",
+    "building_in_region",
+    "enemy_key_buildings_destroyed_in_region",
+}
+
+
+def _condition_node(cond: Any) -> dict:
+    if cond is None:
+        return {}
+    if isinstance(cond, dict):
+        return cond
+    return dict(getattr(cond, "__pydantic_extra__", None) or {})
+
+
+def _objective_regions_from_condition(cond: Any) -> list[dict]:
+    """Extract authored objective regions from a win-condition tree."""
+    out: list[dict] = []
+
+    def walk(node: Any) -> None:
+        data = _condition_node(node)
+        if not data:
+            return
+        for child in data.get("all_of") or []:
+            walk(child)
+        for child in data.get("any_of") or []:
+            walk(child)
+        if "not" in data:
+            walk(data["not"])
+        then = data.get("then")
+        if isinstance(then, dict):
+            for child in then.get("clauses") or []:
+                walk(child)
+        seq = data.get("waypoint_sequence")
+        if isinstance(seq, dict):
+            default_r = seq.get("radius", 6)
+            for i, point in enumerate(seq.get("points") or [], start=1):
+                if not isinstance(point, dict):
+                    continue
+                if "x" in point and "y" in point:
+                    out.append({
+                        "x": int(point["x"]),
+                        "y": int(point["y"]),
+                        "radius": float(point.get("radius", default_r)),
+                        "label": str(point.get("label") or f"W{i}"),
+                    })
+        for key in _REGION_PREDICATES:
+            v = data.get(key)
+            if not isinstance(v, dict) or "x" not in v or "y" not in v:
+                continue
+            label = v.get("label")
+            if not label:
+                if key == "units_in_region_gte":
+                    label = f">={int(v.get('n', 1))} units"
+                elif key == "units_of_type_in_region_gte":
+                    label = f">={int(v.get('n', 1))} {v.get('type')}"
+                elif key == "building_in_region":
+                    label = str(v.get("type") or "building")
+                else:
+                    label = key.replace("_", " ")
+            out.append({
+                "x": int(v["x"]),
+                "y": int(v["y"]),
+                "radius": float(v.get("radius", 3)),
+                "label": str(label),
+            })
+
+    walk(cond)
+    seen = set()
+    unique = []
+    for r in out:
+        key = (r["x"], r["y"], r["radius"], r["label"])
+        if key in seen:
+            continue
+        seen.add(key)
+        unique.append(r)
+    return unique
+
+
+def _initial_type_by_id(scenario: Any, render_state: dict) -> dict[str, str]:
+    """Infer own unit types from authored initial placements.
+
+    Rust currently omits own-unit actor types in some observations, but
+    it preserves deterministic actor ids and initial cells. This maps the
+    initial visible units back to the scenario placements so the human UI
+    can distinguish 1tnk/2tnk/etc. after the units move.
+    """
+    expected: dict[tuple[int, int], list[str]] = {}
+    for actor in getattr(scenario, "actors", []) or []:
+        if str(getattr(actor, "owner", "")).lower() != "agent":
+            continue
+        pos = getattr(actor, "position", None)
+        if not pos or len(pos) < 2:
+            continue
+        cell = (int(pos[0]), int(pos[1]))
+        atype = str(getattr(actor, "type", "") or "").lower()
+        count = int(getattr(actor, "count", 1) or 1)
+        expected.setdefault(cell, []).extend([atype] * count)
+
+    observed: dict[tuple[int, int], list[str]] = {}
+    for unit in render_state.get("units_summary") or []:
+        if not isinstance(unit, dict) or unit.get("id") is None:
+            continue
+        cell = (int(unit.get("cell_x", 0)), int(unit.get("cell_y", 0)))
+        observed.setdefault(cell, []).append(str(unit["id"]))
+
+    out: dict[str, str] = {}
+    for cell, types in expected.items():
+        ids = sorted(observed.get(cell, []))
+        for uid, atype in zip(ids, types):
+            if atype:
+                out[uid] = atype
+    return out
+
+
 # ── Pixel ⇄ cell transforms ─────────────────────────────────────────
 
 
@@ -492,6 +612,13 @@ class InteractiveSession:
         self._env = self._pool.acquire()
         self._adapter = RustObsAdapter()
         self._adapter.observe(self._env.reset(seed=seed))
+        self._adapter.type_by_id.update(
+            _initial_type_by_id(compiled.scenario, self._adapter.render_state())
+        )
+        self._objective_regions = (
+            _objective_regions_from_condition(compiled.win_condition)
+            if compiled.objective_coords == "exact" else []
+        )
         self._forbidden = {
             str(t).lower() for t in (compiled.forbidden_tools or [])
         }
@@ -571,7 +698,10 @@ class InteractiveSession:
     def render_state(self) -> dict:
         """The current observation — the SAME render_state an LLM agent
         is shown for this scenario."""
-        return self._adapter.render_state()
+        rs = self._adapter.render_state()
+        if self._objective_regions:
+            rs["objective_regions"] = list(self._objective_regions)
+        return rs
 
     def status(self) -> dict:
         """Turn / outcome / done summary for the UI."""
@@ -636,16 +766,20 @@ class InteractiveSession:
                 self._pb_terrain = terrain_png_for(
                     self.compiled.scenario.base_map
                 )
-            from .prompt_v2 import minimap_b64 as _v2_mm
+            png = None
+            try:
+                from .prompt_v2 import minimap_b64 as _v2_mm
 
-            png = _v2_mm(
-                rs, self._pb_terrain, self._pb_explored,
-                constant_colors=self.compiled.level in ("easy", "medium"),
-            )
+                png = _v2_mm(
+                    rs, self._pb_terrain, self._pb_explored,
+                    constant_colors=self.compiled.level in ("easy", "medium"),
+                )
+            except Exception:  # noqa: BLE001
+                pass
             if png is None:
-                from .agent import _render_minimap_b64
+                from .minimap import render_b64
 
-                png = _render_minimap_b64(rs, self._pb_terrain)
+                png = render_b64(rs, self._pb_terrain)
             return png
         except Exception:  # noqa: BLE001
             return None

openra_bench/playback.py

@@ -45,7 +45,11 @@ class Playback:
     """Per-episode recorder. Create one per (scenario, seed)."""
 
     def __init__(self, root: str | Path, cell: str, seed: int):
-        self.dir = Path(root) / cell.replace("/", "_") / f"seed{seed}"
+        safe_cell = "".join(
+            ch if ch not in '<>:"/\\|?*' and ord(ch) >= 32 else "_"
+            for ch in str(cell)
+        )
+        self.dir = Path(root) / safe_cell / f"seed{seed}"
         self.dir.mkdir(parents=True, exist_ok=True)
         self._turns_fh = open(self.dir / "turns.jsonl", "w")
         self._n = 0
@@ -67,6 +71,8 @@ class Playback:
         self._n += 1
         if minimap_png_b64:
             try:
+                if "," in minimap_png_b64 and minimap_png_b64.lstrip().startswith("data:"):
+                    minimap_png_b64 = minimap_png_b64.split(",", 1)[1]
                 (self.dir / f"minimap_turn{turn:03d}.png").write_bytes(
                     base64.b64decode(minimap_png_b64)
                 )

openra_bench/scenarios/loader.py

@@ -50,7 +50,7 @@ def resolve_map_path(base_map: str) -> Path | None:
 def load_pack(path: str | Path) -> ScenarioPack:
     """Parse and validate a single pack YAML."""
     path = Path(path)
-    with open(path) as f:
+    with open(path, encoding="utf-8") as f:
         data = yaml.safe_load(f)
     try:
         return ScenarioPack(**data)