fix(scenario): combat-hold-chokepoint — recalibrate after engine movement fixes

The OpenRA-Rust movement fixes (moving units fire and take fire en
route; attack_unit on out-of-sight targets paths normally) made a
static auto-firing squad strong enough that the easy tier was
beatable by a pure stall: the pre-placed stance:2 squad ground a
12-tank trickle to the kill quota of 8 with no agent input.

Recalibration:
- easy: enemy force 12 -> 14 light tanks, kill quota 8 -> 9 so only
active focus-fire of the frontmost tank clears the bar; idle spread
auto-fire is worn down first (stall now killed 7-8 < 9, lost 3-4).
- hard: kill quota 8 -> 9 (matches the comment header and medium).
- all tiers: added a units_in_region win clause requiring >=3 tanks
anchored in the choke region (53,20,r12). This makes the hold
load-bearing — a wrong-path retreat WEST into the open could still
scrape the quota on some hard seeds, but now fails the geometry.

Bar verified every level x seeds 1-4: stall / brute-east /
wrong-path-west all LOSE; intended hold-the-choke WINS.

openra_bench/scenarios/packs/combat-hold-chokepoint.yaml

@@ -157,29 +157,31 @@ base:
 
 levels:
   # ── EASY ────────────────────────────────────────────────────────────
-  # Bare chokepoint-hold skill. 4x 2tnk vs a force of 12 light tanks
+  # Bare chokepoint-hold skill. 4x 2tnk vs a force of 14 light tanks
   # (1tnk) hunting from the east. Holding the 3-cell corridor caps the
-  # enemy to a 3-abreast trickle — the squad out-trades it. Charging
-  # into the open east, or letting the enemy fan into the open west,
-  # gets the squad surrounded. Win: kill >=8, keep >=3 tanks, fact
-  # alive, before tick 5400.
+  # enemy to a 3-abreast trickle — concentrated fire out-trades it.
+  # Charging into the open east, or letting the enemy fan into the open
+  # west, gets the squad surrounded. Win: kill >=9, keep >=3 tanks in
+  # the choke region, fact alive, before tick 5400.
   easy:
     description: >
       Four medium tanks (2tnk) hold a narrow corridor. Two silo walls
       split the map; the ONLY path between the west and east halves is
       a 3-cell-tall lane (y=19,20,21) running x=44..96. Your squad is
       pre-placed inside the corridor at the choke (around x=52..53). A
-      force of TWELVE enemy light tanks (1tnk) stages in the EAST OPEN
-      and hunts your squad — every enemy drives at the nearest tank
-      and pursues. Win by destroying at least EIGHT enemy units while
-      keeping at least THREE of your tanks alive and your construction
-      yard intact, before tick 5400. HOLD THE CORRIDOR: keep your four
-      tanks anchored in the lane and concentrate their fire on the
-      frontmost enemy — the walls confine the attackers to a 3-abreast
-      trickle you can grind down. Charging EAST out of the corridor
-      into the open, or pulling WEST and letting the enemy fan out,
-      lets all twelve enemies surround you at once and focus-fire your
-      squad down.
+      force of FOURTEEN enemy light tanks (1tnk) stages in the EAST
+      OPEN and hunts your squad — every enemy drives at the nearest
+      tank and pursues. Win by destroying at least NINE enemy units
+      while keeping at least THREE of your tanks alive AND anchored in
+      the corridor, with your construction yard intact, before tick
+      5400. HOLD THE CORRIDOR: keep your four tanks anchored in the
+      lane and concentrate their fire on the frontmost enemy — the
+      walls confine the attackers to a 3-abreast trickle you can grind
+      down. Sitting idle and letting the squad spread its fire across
+      the front is too slow — the force wears you down first. Charging
+      EAST out of the corridor into the open, or pulling WEST and
+      letting the enemy fan out, lets the whole force surround you at
+      once and focus-fire your squad down.
     overrides:
       actors:
         # SQUAD — 4 medium tanks PRE-PLACED at the choke, inside the
@@ -195,9 +197,15 @@ levels:
         # fight. building_count_gte:fact:1 in the win clause; razed
         # only if the enemy breaks the hold and reaches the west base.
         - {type: fact, owner: agent, position: [10, 20]}
-        # ENEMY FORCE — 12 light tanks hunting from the east open.
+        # ENEMY FORCE — 14 light tanks hunting from the east open.
         # They converge on the squad and pursue; the corridor funnels
-        # them to a 3-abreast trickle through the lane.
+        # them to a 3-abreast trickle through the lane. (Recalibrated
+        # 2026-05-20: bumped 12→14 after the engine movement fixes —
+        # a pre-placed stance:2 squad on pure auto-fire could grind a
+        # 12-tank trickle to the old kill quota unaided, so a stall
+        # policy won for free. 14 attackers + a quota of 9 means only
+        # active focus-fire of the frontmost tank clears the bar; the
+        # spread auto-fire of an idle squad is worn down first.)
         - {type: 1tnk, owner: enemy, position: [104, 19], stance: 3, count: 1}
         - {type: 1tnk, owner: enemy, position: [104, 20], stance: 3, count: 1}
         - {type: 1tnk, owner: enemy, position: [104, 21], stance: 3, count: 1}
@@ -210,6 +218,8 @@ levels:
         - {type: 1tnk, owner: enemy, position: [110, 19], stance: 3, count: 1}
         - {type: 1tnk, owner: enemy, position: [110, 20], stance: 3, count: 1}
         - {type: 1tnk, owner: enemy, position: [110, 21], stance: 3, count: 1}
+        - {type: 1tnk, owner: enemy, position: [106, 18], stance: 3, count: 1}
+        - {type: 1tnk, owner: enemy, position: [108, 18], stance: 3, count: 1}
         # Persistent far-east enemy fact — absorbs engine auto-done on
         # enemy-wipe so the terminal frame is evaluated.
         - {type: fact, owner: enemy, position: [122, 20]}
@@ -2020,9 +2030,15 @@ levels:
         - {type: silo, owner: enemy, position: [ 96, 38], stance: 0}
     win_condition:
       all_of:
-        - {units_killed_gte: 8}
+        - {units_killed_gte: 9}
         - {own_units_gte: 3}
         - {building_count_gte: {type: fact, n: 1}}
+        # HOLD THE CORRIDOR — ≥3 tanks must still be inside the choke
+        # region at the win evaluation. A squad that charged east
+        # (brute) or pulled west into the open (wrong-path) fails the
+        # geometry even if it scraped the kill quota; only a squad
+        # anchored in the lane satisfies it.
+        - {units_in_region_gte: {x: 53, y: 20, radius: 12, n: 3}}
         - {within_ticks: 5400}
     fail_condition:
       any_of:
@@ -3892,6 +3908,8 @@ levels:
         - {units_killed_gte: 9}
         - {own_units_gte: 3}
         - {building_count_gte: {type: fact, n: 1}}
+        # HOLD THE CORRIDOR — ≥3 tanks anchored in the choke region.
+        - {units_in_region_gte: {x: 53, y: 20, radius: 12, n: 3}}
         - {within_ticks: 5400}
     fail_condition:
       any_of:
@@ -7594,9 +7612,15 @@ levels:
         - {type: silo, owner: enemy, position: [ 96, 38], stance: 0, spawn_point: 1}
     win_condition:
       all_of:
-        - {units_killed_gte: 8}
+        - {units_killed_gte: 9}
         - {own_units_gte: 3}
         - {building_count_gte: {type: fact, n: 1}}
+        # HOLD THE CORRIDOR — ≥3 tanks anchored in the choke region.
+        # Critical on hard: with the seed-flipped enemy cluster a
+        # wrong-path retreat WEST into the open could still scrape the
+        # kill quota on some seeds; the geometry clause makes that a
+        # LOSS — the squad must be in the lane, not just alive.
+        - {units_in_region_gte: {x: 53, y: 20, radius: 12, n: 3}}
         - {within_ticks: 5400}
     fail_condition:
       any_of:

tests/test_combat_hold_chokepoint.py

@@ -8,18 +8,30 @@ corridor, 4 medium tanks grind a 12-16 strong light-tank force down
 piecemeal; the same squad fighting in the open is surrounded and
 focus-fired down.
 
-Bar (verified 2026-05-20, every level, seeds 1-4):
+Bar (recalibrated 2026-05-20 after the OpenRA-Rust engine movement
+fixes — moving units now fire and take fire en route, and attack_unit
+on an out-of-sight target paths normally. Those fixes made a static
+auto-firing squad strong enough that the old 12-tank / quota-8 easy
+tier was beatable by a pure stall; the recalibration bumps easy to 14
+attackers + quota 9 and adds a corridor-geometry win clause):
+
   • stall (only observe)        -> LOSS. The pre-placed squad
     auto-fires (stance:2) but SPREADS its fire across the 3-abreast
-    front instead of concentrating it, kills too slowly, and is worn
-    down -> own_units_gte:2 busts (killed ~3-4, lost 3).
+    front instead of concentrating it, kills too slowly (~7-8 < the
+    quota of 9), and is worn down -> own_units_gte:2 busts AND the
+    kill quota is unmet (killed 7-8, lost 3-4).
   • brute attack_move east      -> LOSS. The squad charges out of the
     corridor into the open; the whole force converges and focus-fires
-    all 4 tanks -> loss cap busted before any kills (killed 0, lost 3).
+    all 4 tanks -> loss cap busted before the kill quota (killed 0-1,
+    lost 3-4), and the squad is no longer in the choke region.
+  • wrong-path retreat WEST     -> LOSS. Pulling the squad west out of
+    the corridor into the open: even when it scrapes the kill quota
+    the survival cap busts and the units_in_region geometry clause
+    fails (the squad is at x~20, not in the lane).
   • intended hold-the-choke     -> WIN. The squad stays anchored in
     the corridor and focus-fires the frontmost enemy; the 3-abreast
-    funnel is ground down; the squad keeps >=3 tanks and hits the
-    kill quota (killed 8-10, lost 1).
+    funnel is ground down; the squad keeps >=3 tanks in the choke
+    region and hits the kill quota (killed 9-10, lost 0-1).
 
 Engine note: `silo` walls block PATHING but not weapons fire, so the
 chokepoint works by CONFINING the attacker to the 3-row lane (capping
@@ -46,8 +58,11 @@ PACK_PATH = PACKS / "combat-hold-chokepoint.yaml"
 # ── unit-level predicate checks ──────────────────────────────────────
 
 
-def _ctx(n_units, tick=1000, killed=0, fact=1):
-    """Synthesize a WinContext for predicate-level checks."""
+def _ctx(n_units, tick=1000, killed=0, fact=1, pos=(52, 20)):
+    """Synthesize a WinContext for predicate-level checks. `pos` is the
+    cell every own unit sits at — defaults to the choke (52,20) so the
+    units_in_region win clause is satisfied; pass an out-of-corridor
+    cell to exercise the geometry teeth."""
     import types
 
     sig = types.SimpleNamespace(
@@ -63,20 +78,23 @@ def _ctx(n_units, tick=1000, killed=0, fact=1):
     return WinContext(
         signals=sig,
         render_state={
-            "units_summary": [{"cell_x": 52, "cell_y": 20}] * n_units,
+            "units_summary": [
+                {"cell_x": pos[0], "cell_y": pos[1]}
+            ] * n_units,
         },
     )
 
 
 def test_predicates_easy():
     c = compile_level(load_pack(PACK_PATH), "easy")
-    # 3 tanks alive, 8 kills, fact alive, in time -> WIN
-    assert evaluate(c.win_condition, _ctx(3, tick=3000, killed=8))
+    # 3 tanks alive (in the choke region), 9 kills, fact alive, in
+    # time -> WIN
+    assert evaluate(c.win_condition, _ctx(3, tick=3000, killed=9))
     assert evaluate(c.win_condition, _ctx(4, tick=3000, killed=12))
     # only 2 tanks alive -> own_units_gte:3 fails
     assert not evaluate(c.win_condition, _ctx(2, tick=3000, killed=12))
-    # kill quota unmet -> win fails
-    assert not evaluate(c.win_condition, _ctx(4, tick=3000, killed=7))
+    # kill quota unmet (8 < 9) -> win fails
+    assert not evaluate(c.win_condition, _ctx(4, tick=3000, killed=8))
     # fact razed -> win fails
     assert not evaluate(c.win_condition, _ctx(4, tick=3000, killed=12, fact=0))
     # 1 tank left -> fail clause fires (not own_units_gte:2)
@@ -91,9 +109,10 @@ def test_predicates_easy():
 
 
 def test_predicates_medium_and_hard():
-    for lvl, quota in (("medium", 9), ("hard", 8)):
+    for lvl, quota in (("medium", 9), ("hard", 9)):
         c = compile_level(load_pack(PACK_PATH), lvl)
-        # meeting the quota with >=3 tanks and fact alive -> WIN
+        # meeting the quota with >=3 tanks in the choke and fact alive
+        # -> WIN
         assert evaluate(c.win_condition, _ctx(3, tick=3000, killed=quota))
         # one short of the quota -> win fails
         assert not evaluate(
@@ -105,6 +124,27 @@ def test_predicates_medium_and_hard():
         assert evaluate(c.fail_condition, _ctx(4, tick=5402, killed=quota))
 
 
+def test_corridor_geometry_clause_bites():
+    """The units_in_region win clause makes the hold load-bearing: a
+    squad that met the kill quota and survival cap but abandoned the
+    corridor (charged east or pulled west into the open) still fails
+    the win — only a squad anchored in the choke satisfies it."""
+    for lvl, quota in (("easy", 9), ("medium", 9), ("hard", 9)):
+        c = compile_level(load_pack(PACK_PATH), lvl)
+        # Anchored in the choke (52,20) -> WIN
+        assert evaluate(
+            c.win_condition, _ctx(4, tick=3000, killed=quota, pos=(52, 20))
+        )
+        # Pulled WEST into the open (x=20) -> geometry clause fails
+        assert not evaluate(
+            c.win_condition, _ctx(4, tick=3000, killed=quota, pos=(20, 20))
+        )
+        # Charged EAST out of the corridor (x=100) -> geometry fails
+        assert not evaluate(
+            c.win_condition, _ctx(4, tick=3000, killed=quota, pos=(100, 20))
+        )
+
+
 def test_timeout_loss_is_reachable_on_every_level():
     """No draw degeneracy: after_ticks 5401 fits inside max_turns on
     every level (~90 ticks/turn ⇒ 93 + 90·(max_turns-1))."""
@@ -170,6 +210,21 @@ def _brute_east_policy(rs, Command):
     ]
 
 
+def _wrong_path_west_policy(rs, Command):
+    """Wrong-path: pull the squad WEST out of the corridor into the
+    open ground behind the choke. Even when the retreating squad
+    auto-fires down enough pursuers to scrape the kill quota, it ends
+    outside the choke region (geometry clause fails) and the survival
+    cap busts -> LOSS on every level/seed."""
+    units = rs.get("units_summary", []) or []
+    if not units:
+        return [Command.observe()]
+    return [
+        Command.move_units([str(u["id"])], target_x=20, target_y=u["cell_y"])
+        for u in units
+    ]
+
+
 def _intended_hold_policy(rs, Command):
     """Intended hold-the-choke: keep the squad anchored in the corridor
     and FOCUS-FIRE the frontmost (lowest cell_x) enemy with every tank.
@@ -194,8 +249,10 @@ def _intended_hold_policy(rs, Command):
 @pytest.mark.parametrize("level", ["easy", "medium", "hard"])
 def test_stall_policy_loses(level):
     """Stall must LOSE on every level/seed — the pre-placed squad
-    auto-fires but spreads fire instead of concentrating it, so it is
-    worn down before the kill quota is met -> own_units_gte:2 busts."""
+    auto-fires but spreads fire instead of concentrating it, so it
+    kills too slowly (below the quota of 9) and is worn down before
+    the quota is met -> own_units_gte:2 busts AND the kill quota is
+    unmet (recalibrated 2026-05-20: 14-tank easy / quota 9)."""
     pytest.importorskip("openra_train")
     from openra_bench.eval_core import run_level
 
@@ -208,6 +265,25 @@ def test_stall_policy_loses(level):
         )
 
 
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_wrong_path_west_policy_loses(level):
+    """Wrong-path retreat WEST out of the corridor must LOSE on every
+    level/seed — the squad abandons the choke; the survival cap busts
+    and/or the units_in_region geometry win clause fails (the squad
+    sits in the open at x~20, not in the lane)."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    for s in (1, 2, 3, 4):
+        res = run_level(c, _wrong_path_west_policy, seed=s)
+        assert res.outcome == "loss", (
+            f"{level} seed={s}: wrong-path west must LOSE; got "
+            f"{res.outcome} killed={res.signals.units_killed} "
+            f"lost={res.signals.units_lost}"
+        )
+
+
 @pytest.mark.parametrize("level", ["easy", "medium", "hard"])
 def test_brute_east_policy_loses(level):
     """Brute attack_move east out of the corridor must LOSE — the squad
@@ -230,8 +306,8 @@ def test_intended_hold_wins(level):
     """The intended hold-the-choke policy (anchor in the corridor +
     focus-fire the frontmost enemy) WINS on every level/seed — the
     3-cell corridor caps the larger force to a 3-abreast trickle the
-    squad grinds down, keeping >=3 tanks (verified 2026-05-20:
-    killed 8-10, lost 1)."""
+    squad grinds down, keeping >=3 tanks anchored in the choke
+    region (recalibrated 2026-05-20: killed 9-10, lost 0-1)."""
     pytest.importorskip("openra_train")
     from openra_bench.eval_core import run_level