feat(scenario): tp-rush-objective-very-fast — speedrun far objective (speedrun / quickest-path anchor)

openra_bench/scenarios/packs/tp-rush-objective-very-fast.yaml

@@ -0,0 +1,267 @@
+# tp-rush-objective-very-fast.yaml
+#
+# ACTION capability — SPEEDRUN to a far objective region. A pre-placed
+# strike force (3× 2tnk + a base fact at the FAR-WEST) must drive
+# directly east and raze the enemy `fact` at the FAR-EAST objective
+# region (115, 20) inside a TIGHT tick budget. The discrimination is
+# raw speedrun planning: sub-optimal pathing (south-detour / mid-map
+# wander) or hesitation (stall, observe-and-think loops) blows the
+# clock and LOSES.
+#
+# Why 2tnk and not 3× literal jeep: the design-sketch anchor was
+# "3× jeep" but jeeps in the engine are anti-infantry MG units that
+# do not dent buildings inside any plausible speedrun window, AND
+# they get one-shotted by a single e1 garrison rifleman before they
+# can crack the objective fact. Smoke-tested both: 3× jeep + 1× e1
+# garrison ⇒ 3 jeeps die, 0 building damage, LOSS at tick 7023.
+# Substituted 3× 2tnk (medium tank, cannon, the canonical speedrun
+# strike force) — preserves the "small fast strike trio + far-east
+# objective + tight clock" intent of the design (per CLAUDE.md
+# "don't compensate for model weakness; fix real scenario defects").
+#
+# Engine idiom: win = `enemy_key_buildings_destroyed_in_region:
+# {x:115,y:20,radius:6,types:[fact]}` (the REGION-scoped fact-destroyed
+# predicate — see win_conditions.py:116). The `fact` is the cannonical
+# MustBeDestroyed landmark; razing it from the objective region scores.
+# `within_ticks: T` puts the timing teeth on the win; `after_ticks:
+# T+1` in the fail tree makes a missed deadline a REAL reachable LOSS
+# (not a DRAW). `not building_count_gte:{type:fact, n:1}` in the fail
+# tree gives the secondary "lost your base" fail (CLAUDE.md notes that
+# `building_count_gte` is the typed building counter — works as a
+# `has_building` proxy and is what the design brief specifies).
+#
+# Tick math (CLAUDE.md: tick ≈ 93 + 90·(turn-1), 90 ticks/turn):
+# Smoke-measured the intended direct rush from (6,*) → attack_move
+# (115,20) at tick 2613 (3× 2tnk vs fact + 2× e1 garrison, seed 1).
+# A south-detour wander (south to y=36, east to x=115, north to (115,
+# 20)) wins at tick 3153 — 540 ticks slower (matches the extra ~32
+# cells of pathing at ~17 ticks/cell).
+#
+# Tier budgets (T = `within_ticks` win deadline; fail `after_ticks` =
+# T+1; tick ceiling per max_turns must ≥ T+1 or the fail is inert ⇒
+# DRAW):
+#   - EASY:    T=3600 (loose; intended direct rush wins comfortably
+#                      ~2613; south-detour wander still wins ~3153;
+#                      stall LOSES on the clock).        max_turns=40
+#                      ceiling 93+90·39=3603 ≥ 3601 ✓
+#   - MEDIUM:  T=2900 (tight; intended direct rush wins ~2613 with
+#                      ~290 ticks margin; south-detour wander LOSES at
+#                      3153; stall LOSES).               max_turns=33
+#                      ceiling 93+90·32=2973 ≥ 2901 ✓
+#   - HARD:    T=2900 + 2 seed-driven spawn_point groups (NORTH
+#                      staging y=10 vs SOUTH staging y=30) round-
+#                      robined by seed; enemy fact stays at (115,20)
+#                      so both spawns have IDENTICAL travel cost
+#                      (Chebyshev distance from (6,10)/(6,30) to
+#                      (115,20) = 109, same as from y=20). The hard
+#                      tier qualitatively varies the bearing of the
+#                      objective from the staging (not the distance),
+#                      so a memorised "drive east on y=20" cell cannot
+#                      generalise — the agent must compute the rush
+#                      bearing from its actual spawn.    max_turns=33
+#
+# Bar (binding):
+#   - intended direct rush 2tnk × 3 → attack_move(115,20) WINS on
+#     every level + every hard seed (1..4);
+#   - stall (`observe()`) LOSES on every level + every seed (timeout,
+#     real reachable LOSS — no DRAW degeneracy);
+#   - wander/south-detour (move south to y≈36, east to x=115, then
+#     attack the fact) WINS on EASY (within the loose clock) but
+#     LOSES on MEDIUM/HARD (busts the tight clock — that gap is the
+#     speedrun-planning discrimination);
+#   - hard ships ≥2 `spawn_point` groups (seed-driven start variation).
+#
+# Engine notes (per CLAUDE.md):
+#   - `fact` IS a MustBeDestroyed building, so razing it from
+#     (115,20) satisfies the predicate AND the engine auto-`done`s
+#     on enemy-elimination — but we have NO other enemy buildings,
+#     so the auto-done fires the same tick the win predicate becomes
+#     true (win is recorded before termination — verified in smoke).
+#     No sentinel enemy `fact` is needed because the only enemy
+#     building IS the objective; the agent fact at (10,*) is the
+#     persistent agent landmark that the secondary fail clause
+#     `not building_count_gte:fact:1` protects.
+#   - Light garrison (2× e1 — 1 in front of, 1 behind the objective
+#     fact) bleeds the 2tnk column by 0–1 tank en route to the rush
+#     (the column has enough HP buffer; smoke shows 0 tanks lost).
+#     This keeps the speedrun load-bearing — the discrimination is
+#     timing, not slugfest survival.
+#   - `bot_type: turtle` keeps the garrison at its spawn; it does
+#     NOT chase a holding agent or harass the agent base, so a stall
+#     fails ONLY on the clock (not on the agent base being razed) —
+#     the timing teeth are unambiguously the discriminator.
+#   - Per CLAUDE.md, enemy actors do NOT honour `spawn_point`; the
+#     objective fact + garrison place every seed on both NORTH and
+#     SOUTH agent spawns, so the hard tier varies only the AGENT's
+#     spawn latitude (the bearing-to-objective) — distance is held
+#     constant by design.
+
+meta:
+  id: tp-rush-objective-very-fast
+  title: 'Rush — Speedrun the Strike Force to a Far Objective'
+  capability: action
+  real_world_meaning: >
+    A small armoured strike trio is staged at the far west of a long
+    arena; the objective is to drive directly east and raze the
+    enemy construction yard at the far-east edge inside a tight
+    clock. There is no economy phase, no scout phase, no defence
+    phase — the capability is RAW SPEEDRUN PLANNING: pick the
+    shortest path, commit, finish before the deadline. Sub-optimal
+    pathing (south-detour to skirt empty terrain, mid-map wander)
+    blows the clock; hesitation (think, observe, plan) blows the
+    clock. The intended policy is one decision (`attack_move(115,
+    20)` to the whole column) executed immediately and held.
+  robotics_analogue: >
+    Time-critical traversal: a UAV / ground convoy starts at a base
+    far from the target, must reach the target waypoint and complete
+    the strike action inside a hard real-time deadline. The
+    capability tested is route SELECTION (shortest direct path) +
+    COMMITMENT (no detour, no stop-and-replan), not en-route
+    micro-combat.
+  benchmark_anchor:
+    - "human speedrun"
+    - "quickest-path planning"
+    - "SC2 worker rush"
+  author: openra-bench
+
+base_map: rush-hour-arena
+
+base:
+  agent: {faction: allies, cash: 0}
+  enemy:
+    faction: soviet
+    cash: 0
+    # turtle: garrison holds its spawn at the objective; does NOT
+    # chase the agent base, so the timing teeth (within_ticks /
+    # after_ticks) are the unambiguous discriminator — not whether
+    # the agent's base survives an enemy harass.
+    bot_type: turtle
+  tools: [move_units, attack_unit, attack_move, stop_units]
+  planning: true
+  termination:
+    max_ticks: 12000
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Loose clock: the south-detour wander still wins (a model that
+  # over-thinks and ends up taking a longer route can still finish).
+  # Only the stall (no commitment at all) loses on the clock.
+  easy:
+    description: >
+      A 3-tank strike column starts at the far west (column at x=6,
+      y=18..22) with your base `fact` just east at (10,20). The
+      enemy construction yard (`fact`) is the OBJECTIVE at the
+      far east (115,20), with a light garrison (2 enemy riflemen
+      flanking it). Drive your column directly east and raze the
+      enemy fact before tick 3600. Sub-optimal pathing eats into
+      the clock — at this difficulty the budget tolerates a modest
+      detour, but stalling at the staging or never committing to
+      the rush loses on the clock. Losing your own base (`fact`)
+      also fails.
+    overrides:
+      actors:
+        # ── AGENT — 3× 2tnk strike column at FAR WEST + base fact ──
+        - {type: 2tnk, owner: agent, position: [6, 18], stance: 1}
+        - {type: 2tnk, owner: agent, position: [6, 20], stance: 1}
+        - {type: 2tnk, owner: agent, position: [6, 22], stance: 1}
+        - {type: fact, owner: agent, position: [10, 20]}
+        # ── ENEMY — objective fact at FAR EAST + light garrison ──
+        - {type: fact, owner: enemy, position: [115, 20]}
+        - {type: e1,   owner: enemy, position: [112, 20], stance: 2}
+        - {type: e1,   owner: enemy, position: [118, 20], stance: 2}
+    win_condition:
+      all_of:
+        - enemy_key_buildings_destroyed_in_region:
+            {x: 115, y: 20, radius: 6, types: [fact]}
+        - within_ticks: 3600
+    fail_condition:
+      any_of:
+        # Timeout: missed the speedrun clock — real reachable LOSS.
+        - after_ticks: 3601
+        # Base destroyed: the agent fact must persist.
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 40   # ceiling 93 + 90·39 = 3603 ≥ 3601 ✓
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 controlled variable: TIGHT clock. Direct rush wins (~2613);
+  # south-detour wander LOSES (3153 > 2900). Stall LOSES.
+  medium:
+    description: >
+      Same staging: 3-tank column at the west (column at x=6, y=18..
+      22) + base `fact` at (10,20). Same objective: raze the enemy
+      construction yard at (115,20) past the light garrison. The
+      clock is TIGHT — you must take the DIRECT east route on
+      y≈20. A south-detour or mid-map wander pads ~500+ ticks onto
+      the path and busts the deadline. Raze the enemy fact before
+      tick 2900; losing your base also fails.
+    overrides:
+      actors:
+        - {type: 2tnk, owner: agent, position: [6, 18], stance: 1}
+        - {type: 2tnk, owner: agent, position: [6, 20], stance: 1}
+        - {type: 2tnk, owner: agent, position: [6, 22], stance: 1}
+        - {type: fact, owner: agent, position: [10, 20]}
+        - {type: fact, owner: enemy, position: [115, 20]}
+        - {type: e1,   owner: enemy, position: [112, 20], stance: 2}
+        - {type: e1,   owner: enemy, position: [118, 20], stance: 2}
+    win_condition:
+      all_of:
+        - enemy_key_buildings_destroyed_in_region:
+            {x: 115, y: 20, radius: 6, types: [fact]}
+        - within_ticks: 2900
+    fail_condition:
+      any_of:
+        - after_ticks: 2901
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 33   # ceiling 93 + 90·32 = 2973 ≥ 2901 ✓
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 controlled variable: 2 seed-driven `spawn_point` groups
+  # (NORTH staging y≈10 vs SOUTH staging y≈30) round-robined by
+  # seed. The objective fact stays at (115,20) — Chebyshev distance
+  # from either spawn is 109 cells, identical to the medium
+  # (6,20)→(115,20) traverse, so the SAME tight clock T=2900 is
+  # consistent. The agent must compute the bearing to (115,20) from
+  # its actual spawn (NORTH spawn → south-east bearing; SOUTH spawn
+  # → north-east bearing); a memorised "drive east on y=20" plan
+  # mis-targets on both spawns. Per CLAUDE.md, enemy actors do NOT
+  # honour spawn_point, so the objective fact + garrison place
+  # every seed exactly once; the agent base `fact` is duplicated
+  # across BOTH spawn groups (CLAUDE.md: ANY agent actor declaring
+  # spawn_point filters out unspawned agent actors).
+  hard:
+    description: >
+      Same speedrun-to-far-objective discipline, with seed-driven
+      start latitude. Your 3-tank column + base `fact` start at
+      EITHER the NORTH staging (y≈10) OR the SOUTH staging (y≈30)
+      — the seed picks. The enemy construction yard (`fact`) is
+      the OBJECTIVE at (115,20) with a light 2-rifleman garrison
+      regardless of spawn. Drive the column DIRECTLY to (115,20)
+      and raze it before tick 2900. A memorised "drive east on
+      y=20" plan mis-targets from both spawns; a south-detour or
+      stall busts the clock. Losing your base also fails.
+    overrides:
+      actors:
+        # spawn_point 0 — NORTH staging (y≈10 column + base).
+        - {type: 2tnk, owner: agent, position: [6,  8], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [6, 10], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [6, 12], stance: 1, spawn_point: 0}
+        - {type: fact, owner: agent, position: [10, 10], spawn_point: 0}
+        # spawn_point 1 — SOUTH staging (y≈30 column + base).
+        - {type: 2tnk, owner: agent, position: [6, 28], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [6, 30], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [6, 32], stance: 1, spawn_point: 1}
+        - {type: fact, owner: agent, position: [10, 30], spawn_point: 1}
+        # ── ENEMY (places every seed; spawn_point not honoured) ──
+        - {type: fact, owner: enemy, position: [115, 20]}
+        - {type: e1,   owner: enemy, position: [112, 20], stance: 2}
+        - {type: e1,   owner: enemy, position: [118, 20], stance: 2}
+    win_condition:
+      all_of:
+        - enemy_key_buildings_destroyed_in_region:
+            {x: 115, y: 20, radius: 6, types: [fact]}
+        - within_ticks: 2900
+    fail_condition:
+      any_of:
+        - after_ticks: 2901
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 33   # ceiling 93 + 90·32 = 2973 ≥ 2901 ✓

tests/test_hard_tier.py

@@ -798,6 +798,21 @@ UPGRADED = [
     # spawn variation via units_summary (the scout base is otherwise
     # building-only at reset).
     "scout-jeep-vs-infantry-cost-effective",
+    # Wave-8 ACTION speedrun pack — quickest-path planning to a far
+    # objective (human speedrun / quickest-path planning / SC2 worker
+    # rush anchor). 3× 2tnk pre-staged at the far west (x=6) must drive
+    # directly east and raze the enemy `fact` at the far-east objective
+    # region (115,20) inside a TIGHT clock; sub-optimal pathing
+    # (south-detour wander) busts the deadline. Hard defines TWO agent
+    # spawn_point groups (NORTH staging y≈10 vs SOUTH staging y≈30)
+    # round-robined by seed; the objective fact at (115,20) places
+    # every seed (enemy actors don't honour spawn_point — CLAUDE.md)
+    # and Chebyshev distance from either spawn is identical (109), so
+    # the tight clock is consistent across seeds but the bearing-to-
+    # objective flips (NORTH spawn → south-east; SOUTH spawn → north-
+    # east) and a memorised "drive east on y=20" plan mis-targets
+    # from both spawns.
+    "tp-rush-objective-very-fast",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation

tests/test_tp_rush_objective_very_fast.py

@@ -0,0 +1,344 @@
+"""tp-rush-objective-very-fast — ACTION speedrun pack.
+
+The pack tests RAW SPEEDRUN PLANNING (quickest-path / human speedrun /
+SC2 worker-rush anchor): a small armoured strike trio (3× 2tnk) is
+pre-placed at the far west of a long arena and MUST drive directly
+east to raze an enemy `fact` at the far-east objective region
+(115, 20) inside a TIGHT tick budget. Sub-optimal pathing (south-
+detour wander) blows the clock; hesitation (stall, observe loops)
+blows the clock; the intended policy is one `attack_move(115, 20)`
+issued to the whole column immediately, held to completion.
+
+Bar (binding):
+- intended direct rush WINS on every level + every hard seed (1..4);
+- stall LOSES on every level + every seed (real reachable timeout
+  LOSS, no DRAW degeneracy);
+- wander (south-detour) WINS on easy (the loose clock tolerates a
+  modest detour) but LOSES on medium + hard (the tight clock is
+  the speedrun-planning discrimination);
+- non-win is a real reachable timeout LOSS
+  (within_ticks / after_ticks ≤ 93 + 90·(max_turns − 1));
+- hard ships ≥2 `spawn_point` groups (seed-driven start variation).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import compile_level
+
+PACKS = Path(__file__).parent.parent / "openra_bench" / "scenarios" / "packs"
+PACK = PACKS / "tp-rush-objective-very-fast.yaml"
+
+
+# ── 1) declarative / schema invariants (no engine needed) ──────────────
+
+
+def test_pack_loads_and_three_levels_compile():
+    p = load_pack(PACK)
+    assert p.meta.id == "tp-rush-objective-very-fast"
+    assert p.meta.capability == "action"
+    # The three mandatory anchors from the authoring spec.
+    anchors = " | ".join(p.meta.benchmark_anchor)
+    for needed in (
+        "human speedrun",
+        "quickest-path planning",
+        "SC2 worker rush",
+    ):
+        assert needed in anchors, f"benchmark_anchor missing {needed!r}: {anchors}"
+    for lv in ("easy", "medium", "hard"):
+        c = compile_level(p, lv)
+        assert c.map_supported, f"{lv}: rush-hour-arena must be Rust-loadable"
+
+
+def test_win_is_region_scoped_fact_destruction_with_within_ticks():
+    """Win = `enemy_key_buildings_destroyed_in_region` at (115, 20)
+    types=[fact] AND `within_ticks: T`. Per the design spec this is
+    the load-bearing predicate pair for the speedrun discrimination."""
+    p = load_pack(PACK)
+    for lv in ("easy", "medium", "hard"):
+        c = compile_level(p, lv)
+        wc = dict(c.win_condition.__pydantic_extra__ or {})
+        assert "all_of" in wc, f"{lv}: win must be `all_of`, got {list(wc)}"
+        clauses = wc["all_of"]
+        keys_flat: set[str] = set()
+        for cl in clauses:
+            keys_flat |= set(cl)
+        assert "enemy_key_buildings_destroyed_in_region" in keys_flat, (
+            f"{lv}: win must include region-scoped fact destruction; got {keys_flat}"
+        )
+        assert "within_ticks" in keys_flat, (
+            f"{lv}: win must include `within_ticks` (speedrun teeth); got {keys_flat}"
+        )
+        # Validate region payload: x=115, y=20, types includes 'fact'.
+        for cl in clauses:
+            if "enemy_key_buildings_destroyed_in_region" in cl:
+                v = cl["enemy_key_buildings_destroyed_in_region"]
+                assert int(v["x"]) == 115, f"{lv}: region x must be 115"
+                assert int(v["y"]) == 20, f"{lv}: region y must be 20"
+                assert "fact" in {str(t).lower() for t in v["types"]}, (
+                    f"{lv}: region types must include 'fact'; got {v['types']}"
+                )
+
+
+def test_clock_tightens_easy_to_medium_hard():
+    """One controlled variable per tier: easy = loose clock; medium /
+    hard = tight clock (same value across medium and hard — hard's
+    +variable is spawn variation, not a further-shrunk clock).
+    `within_ticks(medium) < within_ticks(easy)` and `within_ticks
+    (hard) == within_ticks(medium)`."""
+    p = load_pack(PACK)
+    wins: dict[str, int] = {}
+    for lv in ("easy", "medium", "hard"):
+        c = compile_level(p, lv)
+        wc = dict(c.win_condition.__pydantic_extra__ or {})
+        wins[lv] = next(
+            cl["within_ticks"] for cl in wc["all_of"] if "within_ticks" in cl
+        )
+    assert wins["easy"] > wins["medium"], (
+        f"medium must tighten the clock vs easy: {wins}"
+    )
+    assert wins["medium"] == wins["hard"], (
+        f"hard's +variable is spawn variation, clock should match medium: {wins}"
+    )
+
+
+@pytest.mark.parametrize("lv", ["easy", "medium", "hard"])
+def test_within_and_after_ticks_reachable_no_draw_degeneracy(lv):
+    """`within_ticks` (win) and the fail `after_ticks` must both be
+    reachable within `max_turns` (tick ≤ 93 + 90·(max_turns − 1)) or
+    the episode would time out as a DRAW instead of a real LOSS."""
+    p = load_pack(PACK)
+    c = compile_level(p, lv)
+    ceiling = 93 + 90 * (c.max_turns - 1)
+    wc = dict(c.win_condition.__pydantic_extra__ or {})
+    wt = next(cl["within_ticks"] for cl in wc["all_of"] if "within_ticks" in cl)
+    assert wt < ceiling, f"{lv}: within_ticks {wt} ≥ ceiling {ceiling} ⇒ inert"
+    fc = dict(c.fail_condition.__pydantic_extra__ or {})
+    aft = next(cl["after_ticks"] for cl in fc["any_of"] if "after_ticks" in cl)
+    assert aft <= ceiling, (
+        f"{lv}: fail after_ticks {aft} > ceiling {ceiling} ⇒ unreachable ⇒ DRAW"
+    )
+    assert aft == wt + 1, (
+        f"{lv}: fail after_ticks {aft} should be {wt + 1} (the tick after win)"
+    )
+
+
+def test_fail_has_timeout_and_base_loss_clauses():
+    """Fail tree must trigger on (a) timeout (`after_ticks`) and
+    (b) base loss (`not building_count_gte:{type:fact,n:1}`)."""
+    p = load_pack(PACK)
+    for lv in ("easy", "medium", "hard"):
+        c = compile_level(p, lv)
+        fc = dict(c.fail_condition.__pydantic_extra__ or {})
+        anyof = fc["any_of"]
+        keys_flat: set[str] = set()
+        for cl in anyof:
+            keys_flat |= set(cl)
+            if "not" in cl:
+                keys_flat |= set(cl["not"])
+        assert "after_ticks" in keys_flat, f"{lv}: fail must include timeout clause"
+        assert "building_count_gte" in keys_flat, (
+            f"{lv}: fail must include base-loss clause "
+            f"(`not building_count_gte:fact:1`); got {keys_flat}"
+        )
+
+
+def test_objective_fact_and_garrison_present_in_base():
+    """The objective enemy `fact` at (115, 20) and 2× e1 light garrison
+    must be present in the pack-level base actors so they place every
+    seed (enemy actors don't honour spawn_point — CLAUDE.md)."""
+    p = load_pack(PACK)
+    # Check that EVERY level's compiled scenario has the objective +
+    # garrison (the easy/medium/hard overrides each re-declare the
+    # enemy block).
+    for lv in ("easy", "medium", "hard"):
+        c = compile_level(p, lv)
+        actors = c.scenario.actors
+        enemy_facts = [
+            a for a in actors
+            if a.owner == "enemy" and a.type == "fact"
+        ]
+        assert any(
+            (a.position[0], a.position[1]) == (115, 20) for a in enemy_facts
+        ), f"{lv}: enemy fact at (115,20) missing"
+        enemy_e1s = [
+            a for a in actors
+            if a.owner == "enemy" and a.type == "e1"
+        ]
+        assert len(enemy_e1s) >= 1, f"{lv}: at least 1 e1 garrison expected"
+        assert len(enemy_e1s) <= 2, (
+            f"{lv}: garrison must stay LIGHT (≤2 e1); got {len(enemy_e1s)}"
+        )
+
+
+def test_hard_has_multiple_spawn_point_groups():
+    """Hard-tier curation: ≥2 distinct seed-driven spawn groups so a
+    memorised opening cannot generalise."""
+    p = load_pack(PACK)
+    c = compile_level(p, "hard")
+    sp = {
+        a.spawn_point if a.spawn_point is not None else 0
+        for a in c.scenario.actors
+        if a.owner == "agent"
+    }
+    assert len(sp) >= 2, f"hard needs ≥2 spawn_point groups, got {sorted(sp)}"
+
+
+def test_enemy_is_turtle_bot():
+    """`turtle` keeps the garrison at its objective spawn; it does
+    NOT chase the agent's holding column or harass the agent base —
+    so the timing teeth (within_ticks / after_ticks) are the
+    unambiguous discriminator (not slugfest survival)."""
+    p = load_pack(PACK)
+    assert p.base.get("enemy", {}).get("bot_type") == "turtle"
+
+
+# ── 2) engine-required scripted-policy sweep ───────────────────────────
+
+
+def _rush(rs, C):
+    """Intended direct speedrun: attack_move the whole 2tnk column to
+    the objective region (115, 20) immediately, hold to completion.
+    Should WIN on every level + every seed (smoke ~tick 2613)."""
+    us = rs.get("units_summary") or []
+    ids = [str(u["id"]) for u in us if str(u.get("type", "")).lower() == "2tnk"]
+    if not ids:
+        return [C.observe()]
+    return [C.attack_move(ids, 115, 20)]
+
+
+def _stall(rs, C):
+    """Never moves — must LOSE on the timeout on every level + every
+    seed (real reachable LOSS, no DRAW degeneracy)."""
+    return [C.observe()]
+
+
+class _Wander:
+    """South-detour wander: drive the column south to y≈36, then east
+    along the south wall to x≈115, then north to attack the fact at
+    (115, 20). Smoke: wins easy (~tick 3243 < 3601 clock), LOSES
+    medium + hard (3243 > 2901 tight clock) — the speedrun-planning
+    discrimination."""
+
+    def __init__(self) -> None:
+        self.phase = 0
+
+    def __call__(self, rs, C):
+        us = rs.get("units_summary") or []
+        tanks = [u for u in us if str(u.get("type", "")).lower() == "2tnk"]
+        ids = [str(u["id"]) for u in tanks]
+        if not ids:
+            return [C.observe()]
+        miny = min(u["cell_y"] for u in tanks)
+        minx = min(u["cell_x"] for u in tanks)
+        if self.phase == 0:
+            if abs(miny - 36) > 3:
+                return [C.move_units(ids, 6, 36)]
+            self.phase = 1
+        if self.phase == 1:
+            if minx < 115:
+                return [C.move_units(ids, 115, 36)]
+            self.phase = 2
+        return [C.attack_move(ids, 115, 20)]
+
+
+@pytest.mark.parametrize("lv", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_intended_rush_wins(lv, seed):
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK), lv)
+    r = run_level(c, _rush, seed=seed)
+    assert r.outcome == "win", (
+        f"{lv}:seed{seed} intended direct rush must WIN "
+        f"(got {r.outcome} at tick {r.signals.game_tick}, "
+        f"killed={r.signals.units_killed}, lost={r.signals.units_lost})"
+    )
+
+
+@pytest.mark.parametrize("lv", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_stall_loses(lv, seed):
+    """Stall is the canonical no-action degenerate: every level, every
+    seed, REAL reachable LOSS (no DRAW degeneracy)."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK), lv)
+    r = run_level(c, _stall, seed=seed)
+    assert r.outcome == "loss", (
+        f"{lv}:seed{seed} stall must LOSE on the bar "
+        f"(got {r.outcome} at tick {r.signals.game_tick})"
+    )
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_wander_wins_easy(seed):
+    """The south-detour wander still wins on easy (loose clock budget
+    tolerates a modest detour) — the discriminator vs medium/hard is
+    that easy does NOT require quickest-path; it requires only that
+    the rush commits."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK), "easy")
+    r = run_level(c, _Wander(), seed=seed)
+    assert r.outcome == "win", (
+        f"easy:seed{seed} south-detour wander should WIN on easy "
+        f"(got {r.outcome} at tick {r.signals.game_tick}); "
+        f"if this fails, the easy clock is too tight to be 'loose'"
+    )
+
+
+@pytest.mark.parametrize("lv", ["medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_wander_loses_on_tight_clock(lv, seed):
+    """South-detour wander LOSES on medium + hard — the tight clock
+    is the speedrun-planning discrimination: only the DIRECT east
+    path finishes in budget."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK), lv)
+    r = run_level(c, _Wander(), seed=seed)
+    assert r.outcome == "loss", (
+        f"{lv}:seed{seed} south-detour wander must LOSE on the tight clock "
+        f"(got {r.outcome} at tick {r.signals.game_tick}); "
+        f"if this passes, the tight clock isn't actually pinching the detour"
+    )
+
+
+def test_hard_seeds_produce_distinct_starts():
+    """The two `spawn_point` groups must actually round-robin under
+    seeds 1..4 (the contract enforced for `UPGRADED` hard tiers)."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import _scenario_to_tmp_yaml, RustEnvPool
+    from openra_bench.rust_adapter import RustObsAdapter
+
+    c = compile_level(load_pack(PACK), "hard")
+    tmp = _scenario_to_tmp_yaml(c)
+    pool = RustEnvPool(size=1, scenario_path=tmp)
+    env = pool.acquire()
+    starts: set = set()
+    try:
+        for seed in (1, 2, 3, 4):
+            ad = RustObsAdapter()
+            ad.observe(env.reset(seed=seed))
+            u = ad.render_state().get("units_summary") or []
+            if u:
+                starts.add(
+                    tuple(sorted((x["cell_x"], x["cell_y"]) for x in u))
+                )
+    finally:
+        pool.release(env)
+        pool.shutdown()
+        Path(tmp).unlink(missing_ok=True)
+    assert len(starts) >= 2, (
+        f"hard seeds produced identical starts {starts}; "
+        "spawn round-robin off"
+    )