feat(scenario): combat-prevent-retreat — cut-off encirclement (Cannae / SC2 anchor)

openra_bench/scenarios/packs/combat-prevent-retreat.yaml

@@ -0,0 +1,289 @@
+# combat-prevent-retreat — Cut off the enemy's retreat path BEFORE
+# engaging from the west (Wave-7 ACTION pack: encirclement / Cannae
+# doctrine).
+#
+# Real-world anchors:
+#   - Military encirclement / Cannae doctrine: pin the enemy on the
+#     anvil and close the back door before the hammer falls, so the
+#     opposing force cannot exfiltrate when the engagement begins.
+#   - SC2 encirclement micro: a head-on attack from one bearing lets
+#     the enemy retreat toward their main base/regroup point; the
+#     winning play is to position a cut-off unit on the opposite side
+#     FIRST so the targets cannot exit the kill envelope.
+#   - "The hammer needs an anvil." A frontal hammer with no anvil
+#     just shoves the target back; the anvil makes the strike count.
+#
+# Mechanism (engine-load-bearing geometry — verified by scripted-policy
+# smoke runs, all seeds 1–4 × every tier):
+#   - 4× medium tanks (2tnk) pre-placed at the west edge.
+#   - Mixed enemy infantry cluster at the centre column (x=60):
+#       easy   3× e1 + 2× e3 (5 enemies)
+#       medium 4× e1 + 3× e3 (7 enemies)
+#       hard   5× e1 + 3× e3 (8 enemies)
+#     `e3` (rocket infantry) is anti-armour and BITES tanks within ~5
+#     cells of the cluster — a frontal column charge through the cluster
+#     bleeds the tanks below the survival cap. e1 (small-arms ~3) is
+#     filler that makes up the kill bar so the cluster can't be one-
+#     shotted by overwhelming firepower.
+#   - The enemy is STATIONARY (no `bot_type`, default stance: return
+#     fire only). This is critical: a `hunt` bot would chase the lone
+#     cutoff tank as it flanks, breaking the off-axis safe-route
+#     assumption AND making the "stall lets the enemy walk into you"
+#     degeneracy trivially satisfiable.
+#   - The win predicate requires THREE things AT THE SAME EVALUATION:
+#       (1) `units_killed_gte: K`             — all centre enemies dead
+#       (2) `units_in_region_gte:{85,20,r=8,n=1}` — cutoff tank present
+#       (3) `own_units_gte: 3`                  — at least 3 tanks alive
+#     plus `within_ticks: 4500` to deny stallers.
+#
+# Discrimination bar (six scripted-policy proxies in the test file;
+# every level × every seed 1–4 must hold):
+#   • stall (only observe)            → LOSS. No kills, no in-region,
+#     timeout fires.
+#   • brute attack_move-east-through-cluster (all 4 tanks toward 85,20)
+#                                       → LOSS. The column passes
+#     through the e3 cluster within Dragon range and loses ≥2 tanks
+#     en route → `own_units_gte:3` fails. The kill bar may or may not
+#     be met (depends on tier) but survival busts either way.
+#   • brute attack_move-centre (all 4 tanks toward 60,20) → LOSS.
+#     The column does engage and may even kill all centre enemies on
+#     easy/medium, BUT NO TANK IS IN THE EAST CUT-OFF REGION → the
+#     `units_in_region_gte` clause is never satisfied → after_ticks
+#     LOSS.
+#   • east-only (send ONE tank east, hold the rest) → LOSS. One tank
+#     can't kill the cluster; held tanks don't engage → kill bar
+#     fails. Even on easy with 5 enemies, a solo east tank can't
+#     pull the kill bar in the time budget.
+#   • intended cut-off-then-engage (NORTH route via y=5..10 OR SOUTH
+#     route via y=30..35) → WIN. The cutoff tank routes off-axis (out
+#     of e3 Dragon range), arrives at (85,20). The remaining 3 tanks
+#     attack-move the centre, kill the e1+e3 cluster, lose at most 1
+#     tank (well within `own_units_gte:3`). Kill bar AND in-region AND
+#     survival all satisfied → WIN.
+#
+# Engine guardrails (per CLAUDE.md):
+#   - Map: rush-hour-arena (128 × 40, playable x ∈ [2..126], y ∈ [2..38]).
+#   - All declared cells are well within playable bounds.
+#   - Persistent unarmed enemy `fact` at (120, 4) keeps the episode
+#     alive past the moment the cluster is wiped (otherwise the
+#     engine would auto-`done` on enemy-elimination before the
+#     `units_in_region_gte` predicate evaluates).
+#   - Per CLAUDE.md (60,20) is not on the silent-fail list (the cited
+#     problems are (50,20), (60,28), (90,30)); the e1/e3 cluster
+#     spans (60, 16..23) on hard, no member at a known-bad cell.
+#   - All deadlines (`after_ticks 4501`) are reachable within max_turns
+#     (~90 ticks/turn ⇒ tick ≤ 93 + 90·(max_turns−1) = 5403 on
+#     max_turns 60) ⇒ no draw degeneracy.
+#   - `spawn_point` filter applies ONLY to agent actors; the enemy
+#     cluster + east sentinel `fact` have no spawn_point so they
+#     ALWAYS place. On hard, both NORTH and SOUTH agent groups
+#     declare spawn_point so only ONE is selected per seed.
+
+meta:
+  id: combat-prevent-retreat
+  title: 'Combat Encirclement — Cut Off the Enemy''s Retreat Before You Strike'
+  capability: action
+  real_world_meaning: >
+    A cluster of enemy rifle + rocket infantry sits at the centre of
+    the map. A head-on column charge brings every tank within rocket
+    range of the cluster and bleeds the strike force below the
+    survival cap. The winning play is the Cannae / encirclement
+    idiom: detach ONE tank on a flank route (around the enemy cluster
+    via y=5..10 or y=30..35, out of rocket range) to take the eastern
+    anvil position at (85,20), then commit the main body of THREE
+    tanks from the west. The win predicate explicitly requires the
+    agent to have ESTABLISHED an eastern cut-off (≥1 own unit at
+    (85,20,r=8)) at the moment the kill bar is met AND to have ≥3
+    tanks alive. Brute charging without the cut-off either bleeds
+    the force under the survival cap (attack-move east through the
+    cluster) or wins the centre fight with no tank east (attack-move
+    to the centre) — both LOSE. Stalling never opens fire, also a
+    LOSS on the clock.
+  robotics_analogue: >
+    Multi-agent strike geometry: the placement of a "blocker" /
+    "anvil" unit on the opposite side of the target BEFORE the main
+    engagement opens is what converts a shove into a kill. The
+    decision under test is spatial sequencing — establish the cut-
+    off via a path that avoids the enemy's effective weapon envelope,
+    THEN engage; reversing the order forfeits the capability that
+    the cut-off enables.
+  benchmark_anchor:
+    - "military encirclement"
+    - "Cannae doctrine"
+    - "SC2 encirclement"
+    - "the hammer needs an anvil"
+  author: openra-bench
+
+base_map: rush-hour-arena
+
+base:
+  agent: {faction: allies, cash: 0}
+  enemy: {faction: soviet, cash: 0}
+  tools: [move_units, attack_unit, attack_move, stop]
+  planning: true
+  # React the instant a tank is lost or an enemy unit is spotted —
+  # the encirclement is reactive; without these the policy only
+  # re-targets on the next turn boundary.
+  interrupts:
+    enemy_unit_spotted: true
+    own_unit_destroyed: true
+  termination: {max_ticks: 6000}
+  actors: []
+
+levels:
+  # ── EASY ──────────────────────────────────────────────────────────
+  # Bare encirclement skill: 5-unit cluster (3× e1 + 2× e3 anti-armour)
+  # at the centre. The 2× e3 are enough to punish a frontal-column
+  # charge but not enough to overwhelm 3 attacking tanks from the
+  # west. Generous tick budget.
+  easy:
+    description: >
+      Four medium tanks (2tnk) stage at the west edge (x=6, y=18..21).
+      A five-unit enemy infantry cluster holds the centre at (60,
+      y=18..22): 3× e1 (rifle, small-arms) + 2× e3 (rocket, anti-
+      armour). To win the encirclement you must POSITION ≥1 tank in
+      the east cut-off region (85, 20, r=8) AND kill all 5 enemies
+      AND keep ≥3 tanks alive, before tick 4500. Detach ONE tank on
+      a flank route (via y=5..10 or y=30..35 to stay out of e3
+      Dragon range) and run it east to (85, 20); engage the centre
+      with the remaining THREE tanks. A head-on attack-move-east
+      through the cluster bleeds tanks below the survival cap and
+      LOSES; an attack-move-centre kills the e1+e3 but no tank
+      reaches the east region — also LOSES. Stall LOSES on the
+      clock.
+    overrides:
+      actors:
+        # Strike force — 4 medium tanks staged at the west edge.
+        # Stance:1 ReturnFire so they don't auto-charge across the
+        # map and break the agent's positional plan.
+        - {type: 2tnk, owner: agent, position: [6, 18], stance: 1}
+        - {type: 2tnk, owner: agent, position: [6, 19], stance: 1}
+        - {type: 2tnk, owner: agent, position: [6, 20], stance: 1}
+        - {type: 2tnk, owner: agent, position: [6, 21], stance: 1}
+        # ENEMY centre cluster — 3× e1 + 2× e3. Stationary defenders
+        # (no bot_type); stance defaults to return-fire when attacked.
+        - {type: e1, owner: enemy, position: [60, 18]}
+        - {type: e3, owner: enemy, position: [60, 19]}
+        - {type: e1, owner: enemy, position: [60, 20]}
+        - {type: e3, owner: enemy, position: [60, 21]}
+        - {type: e1, owner: enemy, position: [60, 22]}
+        # SENTINEL — unarmed enemy `fact` far in the north corner.
+        # Keeps the episode alive past enemy-cluster elimination so
+        # the in-region predicate evaluates on the terminal frame
+        # (per CLAUDE.md: without a persistent enemy actor the
+        # engine auto-`done`s on enemy-wipe and collapses to DRAW).
+        - {type: fact, owner: enemy, position: [120, 4]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 5}
+        - {units_in_region_gte: {x: 85, y: 20, radius: 8, n: 1}}
+        - {own_units_gte: 3}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {own_units_gte: 3}}
+    max_turns: 60
+
+  # ── MEDIUM ────────────────────────────────────────────────────────
+  # +1 controlled variable vs easy: the enemy cluster gains TWO more
+  # units (one e1 + one e3 → 7 total at y=17..23). Kill bar 7 makes
+  # the east-only solo-tank play decisively too slow; the e3 density
+  # makes brute-charge-east decisively bleed.
+  medium:
+    description: >
+      Four medium tanks (2tnk) stage at the west edge (x=6, y=18..21).
+      A seven-unit enemy infantry cluster holds the centre at (60,
+      y=17..23): 4× e1 + 3× e3 (rocket anti-armour). To win you must
+      POSITION ≥1 tank in the east cut-off region (85, 20, r=8) AND
+      kill all 7 enemies AND keep ≥3 tanks alive, before tick 4500.
+      Detach ONE tank on a flank route (via y=5..10 or y=30..35) and
+      run it east to (85, 20); engage the centre with the remaining
+      three. Head-on, east-only, and stall all LOSE.
+    overrides:
+      actors:
+        - {type: 2tnk, owner: agent, position: [6, 18], stance: 1}
+        - {type: 2tnk, owner: agent, position: [6, 19], stance: 1}
+        - {type: 2tnk, owner: agent, position: [6, 20], stance: 1}
+        - {type: 2tnk, owner: agent, position: [6, 21], stance: 1}
+        - {type: e1, owner: enemy, position: [60, 17]}
+        - {type: e3, owner: enemy, position: [60, 18]}
+        - {type: e1, owner: enemy, position: [60, 19]}
+        - {type: e3, owner: enemy, position: [60, 20]}
+        - {type: e1, owner: enemy, position: [60, 21]}
+        - {type: e3, owner: enemy, position: [60, 22]}
+        - {type: e1, owner: enemy, position: [60, 23]}
+        - {type: fact, owner: enemy, position: [120, 4]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 7}
+        - {units_in_region_gte: {x: 85, y: 20, radius: 8, n: 1}}
+        - {own_units_gte: 3}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {own_units_gte: 3}}
+    max_turns: 60
+
+  # ── HARD ──────────────────────────────────────────────────────────
+  # +1 controlled variable vs medium: TWO seed-driven agent spawn_point
+  # groups (NORTH staging y=12..15 OR SOUTH staging y=25..28),
+  # round-robined by seed so the natural flank corridor flips per
+  # seed (a memorised "always flank via the north" opening cannot
+  # generalise). The enemy cluster is symmetric across y=20 (y=16..23)
+  # so both spawns face the same encirclement geometry. The hard tier
+  # also adds one more e1 to the cluster (kill bar 8).
+  #
+  # Per the CLAUDE.md `spawn_point` contract: ALL agent actors carry
+  # an explicit spawn_point (the filter applies only to agent actors);
+  # the enemy actors are unchanged and always place.
+  hard:
+    description: >
+      Four medium tanks (2tnk) stage at ONE of two west-edge corridors
+      (NORTH y=12..15 OR SOUTH y=25..28, chosen by seed, anti-
+      memorisation). An eight-unit enemy infantry cluster holds the
+      centre at (60, y=16..23): 5× e1 + 3× e3 (rocket anti-armour).
+      To win you must POSITION ≥1 tank in the east cut-off region
+      (85, 20, r=8) AND kill all 8 enemies AND keep ≥3 tanks alive,
+      before tick 4500. From the NORTH spawn run the cutoff tank via
+      y=5..10 to (85, 20); from the SOUTH spawn run it via y=30..35.
+      Engage the centre with the remaining three tanks descending
+      onto the cluster from the staging latitude. Head-on, east-only,
+      and stall all LOSE on every seed.
+    overrides:
+      actors:
+        # spawn_point 0 — NORTH staging corridor (y=12..15). Already
+        # off-axis from the e1/e3 cluster (e3 Dragon range ~5, so a
+        # tank at y=5..10 transiting east at x=20..80 stays out of
+        # cluster fire from the y=16..23 cluster).
+        - {type: 2tnk, owner: agent, position: [6, 12], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [6, 13], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [6, 14], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [6, 15], stance: 1, spawn_point: 0}
+        # spawn_point 1 — SOUTH staging corridor (y=25..28). Mirror.
+        - {type: 2tnk, owner: agent, position: [6, 25], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [6, 26], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [6, 27], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [6, 28], stance: 1, spawn_point: 1}
+        # 8× cluster symmetric across y=20 at the centre.
+        - {type: e1, owner: enemy, position: [60, 16]}
+        - {type: e3, owner: enemy, position: [60, 17]}
+        - {type: e1, owner: enemy, position: [60, 18]}
+        - {type: e3, owner: enemy, position: [60, 19]}
+        - {type: e1, owner: enemy, position: [60, 20]}
+        - {type: e3, owner: enemy, position: [60, 21]}
+        - {type: e1, owner: enemy, position: [60, 22]}
+        - {type: e1, owner: enemy, position: [60, 23]}
+        - {type: fact, owner: enemy, position: [120, 4]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 8}
+        - {units_in_region_gte: {x: 85, y: 20, radius: 8, n: 1}}
+        - {own_units_gte: 3}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {own_units_gte: 3}}
+    max_turns: 60

tests/test_combat_prevent_retreat.py

@@ -0,0 +1,426 @@
+"""combat-prevent-retreat — cut-off encirclement before engaging.
+
+The bar: 4× medium tanks (2tnk) start at the west edge; a mixed e1+e3
+infantry cluster holds the centre (60, 16..23). The win predicate
+requires:
+
+  • `units_killed_gte: K`              — the full cluster wiped
+    (K=5 easy / 7 medium / 8 hard)
+  • `units_in_region_gte:{85,20,r=8,n=1}` — ≥1 own tank in the east
+    cut-off region at evaluation time
+  • `own_units_gte: 3`                  — at least 3 tanks survive
+  • `within_ticks: 4500`                — stallers can't draw
+
+This combination forces the Cannae idiom: ONE flank tank routes
+off-axis (via y=5..10 from a NORTH spawn or y=30..35 from a SOUTH
+spawn, out of e3 Dragon range) to take the eastern anvil; the
+remaining THREE engage the centre from the west. The cluster's
+anti-armour e3s punish a head-on column charge (`brute_east` loses
+≥2 tanks → survival cap busts); a centre-only charge leaves no tank
+east (in-region clause fails); a solo east tank can't pull the kill
+bar in budget.
+
+Discrimination (verified per-level × per-seed 1–4):
+
+  • stall (observe-only)              — LOSS on every level/seed
+                                        (no kills, deadline fires).
+  • brute_east (attack_move all to 85,20)
+                                       — LOSS: column bled by e3
+                                         Dragons; survival cap busts.
+  • brute_centre (attack_move all to 60,20)
+                                       — LOSS: cluster killed but
+                                         no tank east → in-region
+                                         clause fails → after_ticks.
+  • east_only (move 1 east, hold rest)— LOSS: kill bar never met
+                                         (1 tank vs cluster too slow).
+  • intended (cut-off then engage)    — WIN every level/seed.
+
+Validation is scripted (no model / network)."""
+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
+from openra_bench.scenarios.win_conditions import WinContext, evaluate
+
+PACKS = Path(__file__).parent.parent / "openra_bench" / "scenarios" / "packs"
+PACK_PATH = PACKS / "combat-prevent-retreat.yaml"
+
+
+# ── unit-level predicate / metadata checks (no engine) ──────────────
+
+
+def test_pack_compiles_and_meta_fields_populated():
+    pack = load_pack(PACK_PATH)
+    assert pack.meta.id == "combat-prevent-retreat"
+    assert pack.meta.capability == "action"
+    assert pack.meta.real_world_meaning, "real_world_meaning required"
+    assert pack.meta.robotics_analogue, "robotics_analogue required"
+    anchors = pack.meta.benchmark_anchor
+    assert isinstance(anchors, list) and len(anchors) >= 3, (
+        f"benchmark_anchor must list ≥3 anchors, got {anchors!r}"
+    )
+    joined = " ".join(anchors).lower()
+    for needle in ("encirclement", "cannae", "sc2"):
+        assert needle in joined, f"missing anchor keyword: {needle}"
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        assert c.map_supported
+        assert c.win_condition is not None
+        assert c.fail_condition is not None
+
+
+def _ctx(*, units=(), tick=1000, kills=0, lost=0):
+    """Synthesize a WinContext for predicate-level checks."""
+    import types
+
+    sig = types.SimpleNamespace(
+        game_tick=tick,
+        units_killed=kills,
+        units_lost=lost,
+        cash=0,
+        resources=0,
+        power_provided=0,
+        power_drained=0,
+        own_buildings=[],
+        own_building_types=set(),
+        enemies_seen_ids=set(),
+        enemy_buildings_seen_ids=set(),
+        explored_percent=0.0,
+        then_progress={},
+        seq_progress={},
+    )
+    return WinContext(
+        signals=sig,
+        render_state={"units_summary": list(units)},
+    )
+
+
+def _tanks_at(n, x=85, y=20):
+    return [
+        {"cell_x": x, "cell_y": y, "type": "2tnk", "id": str(2000 + i)}
+        for i in range(n)
+    ]
+
+
+def test_predicates_per_level():
+    """Region n=1 + kill bar + survival cap + deadline all load-bearing."""
+    pack = load_pack(PACK_PATH)
+    # (kill_bar, surv_min, within, after_fail)
+    expectations = {
+        "easy":   (5, 3, 4500, 4501),
+        "medium": (7, 3, 4500, 4501),
+        "hard":   (8, 3, 4500, 4501),
+    }
+    for lvl, (kb, surv, w, af) in expectations.items():
+        c = compile_level(pack, lvl)
+        # Intended win: ≥1 tank in east region + kill bar + ≥surv alive.
+        ctx_win = _ctx(units=_tanks_at(surv), tick=w - 100, kills=kb, lost=4 - surv)
+        assert evaluate(c.win_condition, ctx_win), f"{lvl}: intended should WIN"
+        # No tank in east region → in-region clause unmet.
+        ctx_no_east = _ctx(
+            units=[{"cell_x": 60, "cell_y": 20, "type": "2tnk", "id": str(3000 + i)}
+                   for i in range(surv)],
+            tick=w - 100, kills=kb, lost=4 - surv,
+        )
+        assert not evaluate(c.win_condition, ctx_no_east), (
+            f"{lvl}: 0 tanks in east region must not satisfy win"
+        )
+        # Kill bar unmet → not a win.
+        ctx_low_kills = _ctx(units=_tanks_at(surv), tick=w - 100, kills=kb - 1, lost=0)
+        assert not evaluate(c.win_condition, ctx_low_kills), (
+            f"{lvl}: kills < {kb} must not satisfy win"
+        )
+        # Survival cap busted → not a win + fails.
+        ctx_lost = _ctx(units=_tanks_at(surv - 1), tick=w - 100, kills=kb, lost=4 - surv + 1)
+        assert not evaluate(c.win_condition, ctx_lost)
+        assert evaluate(c.fail_condition, ctx_lost), (
+            f"{lvl}: survival<{surv} must FAIL"
+        )
+        # Timeout busted → fails.
+        ctx_late = _ctx(units=_tanks_at(surv), tick=af + 1, kills=kb, lost=0)
+        assert evaluate(c.fail_condition, ctx_late), (
+            f"{lvl}: tick>after must FAIL"
+        )
+
+
+def test_timeout_reachable_inside_max_turns():
+    """No DRAW degeneracy: after_ticks fail trigger must be reachable
+    within max_turns (engine advances ~90 ticks per turn ⇒ max tick
+    ≈ 93 + 90·(max_turns-1))."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        max_tick = 93 + 90 * (c.max_turns - 1)
+        assert 4501 <= max_tick, (
+            f"{lvl}: after_ticks 4501 > max reachable tick {max_tick} "
+            f"(max_turns={c.max_turns}); deadline never bites"
+        )
+
+
+def test_tanks_are_2tnk_and_west_edge():
+    """Agent strike force is 4× 2tnk at the west edge (x=6) on every
+    level — the encirclement geometry is load-bearing."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        agent = [a for a in c.scenario.actors if a.owner == "agent"]
+        for a in agent:
+            assert a.type == "2tnk", f"{lvl}: agent must be 2tnk; got {a.type}"
+            assert a.position[0] == 6, (
+                f"{lvl}: agent must start at x=6 (west edge); got {a.position}"
+            )
+        # Easy/medium: 4 tanks. Hard: 4 per spawn_point (8 declared
+        # actors total, but only one spawn_point group places per seed).
+        if lvl == "hard":
+            assert len(agent) == 8, f"hard: declares 4 tanks × 2 spawn_points = 8"
+        else:
+            assert len(agent) == 4, f"{lvl}: 4 tanks expected; got {len(agent)}"
+
+
+def test_enemy_cluster_e1_plus_e3_mix():
+    """The centre cluster mixes e1 (filler) + e3 (anti-armour). The
+    e3 component is load-bearing — without it a brute attack-move
+    column charge wouldn't bleed below the survival cap."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        cluster = [
+            a for a in c.scenario.actors
+            if a.owner == "enemy" and a.type in ("e1", "e3")
+        ]
+        assert cluster, f"{lvl}: no central cluster declared"
+        e3 = [a for a in cluster if a.type == "e3"]
+        assert len(e3) >= 2, (
+            f"{lvl}: cluster needs ≥2 e3 to bleed a frontal column charge; "
+            f"got {len(e3)}"
+        )
+        # No cluster member at a known silently-no-place cell.
+        for a in cluster:
+            assert tuple(a.position) != (50, 20), (
+                f"{lvl}: cluster member at (50,20) — CLAUDE.md no-place footgun"
+            )
+            assert a.position[0] == 60, (
+                f"{lvl}: cluster member off-column; got {a.position}"
+            )
+
+
+def test_persistent_far_enemy_marker_present():
+    """Engine auto-`done` mitigation: a far unarmed enemy `fact` keeps
+    the episode alive past full cluster elimination so the in-region
+    predicate evaluates on the terminal frame (no DRAW collapse)."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        far_facts = [
+            a for a in c.scenario.actors
+            if a.owner == "enemy" and a.type == "fact"
+            and a.position[0] >= 100
+        ]
+        assert far_facts, f"{lvl}: needs a far persistent enemy fact sentinel"
+
+
+def test_enemy_is_static_no_bot_type():
+    """Enemies are stationary defenders (no `bot_type`) — a hunt bot
+    would chase the lone cutoff tank as it flanks, breaking the
+    off-axis safe-route assumption AND letting a staller win when
+    enemies walk into the tanks."""
+    pack = load_pack(PACK_PATH)
+    enemy = pack.base.get("enemy") if isinstance(pack.base, dict) else getattr(pack.base, "enemy", {})
+    assert (enemy or {}).get("bot_type") is None, (
+        "enemy must not declare a bot_type — see file header docstring"
+    )
+
+
+def test_hard_has_two_spawn_point_groups():
+    """Hard-tier curation: ≥2 distinct agent spawn_point groups so the
+    seed round-robins which staging corridor (north y=12 or south y=28)
+    the tank column starts in. The natural flank route flips per seed
+    so no memorised opening generalises."""
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    groups = {
+        (a.spawn_point if a.spawn_point is not None else 0)
+        for a in c.scenario.actors
+        if a.owner == "agent"
+    }
+    assert len(groups) >= 2, f"hard needs ≥2 spawn_point groups, got {groups}"
+
+
+# ── engine-driven scripted policies ─────────────────────────────────
+
+
+def _tank_ids(rs):
+    return [
+        str(u["id"])
+        for u in (rs.get("units_summary") or [])
+        if str(u.get("type", "")).lower() == "2tnk"
+    ]
+
+
+def _stall(rs, Command):
+    """Pure observe — no kills, no in-region, deadline LOSS."""
+    return [Command.observe()]
+
+
+def _brute_east(rs, Command):
+    """All 4 tanks attack-move EAST through the cluster toward (85,20).
+    The column passes within e3 Dragon range and bleeds below the
+    survival cap → LOSS on every level."""
+    ids = _tank_ids(rs)
+    return [Command.attack_move(ids, 85, 20)] if ids else [Command.observe()]
+
+
+def _brute_centre(rs, Command):
+    """All 4 tanks attack-move the centre cluster at (60,20). May clear
+    the cluster (kills bar met) but NO TANK IS IN THE EAST REGION at
+    evaluation time → in-region clause fails → after_ticks LOSS."""
+    ids = _tank_ids(rs)
+    return [Command.attack_move(ids, 60, 20)] if ids else [Command.observe()]
+
+
+def _east_only(rs, Command):
+    """Send ONLY one tank east, hold the rest. The solo east tank
+    can't pull the kill bar in budget; held tanks don't engage →
+    kill bar fails → LOSS."""
+    ids = _tank_ids(rs)
+    if not ids:
+        return [Command.observe()]
+    return [
+        Command.move_units([ids[0]], target_x=85, target_y=20),
+        Command.stop(ids[1:]),
+    ]
+
+
+def _make_intended():
+    """Cannae intended play. Pick the off-axis safe latitude based on
+    the actual spawn (NORTH spawn → off-y=5; SOUTH spawn → off-y=35),
+    pick the cutoff tank closest to that latitude, route it via three
+    waypoints out of e3 Dragon range to (85,20). The remaining three
+    tanks attack-move the centre cluster from the west."""
+    state = {}
+
+    def policy(rs, Command):
+        units = [
+            u for u in (rs.get("units_summary") or [])
+            if str(u.get("type", "")).lower() == "2tnk"
+        ]
+        if not units:
+            return [Command.observe()]
+        if "off_y" not in state:
+            avg = sum(int(u["cell_y"]) for u in units) / len(units)
+            state["off_y"] = 5 if avg < 20 else 35
+            us = sorted(units, key=lambda u: abs(int(u["cell_y"]) - state["off_y"]))
+            state["cutoff"] = str(us[0]["id"])
+            state["phase"] = 0
+        cmds = []
+        cutoff = state["cutoff"]
+        cu = next((u for u in units if str(u["id"]) == cutoff), None)
+        others = [str(u["id"]) for u in units if str(u["id"]) != cutoff]
+        off_y = state["off_y"]
+        if cu is not None:
+            cx, cy = int(cu["cell_x"]), int(cu["cell_y"])
+            wps = [(20, off_y), (85, off_y), (85, 20)]
+            tx, ty = wps[min(state["phase"], len(wps) - 1)]
+            cmds.append(Command.move_units([cutoff], target_x=tx, target_y=ty))
+            if (
+                abs(cx - tx) <= 2
+                and abs(cy - ty) <= 2
+                and state["phase"] < len(wps) - 1
+            ):
+                state["phase"] += 1
+        if others:
+            cmds.append(Command.attack_move(others, 60, 20))
+        return cmds or [Command.observe()]
+
+    return policy
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_stall_loses(level, seed):
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _stall, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: stall must be a real timeout LOSS "
+        f"(no engagement → kill bar + region clause unmet); got {r.outcome}"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_brute_east_loses(level, seed):
+    """Attack-move all tanks east through the cluster. The e3 Dragon
+    fire bleeds the column below the survival cap → `own_units_gte:3`
+    fails → LOSS on every level/seed."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _brute_east, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: brute_east must LOSE (column bled by "
+        f"e3 Dragons); got {r.outcome} "
+        f"(kills={r.signals.units_killed}, lost={r.signals.units_lost})"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_brute_centre_loses(level, seed):
+    """Attack-move all tanks to the centre cluster (60,20). Even when
+    the cluster is wiped (kill bar met), NO TANK IS IN THE EAST CUT-
+    OFF REGION → in-region clause fails → after_ticks LOSS."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _brute_centre, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: brute_centre must LOSE (no tank in "
+        f"east region); got {r.outcome} "
+        f"(kills={r.signals.units_killed}, lost={r.signals.units_lost})"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_east_only_loses(level, seed):
+    """Send only one tank east; hold the rest. The solo east tank
+    can't pull the kill bar in budget → LOSS on every level/seed."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _east_only, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: east_only must LOSE (kill bar unmet); "
+        f"got {r.outcome} (kills={r.signals.units_killed}, "
+        f"lost={r.signals.units_lost})"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_intended_cutoff_then_engage_wins(level, seed):
+    """Cannae intended play: ONE tank flanks via the off-axis lane
+    (y=5 from NORTH spawn, y=35 from SOUTH spawn — both out of e3
+    Dragon range) to the eastern anvil at (85,20); the remaining
+    THREE attack-move the centre cluster. Kill bar AND in-region AND
+    survival all satisfied → WIN on every level/seed."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _make_intended(), seed=seed)
+    assert r.outcome == "win", (
+        f"{level} seed={seed}: intended cut-off-then-engage should WIN, "
+        f"got {r.outcome} after {r.turns} turns "
+        f"(kills={r.signals.units_killed}, lost={r.signals.units_lost})"
+    )

tests/test_hard_tier.py

@@ -667,6 +667,19 @@ UPGRADED = [
     # spawn variation via units_summary (the buy-vs-build base is
     # otherwise building-only).
     "econ-buy-vs-build-decision",
+    # Wave-7 ACTION pack — cut-off encirclement (Cannae doctrine /
+    # SC2 encirclement / "the hammer needs an anvil"). Strike force
+    # must position ONE tank in the eastern cut-off region BEFORE
+    # engaging the centre cluster with the rest, otherwise either
+    # the column gets bled by e3 Dragon fire (brute-east) or the
+    # cluster is wiped with no tank east (brute-centre). Hard tier
+    # defines two agent spawn_point groups (NORTH staging y=12..15 /
+    # SOUTH staging y=25..28) round-robined by seed; the centre
+    # cluster is symmetric across y=20 so both spawns face the same
+    # encirclement geometry from a flipped flank latitude, and a
+    # memorised "always flank via the north" opening cannot
+    # generalise across seeds.
+    "combat-prevent-retreat",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation