feat(scenario): combat-retreat-after-engagement — disengage to preserve force (SC2 retreat micro / military withdrawal anchor) [Wave-6 salvage]

openra_bench/scenarios/packs/combat-retreat-after-engagement.yaml

@@ -0,0 +1,309 @@
+# combat-retreat-after-engagement — disengage when battle goes poorly
+# to PRESERVE the force (Wave-6 reasoning pack).
+#
+# Real-world anchors:
+#   - SC2 retreat micro: when a fight is going poorly, pull units back
+#     to a safe rally point before they die. The decision is timing —
+#     too early and you don't score damage; too late and you lose the
+#     force. "Live to fight another day."
+#   - Military tactical-withdrawal doctrine (skirmish-and-pullback,
+#     covering retreat, preservation of force). A small commitment
+#     trades hits for intel/attrition, then breaks contact before the
+#     enemy can encircle and destroy.
+#
+# Idiom (the four-policy bar — same shape used by combat-kite and
+# combat-focus-fire):
+#   • stall (only observe)                    → LOSS. The kill bar
+#     (units_killed_gte:3) is never met → after_ticks LOSS.
+#   • brute attack-until-death (commit fully) → LOSS. The 2× heavy
+#     3tnk + 5× e3 rocket-infantry mass out-trades 4× 2tnk in a
+#     stand-up fight at the enemy line; tanks die two-by-two and
+#     `own_units_gte:3` flips to fail before the survivors can pull
+#     back.
+#   • never-engage (sit at safe zone)         → LOSS. Three tanks are
+#     in the safe-zone region the whole episode, but the kill bar is
+#     unmet → after_ticks LOSS.
+#   • intended engage-then-retreat            → WIN. March east into
+#     fire range, attack_unit the soft e3 rocket infantry (the kill
+#     bar is units_killed_gte:3, and 5× e3 are the cheap kills), then
+#     the moment the first tank is gone (or the second is hurt) issue
+#     a move_units order WEST back to the safe-zone region (x≈5,
+#     y≈20, r=6). All four tanks need not survive — the bar is
+#     own_units_gte:3 (lose at most ONE tank) AND ≥3 tanks back in
+#     the safe-zone radius. The decision under test is DISENGAGE
+#     TIMING: bail BEFORE attrition busts the force-preservation cap.
+#
+# Why "battle is unwinnable" (verified vs engine combat sheet):
+#   • 4× 2tnk vs 5× e3 + 2× 3tnk: head-on, the two 3tnks alone
+#     (Soviet heavy cannon, ~range 5, high anti-armour DPS) trade
+#     2tnk-for-3tnk roughly 1:1 and the rocket infantry (e3 Dragon
+#     launcher, anti-armour) finishes the surviving 2tnks. A brute
+#     attack_move column dies before clearing the squad — the loss
+#     cap (lose at most 1) flips on tank #2 going down, while only
+#     ~2 e3 have died.
+#   • The "engage 3 e3 → break contact" play kills 3 cheap targets
+#     fast (4-vs-1 focus on each e3 ends it in 1-2 decision turns)
+#     then bails BEFORE the 3tnks have ground enough HP off the
+#     column to crater the survival cap.
+#
+# Engine guardrails:
+#   • Map: rush-hour-arena (128 × 40, playable x in [2..126],
+#     y in [2..38]). Tanks stage at the west edge (x=5..7), enemies
+#     at (60,20). Cells verified placeable per CLAUDE.md (60,28 was
+#     called out as silently-failing — we use (60,20) and adjacent
+#     y=17..23).
+#   • Enemy bot is `guard` (not `hunt`): guard holds post and lunges
+#     within GUARD_AGGRO~16, snaps back past leash 18. This lets the
+#     enemy COMMIT during the engagement but NOT pursue the retreating
+#     tanks all the way home — the retreat is genuinely safe once the
+#     tanks break leash range. Critically, `guard` also means the
+#     never-engage policy is not punished by enemy approach (the
+#     enemies stay east), which is exactly what makes never-engage a
+#     CLEAN kill-bar LOSS rather than a confounded contact loss.
+#   • Persistent unarmed `fact` far east (x=120, y=20) prevents engine
+#     auto-done on enemy-elimination collapsing the run to DRAW — if
+#     the agent accidentally kills everything, the run still evaluates
+#     the in-region predicate at the safe zone (and the agent likely
+#     hasn't retreated → fail clause fires on the clock or attrition).
+#   • after_ticks 4501 ≤ 93 + 90·(51-1) = 4593 → the stall LOSS is
+#     reachable inside max_turns; no draw degeneracy.
+#   • units_lost / units_killed are signal-level integers (combat-
+#     focus-fire idiom); units_in_region_gte is the geometry predicate
+#     established by action-multiunit-coordination / artofwar-lure-
+#     the-tiger.
+
+meta:
+  id: combat-retreat-after-engagement
+  title: 'Combat Retreat — Disengage to Preserve the Force'
+  capability: reasoning
+  real_world_meaning: >
+    Four medium tanks face a numerically superior enemy squad (rocket
+    infantry + heavy tanks) at close range. The fight is unwinnable
+    head-on: the rocket infantry and heavy cannons together out-trade
+    the column inside the loss cap. The only winning play is the
+    SC2 retreat-micro idiom: commit briefly to score the kill bar on
+    the soft anti-tank infantry (e3), then break contact and pull
+    the surviving tanks BACK to the safe rally point in the west
+    before attrition busts the force-preservation cap. The decision
+    under test is disengage TIMING — stalling never engages (kill
+    bar unmet), brute attack-until-death loses the force, and only
+    the engage-then-retreat play wins.
+  robotics_analogue: >
+    Military tactical-withdrawal doctrine and the SC2 retreat-micro
+    pattern — when a battle goes poorly, the policy must IDENTIFY
+    the losing trade and pull back to a safe rally before the unit
+    is destroyed. The skill is reading the engagement state and
+    issuing a withdrawal order at the right moment; over- or
+    under-commitment both fail. Preservation of force is its own
+    objective.
+  benchmark_anchor:
+    - "SC2 retreat micro / disengage timing"
+    - "military tactical withdrawal doctrine"
+    - "preservation of force / live-to-fight-another-day"
+    - "skirmish-and-pullback tactics"
+  author: openra-bench
+
+base_map: rush-hour-arena
+
+base:
+  agent: {faction: allies, cash: 0}
+  enemy: {faction: soviet, cash: 0, bot_type: guard}
+  tools: [move_units, attack_unit, attack_move, stop]
+  planning: true
+  # React the instant a tank is destroyed — retreat timing is the
+  # capability under test; without own_unit_destroyed the policy
+  # only learns of the first loss on the next turn boundary and the
+  # second loss lands in the gap. enemy_unit_spotted lets the policy
+  # see the contact frame so it can pick targets before opening fire.
+  interrupts:
+    enemy_unit_spotted: true
+    own_unit_destroyed: true
+  termination: {max_ticks: 6000}
+  actors: []
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Bare retreat skill: 4 tanks vs LESS enemy (4× e3 + 1× 3tnk).
+  # Loss cap forgiving (own_units_gte:2 ⇒ lose up to 2 tanks), kill
+  # bar only 2. The engage-then-retreat play is comfortable; the
+  # brute may LOSE on the heavy + rocket attrition trade; stall and
+  # never-engage LOSE on the kill bar.
+  easy:
+    description: >
+      Four medium tanks (2tnk) stage at the safe zone in the west
+      (x=5, y=18..21). A smaller enemy squad of FOUR rocket
+      infantry (e3, anti-tank Dragon launcher) escorting ONE heavy
+      tank (3tnk) holds the centre at (60, 20). The fight is
+      unwinnable head-on — the rocket infantry kill armour fast
+      and the 3tnk cannon out-trades the column at close range.
+      The intended play: march east into engagement range, kill TWO
+      enemy units (the cheap e3s die in 1-2 turns of focused tank
+      fire), then move your tanks WEST BACK to the safe zone before
+      attrition busts the loss cap. Win when ≥2 enemies are killed
+      AND ≥3 of your tanks are within radius 6 of (5,20) AND you
+      have ≥2 tanks alive, before tick 4500. Stall, brute attack
+      until-death, and never-engage all LOSE.
+    overrides:
+      actors:
+        # Strike force — 4 medium tanks at the safe-zone start.
+        - {type: 2tnk, owner: agent, position: [5, 18], stance: 1}
+        - {type: 2tnk, owner: agent, position: [5, 19], stance: 1}
+        - {type: 2tnk, owner: agent, position: [5, 20], stance: 1}
+        - {type: 2tnk, owner: agent, position: [5, 21], stance: 1}
+        # Enemy squad — centre at (60,20). 4× e3 anti-tank rockets
+        # form the kill bar's soft targets; 1× 3tnk provides the
+        # attrition pressure that makes the brute LOSE.
+        - {type: e3,   owner: enemy, position: [60, 18], stance: 3}
+        - {type: e3,   owner: enemy, position: [60, 19], stance: 3}
+        - {type: e3,   owner: enemy, position: [60, 21], stance: 3}
+        - {type: e3,   owner: enemy, position: [60, 22], stance: 3}
+        - {type: 3tnk, owner: enemy, position: [60, 20], stance: 3}
+        # Persistent far-east enemy fact — prevents engine auto-done
+        # on enemy-elimination so the safe-zone predicate is
+        # evaluated rather than the run collapsing to DRAW.
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 2}
+        - {units_in_region_gte: {x: 5, y: 20, radius: 6, n: 3}}
+        - {own_units_gte: 2}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {own_units_gte: 2}}
+    max_turns: 51
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 controlled variable vs easy: FULL enemy squad (5× e3 + 2× 3tnk)
+  # AND tighter survival bar (own_units_gte:3 ⇒ lose AT MOST ONE
+  # tank). The kill bar tightens to 3. The engage window is shorter:
+  # the second 3tnk doubles the close-range damage and the brute now
+  # loses tanks ~twice as fast. The intended engage-then-retreat
+  # still wins — focus-fire 3 e3s (1-2 turns each) and pull back
+  # before the heavies grind ≥2 tanks down.
+  medium:
+    description: >
+      Four medium tanks (2tnk) stage at the safe zone in the west
+      (x=5, y=18..21). The enemy squad at (60, 20) is FIVE rocket
+      infantry (e3, anti-tank Dragon launcher) escorting TWO heavy
+      tanks (3tnk). The fight is unwinnable head-on — the rockets
+      and heavy cannons together collapse the column at close
+      range. The intended play: march east into engagement range,
+      focus-fire THREE enemy units (the cheap e3s die in 1-2 turns
+      of concentrated tank fire each), then move your tanks WEST
+      BACK to the safe zone before attrition takes a second tank.
+      Win when ≥3 enemies are killed AND ≥3 of your tanks are
+      within radius 6 of (5,20) AND you have ≥3 tanks alive,
+      before tick 4500. Stall, brute attack-until-death, and
+      never-engage all LOSE.
+    overrides:
+      actors:
+        - {type: 2tnk, owner: agent, position: [5, 18], stance: 1}
+        - {type: 2tnk, owner: agent, position: [5, 19], stance: 1}
+        - {type: 2tnk, owner: agent, position: [5, 20], stance: 1}
+        - {type: 2tnk, owner: agent, position: [5, 21], stance: 1}
+        # FULL enemy squad — 5× e3 (kill-bar fodder; anti-tank
+        # Dragon launcher) ON THE LINE at x=60, with the 2× 3tnk
+        # heavy escort placed 4 cells back at x=64. The e3 line is
+        # what the attacker must close on to score kills (Dragon
+        # range 5); from the e3 firing line (~x=55) the rear-rank
+        # 3tnks (range ~5) cannot yet engage, so they only weigh in
+        # if the agent commits PAST the e3 line — i.e. the brute
+        # attack_move policy that overshoots. Spread the e3 line
+        # across y=17..23 so all four tanks face fire.
+        - {type: e3,   owner: enemy, position: [60, 17], stance: 3}
+        - {type: e3,   owner: enemy, position: [60, 18], stance: 3}
+        - {type: e3,   owner: enemy, position: [60, 19], stance: 3}
+        - {type: e3,   owner: enemy, position: [60, 21], stance: 3}
+        - {type: e3,   owner: enemy, position: [60, 22], stance: 3}
+        # Heavy tanks placed 4 cells BEHIND the rocket line —
+        # within engagement leash for the guard bot to pursue when
+        # contact starts (GUARD_AGGRO ~16), but outside their own
+        # ~5-cell weapon range from the e3 firing line. They are
+        # the attrition trigger for the brute attack_move policy
+        # that closes past x=60 into 3tnk cannon range.
+        - {type: 3tnk, owner: enemy, position: [64, 19], stance: 3}
+        - {type: 3tnk, owner: enemy, position: [64, 21], stance: 3}
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 3}
+        - {units_in_region_gte: {x: 5, y: 20, radius: 6, n: 3}}
+        - {own_units_gte: 3}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {own_units_gte: 3}}
+    max_turns: 51
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 axis vs medium: TWO seed-driven agent spawn_point groups
+  # (NORTH safe zone at (5,10) OR SOUTH safe zone at (5,30)). The
+  # safe-zone position FLIPS per seed, so a memorised "always
+  # retreat to (5,20)" play cannot generalise — the policy must
+  # read the obs to find its own start cell and retreat to THAT
+  # safe zone. Win predicate is an any_of over the two safe-zone
+  # regions so either spawn satisfies the geometry. Enemy formation
+  # is symmetric across y=20 mid-latitude so both spawns face the
+  # same engagement geometry.
+  #
+  # 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 safe-zone
+      corridors (NORTH at x=5, y=8..11 OR SOUTH at x=5, y=28..31,
+      chosen by seed — anti-memorisation). The enemy squad of FIVE
+      rocket infantry (e3) escorting TWO heavy tanks (3tnk) holds
+      the centre at (60, 20). The fight is unwinnable head-on.
+      The intended play: march east-and-toward-centre into
+      engagement range, focus-fire THREE enemy units (the cheap
+      e3s die fast under concentrated tank fire), then move your
+      tanks BACK to YOUR safe zone (the one you started in — read
+      your start cell from obs) before attrition takes a second
+      tank. Win when ≥3 enemies are killed AND ≥3 of your tanks
+      are within radius 6 of YOUR safe zone (north (5,10) OR south
+      (5,30)) AND you have ≥3 tanks alive, before tick 4500.
+      Stall, brute attack-until-death, never-engage, and retreating
+      to the WRONG safe zone all LOSE.
+    overrides:
+      actors:
+        # spawn_point 0 — NORTH safe zone (y=8..11)
+        - {type: 2tnk, owner: agent, position: [5, 8],  stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [5, 9],  stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [5, 10], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [5, 11], stance: 1, spawn_point: 0}
+        # spawn_point 1 — SOUTH safe zone (y=28..31)
+        - {type: 2tnk, owner: agent, position: [5, 28], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [5, 29], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [5, 30], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [5, 31], stance: 1, spawn_point: 1}
+        # FULL enemy squad — symmetric across y=20 so both spawns
+        # face the same engagement geometry. e3 line forward at
+        # x=60 (Dragon range 5); 3tnk escort 4 cells back at x=64
+        # (out of weapon range from the e3 firing line so the heavy
+        # only weighs in on a brute overshoot past the rocket line).
+        - {type: e3,   owner: enemy, position: [60, 17], stance: 3}
+        - {type: e3,   owner: enemy, position: [60, 18], stance: 3}
+        - {type: e3,   owner: enemy, position: [60, 19], stance: 3}
+        - {type: e3,   owner: enemy, position: [60, 21], stance: 3}
+        - {type: e3,   owner: enemy, position: [60, 22], stance: 3}
+        - {type: 3tnk, owner: enemy, position: [64, 19], stance: 3}
+        - {type: 3tnk, owner: enemy, position: [64, 21], stance: 3}
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 3}
+        - any_of:
+            - {units_in_region_gte: {x: 5, y: 10, radius: 6, n: 3}}
+            - {units_in_region_gte: {x: 5, y: 30, radius: 6, n: 3}}
+        - {own_units_gte: 3}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {own_units_gte: 3}}
+    max_turns: 51

tests/test_combat_retreat_after_engagement.py

@@ -0,0 +1,338 @@
+"""combat-retreat-after-engagement — disengage to preserve the force.
+
+Bar (four script-policy proxies):
+  • stall (observe only)                    → LOSS (kill bar unmet)
+  • brute attack-until-death                → LOSS (loses too many tanks)
+  • never-engage (sit at safe zone)         → LOSS (kill bar unmet)
+  • intended engage-then-retreat            → WIN
+
+The "intended" policy is the spec's load-bearing decision: march east
+into engagement range, focus-fire e3 rocket infantry (the cheap kill-
+bar targets), and the instant the kill bar is met OR a tank is lost
+pull back to the safe-zone radius. The retreat trigger is the
+capability under test — too early ⇒ kill bar fails; too late ⇒
+attrition busts the survival bar.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+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-retreat-after-engagement.yaml"
+
+
+# ── unit-level predicate checks ──────────────────────────────────────
+
+
+def _ctx(units_xy=(), tick=1000, killed=0, lost=0):
+    """Synthesize a WinContext for predicate-level checks."""
+    import types
+
+    sig = types.SimpleNamespace(
+        game_tick=tick,
+        units_killed=killed,
+        units_lost=lost,
+        own_buildings=[],
+        own_building_types=set(),
+        enemies_seen_ids=set(),
+        enemy_buildings_seen_ids=set(),
+    )
+    return WinContext(
+        signals=sig,
+        render_state={
+            "units_summary": [
+                {"cell_x": x, "cell_y": y} for x, y in units_xy
+            ]
+        },
+    )
+
+
+def test_predicates_easy():
+    c = compile_level(load_pack(PACK_PATH), "easy")
+    # 3 tanks back in safe zone (5,20,r=6), killed 2 enemies, 1 lost, in time → WIN
+    home3 = [(5, 18), (5, 20), (5, 21)]
+    assert evaluate(c.win_condition, _ctx(home3, tick=3000, killed=2, lost=1))
+    # Kill bar unmet (only 1 killed) → not WIN
+    assert not evaluate(c.win_condition, _ctx(home3, tick=3000, killed=1, lost=1))
+    # Tanks elsewhere (not at safe zone) → not WIN
+    assert not evaluate(
+        c.win_condition, _ctx([(55, 20), (55, 21), (55, 22)], tick=3000, killed=3, lost=1)
+    )
+    # 3 tanks lost (only 1 alive) → fail clause own_units_gte:2 fires
+    assert evaluate(c.fail_condition, _ctx([(5, 20)], tick=3000, killed=3, lost=3))
+    # Past deadline → real LOSS reachable within max_turns
+    assert evaluate(c.fail_condition, _ctx(home3, tick=4502, killed=0, lost=0))
+    assert 4501 <= 93 + 90 * (c.max_turns - 1), (
+        "easy after_ticks 4501 must be reachable within max_turns"
+    )
+
+
+def test_predicates_medium_force_preservation_bar():
+    c = compile_level(load_pack(PACK_PATH), "medium")
+    home3 = [(5, 18), (5, 20), (5, 21)]
+    home2 = home3[:2]
+    # Intended: 3 kills, ≥3 tanks at safe zone, ≤1 lost → WIN
+    assert evaluate(c.win_condition, _ctx(home3, tick=3000, killed=3, lost=1))
+    # Same kills but only 2 tanks left → predicate fails (need ≥3)
+    assert not evaluate(c.win_condition, _ctx(home2, tick=3000, killed=3, lost=2))
+    # 3 tanks alive but only 2 in safe zone → fails
+    assert not evaluate(
+        c.win_condition,
+        _ctx([(5, 20), (5, 21), (55, 20)], tick=3000, killed=3, lost=1),
+    )
+    # 2 tanks alive ⇒ fail clause fires (preservation cap)
+    assert evaluate(c.fail_condition, _ctx(home2, tick=3000, killed=3, lost=2))
+    # Past deadline ⇒ real LOSS reachable
+    assert evaluate(c.fail_condition, _ctx(home3, tick=4502, killed=0, lost=0))
+    assert 4501 <= 93 + 90 * (c.max_turns - 1)
+
+
+def test_predicates_hard_two_safe_zones():
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    # NORTH safe zone (5,10) satisfies the any_of geometry
+    home_north = [(5, 9), (5, 10), (5, 11)]
+    assert evaluate(c.win_condition, _ctx(home_north, tick=3000, killed=3, lost=1))
+    # SOUTH safe zone (5,30) also satisfies the any_of geometry
+    home_south = [(5, 29), (5, 30), (5, 31)]
+    assert evaluate(c.win_condition, _ctx(home_south, tick=3000, killed=3, lost=1))
+    # Tanks at the WRONG centre (5,20) — outside BOTH safe zones at r=6
+    # ((5,20)-(5,10)=10>6 and (5,20)-(5,30)=10>6) → fails the geometry
+    assert not evaluate(
+        c.win_condition,
+        _ctx([(5, 20), (5, 19), (5, 21)], tick=3000, killed=3, lost=1),
+    )
+    # Past tighter deadline → real LOSS reachable
+    assert evaluate(c.fail_condition, _ctx(home_north, tick=4502, killed=0, lost=0))
+    assert 4501 <= 93 + 90 * (c.max_turns - 1)
+
+
+def test_hard_has_two_spawn_point_groups():
+    """Hard-tier curation contract: ≥2 agent spawn_point groups so
+    the seed flips the safe-zone corridor."""
+    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}"
+
+
+def test_pack_compiles_and_meta_fields_populated():
+    pack = load_pack(PACK_PATH)
+    assert pack.meta.capability == "reasoning"
+    assert pack.meta.id == "combat-retreat-after-engagement"
+    anchors = pack.meta.benchmark_anchor
+    assert isinstance(anchors, list) and anchors, "benchmark_anchor required"
+    joined = " ".join(anchors).lower()
+    # Anchored to the doctrines the brief calls out: SC2 retreat
+    # micro + military tactical withdrawal + preservation of force.
+    assert "retreat" in joined
+    assert "withdrawal" in joined or "preservation" in joined or "pullback" in joined
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        assert c.map_supported
+        assert c.win_condition is not None and c.fail_condition is not None
+
+
+def test_timeout_loss_is_reachable_on_every_level():
+    """No draw degeneracy: the after_ticks deadline fits inside
+    max_turns on every level (∼90 ticks/turn ⇒ 93 + 90·(max_turns-1))."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        assert 4501 <= 93 + 90 * (c.max_turns - 1), (
+            f"{lvl}: after_ticks 4501 not reachable within max_turns"
+        )
+
+
+# ── engine-driven scripted policies ──────────────────────────────────
+#
+# The four-policy bar. All engine-driven tests guard on the Rust env
+# wheel; predicate-level tests above run without it.
+
+
+def _stall_policy(rs, Command):
+    """Stall: only observe. Kill bar never met → after_ticks LOSS."""
+    return [Command.observe()]
+
+
+def _brute_attack_until_death_policy(rs, Command):
+    """Brute: attack_move toward the enemy centre and never retreat.
+    The 2× 3tnk + 5× e3 mass alpha out-trades 4× 2tnk in melee; the
+    column dies before clearing the squad → own_units_gte:N fails."""
+    units = rs.get("units_summary", []) or []
+    if not units:
+        return [Command.observe()]
+    return [
+        Command.attack_move([str(u["id"])], target_x=60, target_y=20)
+        for u in units
+    ]
+
+
+def _never_engage_policy(rs, Command):
+    """Never-engage: each turn re-issue a move-in-place at the spawn.
+    The agent has ≥3 tanks in the safe zone the entire episode, but
+    units_killed_gte:N is never met → after_ticks LOSS. This is the
+    "preserve everything, score nothing" trap the kill bar punishes."""
+    units = rs.get("units_summary", []) or []
+    if not units:
+        return [Command.observe()]
+    return [
+        Command.move_units(
+            [str(u["id"])], target_x=u["cell_x"], target_y=u["cell_y"]
+        )
+        for u in units
+    ]
+
+
+def _make_intended_engage_then_retreat():
+    """Intended policy (the spec's load-bearing decision): march to
+    the engagement axis, focus-fire e3 rocket infantry, and the
+    instant a tank is lost OR ≥3 enemies are observed killed pull
+    back to the safe-zone radius (detected from the agent's spawn
+    median-y latched on first observation). Stateful — uses a
+    closure to track the peak number of visible killables (so we
+    can infer kills from the shrink without reading
+    signals.units_killed)."""
+    state = {"peak_visible": 0, "retreat_latched": False, "home_y": None}
+
+    def pol(rs, Command):
+        units = rs.get("units_summary", []) or []
+        enemies = rs.get("enemy_summary", []) or []
+        if not units:
+            return [Command.observe()]
+        # Latch the home Y on first observation. The agent's spawn
+        # cell median y resolves to one of the three safe-zone
+        # corridors (north y=10, centre y=20, south y=30).
+        if state["home_y"] is None:
+            ys = sorted(u["cell_y"] for u in units)
+            hy_med = ys[len(ys) // 2]
+            if hy_med < 15:
+                state["home_y"] = 10
+            elif hy_med > 25:
+                state["home_y"] = 30
+            else:
+                state["home_y"] = 20
+        hy = state["home_y"]
+        n_alive = len(units)
+        killable = [
+            e
+            for e in enemies
+            if not e.get("is_building")
+            and (e.get("type") or "").lower() != "fact"
+        ]
+        visible = len(killable)
+        if visible > state["peak_visible"]:
+            state["peak_visible"] = visible
+        killed_observed = state["peak_visible"] - visible
+        # RETREAT TRIGGER: latched, or any tank lost, or ≥3 enemies
+        # observed killed. Once retreating, stay retreating (a re-
+        # engagement would re-expose the survivors to attrition).
+        if state["retreat_latched"] or n_alive < 4 or killed_observed >= 3:
+            state["retreat_latched"] = True
+            return [
+                Command.move_units([str(u["id"])], target_x=5, target_y=hy)
+                for u in units
+            ]
+        # ENGAGE: pick the closest e3 to home and focus-fire it with
+        # ALL tanks (4-vs-1 ends a Dragon-soldier in 1-2 decision turns).
+        e3s = [e for e in killable if (e.get("type") or "").lower() == "e3"]
+        if e3s:
+            e3s.sort(
+                key=lambda e: (e["cell_x"] - 5) ** 2 + (e["cell_y"] - hy) ** 2
+            )
+            t = e3s[0]
+            return [
+                Command.attack_unit([str(u["id"])], str(t["id"])) for u in units
+            ]
+        # APPROACH: advance toward the engagement axis (50, 20) so
+        # the spawn corridor (y=10 or y=30 on hard) closes onto the
+        # mid-latitude line where the e3s will come into view.
+        return [
+            Command.move_units(
+                [str(u["id"])],
+                target_x=min(50, u["cell_x"] + 12),
+                target_y=20,
+            )
+            for u in units
+        ]
+
+    return pol
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_stall_policy_loses(level):
+    """Stall must LOSE on every level — kill bar unmet → after_ticks LOSS."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    seeds = (1, 2, 3, 4) if level == "hard" else (1,)
+    for s in seeds:
+        res = run_level(c, _stall_policy, seed=s)
+        assert res.outcome == "loss", (
+            f"{level} seed={s}: stall must LOSE; got {res.outcome} "
+            f"k={res.signals.units_killed} l={res.signals.units_lost}"
+        )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_brute_attack_until_death_loses(level):
+    """Brute attack-until-death must LOSE — the mass alpha at the
+    enemy line out-trades the column before the bar is met."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    seeds = (1, 2, 3, 4) if level == "hard" else (1,)
+    for s in seeds:
+        res = run_level(c, _brute_attack_until_death_policy, seed=s)
+        assert res.outcome == "loss", (
+            f"{level} seed={s}: brute must LOSE; got {res.outcome} "
+            f"k={res.signals.units_killed} l={res.signals.units_lost}"
+        )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_never_engage_policy_loses(level):
+    """Never-engage must LOSE — ≥3 tanks survive in the safe zone,
+    but units_killed_gte:N is never met → after_ticks LOSS."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    seeds = (1, 2, 3, 4) if level == "hard" else (1,)
+    for s in seeds:
+        res = run_level(c, _never_engage_policy, seed=s)
+        assert res.outcome == "loss", (
+            f"{level} seed={s}: never-engage must LOSE; got {res.outcome} "
+            f"k={res.signals.units_killed} l={res.signals.units_lost}"
+        )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_intended_engage_then_retreat_wins(level):
+    """Intended engage-then-retreat must WIN on every level and every
+    hard seed (1..4): focus-fire e3s, retreat the instant a tank is
+    lost or ≥3 kills observed, end with ≥3 tanks in the safe zone."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    seeds = (1, 2, 3, 4) if level == "hard" else (1,)
+    for s in seeds:
+        pol = _make_intended_engage_then_retreat()
+        res = run_level(c, pol, seed=s)
+        assert res.outcome == "win", (
+            f"{level} seed={s}: intended engage-then-retreat must WIN; "
+            f"got {res.outcome} k={res.signals.units_killed} "
+            f"l={res.signals.units_lost}"
+        )

tests/test_hard_tier.py

@@ -400,6 +400,8 @@ UPGRADED = [
     # bands (y=12 / y=28) punishes the near-edge shortcut so a
     # memorised single-detour-band opening cannot generalise.
     "scout-and-report",
+    # Wave-6 salvage: agent timeout pre-commit
+    "combat-retreat-after-engagement",
     # Wave-6 proc-checklist-no-deviation: strict ordered visit-
     # checklist (IFBench step-order / PlanBench strict ordering /
     # aviation pre-flight / SOP no-skip-no-reorder anchor). Hard