feat(scenario): combat-bait-counter-attack — sacrificial bait + flanking strike (SC2 bait / military feint anchor)

Wave-4 Group D reasoning pack. A leashed GUARD cluster (engine
scripted bot 'guard', GUARD_AGGRO ≈ 16 / GUARD_LEASH ≈ 18) sits
clumped on the west face of the enemy construction yard (`fact`).
The intended idiom commits a cheap jeep as bait on a divergent
hemisphere flank, pulling a SIDE of the cluster off post; the strike
tanks engage the matching-side guards (now away from post, vulnerable)
in a favourable trade, then destroy the briefly-undefended yard. The
discrimination:

• stall LOSES (clock runs out, fact intact)
• brute frontal LOSES (anti-tank Dragon fire shreds the column,
units_lost_lte cap fails)
• bait-only LOSES (fact not destroyed → enemy_key_buildings_destroyed
unsatisfied → clock runs out)
• intended bait + counter-attack WINS

Engine notes: an unarmed sentinel fact at (120,4) keeps the episode
alive past the moment the objective fact dies so the within_ticks /
units_lost_lte predicates evaluate cleanly on the terminal frame
(CLAUDE.md MustBeDestroyed auto-terminate footgun).

Difficulty axis (one controlled variable per tier):
easy: 3 guards on the west face, cap 3
medium: 5 guards on west + south faces, cap 2
hard: 6 guards split NW+SW + 2 spawn_point groups round-robin'd by
seed so the working bait-direction / counter-attack-target
pair flips per seed (cannot be memorised), cap 2

Bar verified by scripted policies on every level × seed 1..4. Hard-
tier registered in tests/test_hard_tier.py::UPGRADED.

Benchmark anchors: SC2 bait micro / sacrificial pull; military
feint-and-flank doctrine; CICERO / Diplomacy deception.

openra_bench/scenarios/packs/combat-bait-counter-attack.yaml

@@ -0,0 +1,271 @@
+# combat-bait-counter-attack.yaml
+#
+# REASONING capability — bait-and-flank counter-attack micro. A
+# leashed GUARD cluster (scripted `guard` bot, GUARD_AGGRO ≈ 16 /
+# GUARD_LEASH ≈ 18 from spawn cell) sits clumped on the WEST face of
+# the enemy construction yard (`fact`) and forms a wall of anti-tank
+# rocket infantry (e3) directly between the agent and the objective.
+# Drive the strike tanks straight in and every guard auto-fires on
+# the approach — e3 anti-tank DPS shreds a 2tnk column before the
+# fact falls and the attrition cap (units_lost_lte:N) trips. Sit
+# still and the clock runs out (within_ticks 5400).
+#
+# The intended idiom is the SC2 bait-micro / military feint-and-flank
+# doctrine: commit the cheap fast jeep as bait on a divergent vector
+# that comes WITHIN aggro radius of a SEGMENT of the cluster (e.g.
+# south-flank approach), pulling those guards OFF post; in the
+# transient window while they're off-post chasing the jeep toward
+# their leash, swing the strike tanks around through the now-vacated
+# slot (north flank) to hit the briefly-undefended `fact`. Phase 1
+# (the bait pull) yields zero objective progress and looks locally
+# negative (the jeep is drawing fire); only phase 2, through the
+# vacated slot, scores.
+#
+# Distinct from `artofwar-lure-the-tiger` (a LINE-of-guards walling
+# a corridor: the bait pulls a segment off the wall to open a passage
+# for the main body to TRAVERSE through to a far landmark) and
+# `artofwar-decoy-sacrifice` (a HUNTING picket that actively pursues:
+# bait spends to draw chasers off a corridor): here the cluster
+# GUARDS a fixed objective `fact` and the win is the FACT BEING
+# DESTROYED — the bait displaces a side of the cluster off post and
+# the strike force exploits the gap to attack the objective itself,
+# not pass through.
+#
+# Engine notes (per CLAUDE.md):
+#   - `fact` is `MustBeDestroyed`: razing it would auto-`done` the
+#     engine. A SENTINEL enemy `fact` is placed in the far north so
+#     the episode persists past the objective `fact` destruction
+#     until the engine evaluates win/fail predicates — including the
+#     attrition cap (units_lost_lte) and the deadline (within_ticks).
+#   - GUARD_AGGRO ≈ 16, GUARD_LEASH ≈ 18 from spawn_cell. The bait
+#     vector must come WITHIN ≈16 of a guard's spawn cell to lunge;
+#     the strike vector must keep the strike tanks beyond aggro of
+#     the remaining guards on the loop-around path.
+#   - `move_units` auto-fires opportunistically; tanks travelling
+#     close to a remaining guard will engage en route. The flank
+#     route must keep the column out of every remaining guard's
+#     weapon range until it reaches the fact.
+
+meta:
+  id: combat-bait-counter-attack
+  title: 'Bait + Counter-Attack — Pull the Guards Off Post, Strike the Undefended Yard'
+  capability: reasoning
+  real_world_meaning: >
+    A reactive defending cluster (scripted `guard` bot: holds its post,
+    auto-fires in range, lunges at the nearest foe within an aggro
+    radius, snaps back past a leash) is bunched on the approach side
+    of the enemy construction yard. Driving the strike force straight
+    in eats anti-tank fire from the whole cluster and runs the
+    attrition cap before the objective falls. The winning policy
+    commits a cheap fast bait (jeep) on a DIVERGENT vector that comes
+    just close enough to make a SIDE of the cluster lunge off post
+    after the bait, then runs the strike tanks around through the
+    now-vacated flank to destroy the construction yard while it is
+    briefly undefended. Phase 1 (the bait pull) yields zero objective
+    progress and looks locally negative; phase 2, through the slot
+    the bait opened, scores. The credit problem is FEINT-AND-FLANK:
+    the bait must displace a segment of the cluster and the strike
+    must exploit the reversible vacancy in time; bait-only never
+    razes the yard, brute frontal trades the strike force against
+    the full cluster, stalling loses the clock.
+  robotics_analogue: >
+    Sacrificial-decoy planning against a reactive guarding obstacle:
+    a no-reward enabling action (entice a leashed interceptor off the
+    objective with a decoy on a divergent vector) must precede and
+    temporally overlap the rewarded objective action (commit the
+    payload force on the briefly-cleared flank to destroy the
+    objective before the interceptor snaps back).
+  benchmark_anchor:
+    - "SC2 bait micro / sacrificial pull"
+    - "military feint-and-flank doctrine"
+    - "CICERO / Diplomacy deception"
+  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
+  termination: {max_ticks: 12000}
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # The bare bait-and-flank skill: 3 leashed guards lined on the
+  # WEST face of the enemy fact (the natural approach side), generous
+  # loss cap (3). Brute frontal: the 3-tank column eats anti-tank
+  # fire from all 3 guards on the approach, trades the whole strike
+  # force before the fact falls, trips the attrition cap. Stall:
+  # clock runs out (within_ticks 5400). Bait-only: jeep pulls all 3
+  # guards south off post but no strike — fact survives, clock runs
+  # out. Intended: jeep dives south-east to (78, 32); all three
+  # west-face guards are within ≈16 cells (distances 12/14/10) and
+  # lunge south after it. While the jeep kites them at their leash,
+  # the strike tanks drive east along y=20 through the now-cleared
+  # west face and destroy the undefended yard.
+  easy:
+    description: >
+      Three leashed rocket-infantry guards stand on the west face of
+      the enemy construction yard (`fact` at 80,20), directly
+      between you and the objective. They hold post, auto-fire on
+      units in range, lunge at the nearest foe within ≈16 cells, and
+      snap back past a leash of ≈18. Destroy the enemy construction
+      yard with at most 3 of your units lost before tick 5400.
+      Driving the 3 tanks straight east at the yard puts them in
+      anti-tank fire from the whole guard line; stalling runs the
+      clock. Commit the fast jeep on a divergent south-east vector
+      so all three guards lunge south after it; while the jeep
+      kites them at their leash, run the strike tanks straight
+      through the now-undefended west face to destroy the yard.
+    overrides:
+      actors:
+        # Strike force: 3 medium tanks at west, central staging.
+        - {type: 2tnk, owner: agent, position: [6, 20], stance: 1, count: 3}
+        # Bait: 1 fast jeep at west, south staging.
+        - {type: jeep, owner: agent, position: [6, 28], stance: 1}
+        # The OBJECTIVE: enemy construction yard at mid-map.
+        - {type: fact, owner: enemy, position: [80, 20]}
+        # The GUARDS: 3 leashed rocket infantry on the WEST face of
+        # the fact. A south-flank jeep at (78,32) is within aggro
+        # ≈16 cells of all three (distances ≈14/12/10), so all
+        # three lunge south after it, clearing the west approach.
+        - {type: e3, owner: enemy, position: [76, 18], stance: 2}
+        - {type: e3, owner: enemy, position: [76, 20], stance: 2}
+        - {type: e3, owner: enemy, position: [76, 22], stance: 2}
+        # SENTINEL: persistent enemy fact at far north (out of the
+        # combat zone, agent can't reach it in budget) so the engine
+        # does not auto-`done` the instant the objective fact dies,
+        # letting the within_ticks / units_lost_lte predicates
+        # evaluate cleanly on the terminal frame.
+        - {type: fact, owner: enemy, position: [120, 4]}
+    win_condition:
+      all_of:
+        - {enemy_key_buildings_destroyed: {types: [fact]}}
+        - {within_ticks: 5400}
+        - {units_lost_lte: 3}
+    fail_condition:
+      any_of:
+        - {after_ticks: 5401}
+        - {not: {units_lost_lte: 3}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 62
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 controlled variable: 5 guards forming a south + west L-cover
+  # of the yard (the two natural west-staging approaches: head-on
+  # along y=20 OR a south sweep along y=24..28), so a single south
+  # bait pulls the south arc off while the west arc still covers
+  # the head-on lane — the strike must LOOP NORTH to come in via
+  # the cleared y=10..16 corridor. Strict attrition cap (only the
+  # bait jeep + at most one tank may be spent).
+  medium:
+    description: >
+      A denser cluster of 5 leashed rocket-infantry guards covers
+      the enemy construction yard (`fact` at 80,20) on the WEST and
+      SOUTH faces (the two natural approaches from your west base).
+      A head-on push along y=20 is now decisively fatal. You may
+      spend at most 2 units — losing a second tank fails. Commit the
+      fast jeep on a south flank vector to pull the south arc of
+      guards off post after it; the west arc still covers the y=20
+      head-on lane, so loop the strike tanks NORTH through the
+      cleared y=10 corridor and dive south onto the yard from
+      above. Destroy the yard before tick 5400. Bait-only (no
+      strike) loses on the clock; brute frontal trades the strike
+      force.
+    overrides:
+      actors:
+        - {type: 2tnk, owner: agent, position: [6, 20], stance: 1, count: 3}
+        - {type: jeep, owner: agent, position: [6, 28], stance: 1}
+        - {type: fact, owner: enemy, position: [80, 20]}
+        # 5 guards on the WEST + SOUTH faces. Bait at (78,32) pulls
+        # the SOUTH arc (76,24), (80,24), (84,24) — distances ≤12;
+        # the WEST arc (76,18), (76,20) stays but is OUT of weapon
+        # range of a north-flank y=10 approach (distance ≥22).
+        - {type: e3, owner: enemy, position: [76, 18], stance: 2}
+        - {type: e3, owner: enemy, position: [76, 20], stance: 2}
+        - {type: e3, owner: enemy, position: [76, 24], stance: 2}
+        - {type: e3, owner: enemy, position: [80, 24], stance: 2}
+        - {type: e3, owner: enemy, position: [84, 24], stance: 2}
+        - {type: fact, owner: enemy, position: [120, 4]}
+    win_condition:
+      all_of:
+        - {enemy_key_buildings_destroyed: {types: [fact]}}
+        - {within_ticks: 5400}
+        - {units_lost_lte: 2}
+    fail_condition:
+      any_of:
+        - {after_ticks: 5401}
+        - {not: {units_lost_lte: 2}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 62
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 more controlled variable: 6 guards split into a NORTH-WEST
+  # half-cluster (y=16..18) and a SOUTH-WEST half-cluster (y=22..24),
+  # covering BOTH the north-flank y=10 corridor and the south-flank
+  # y=30 corridor (so a single fixed bait/flank pair doesn't work
+  # across seeds). Two spawn_point groups round-robin the agent's
+  # staging latitude — from the NORTH spawn the bait pulls the NW
+  # half off and the strike loops SOUTH; from the SOUTH spawn the
+  # bait pulls the SW half off and the strike loops NORTH. Strict
+  # loss cap of 1 — only the bait jeep may be spent; burning ANY
+  # tank fails. The strike must hit the yard essentially untouched.
+  hard:
+    description: >
+      Densest guard cover (6 leashed rocket-infantry split into a
+      NW half and a SW half around the enemy construction yard at
+      80,20 — covering both the north-flank y=10 corridor and the
+      south-flank y=30 corridor). The force stages from a seed-
+      chosen latitude (north or south), so the working bait/strike
+      pair varies per seed and can't be memorised. You may spend at
+      most 2 units (the bait jeep + at most one tank) — losing a
+      second tank fails. Destroy the yard before tick 5400. Brute
+      frontal trades armour and fails; bait-only never razes the
+      yard; stalling loses the clock.
+    overrides:
+      actors:
+        # spawn_point 0 — NORTH staging (y≈10): the bait dives
+        # further north into the NW half's aggro arc (pulling it
+        # off post), the strike loops SOUTH through the cleared
+        # y=10 corridor over the top and down onto the yard.
+        - {type: 2tnk, owner: agent, position: [6, 10], stance: 1, count: 3,
+           spawn_point: 0,
+           randomize: {position: {base: [6, 10], offset: 2}}}
+        - {type: jeep, owner: agent, position: [6, 14], stance: 1,
+           spawn_point: 0}
+        # spawn_point 1 — SOUTH staging (y≈30): mirror layout. Bait
+        # dives further south into the SW half's aggro arc, strike
+        # loops NORTH through the cleared y=30 corridor.
+        - {type: 2tnk, owner: agent, position: [6, 30], stance: 1, count: 3,
+           spawn_point: 1,
+           randomize: {position: {base: [6, 30], offset: 2}}}
+        - {type: jeep, owner: agent, position: [6, 26], stance: 1,
+           spawn_point: 1}
+        # The OBJECTIVE.
+        - {type: fact, owner: enemy, position: [80, 20]}
+        # 6 guards in TWO cluster halves on the WEST face of the
+        # yard: NW half (y=16..18) and SW half (y=22..24). Each
+        # half covers its matching flank corridor (y=10 from above,
+        # y=30 from below) within aggro ≈16. Both halves always
+        # place — enemy actors are not spawn_point filtered (per
+        # CLAUDE.md). The seed varies which staging latitude the
+        # agent starts from, so the natural bait/strike sides flip.
+        - {type: e3, owner: enemy, position: [76, 16], stance: 2}
+        - {type: e3, owner: enemy, position: [78, 17], stance: 2}
+        - {type: e3, owner: enemy, position: [76, 18], stance: 2}
+        - {type: e3, owner: enemy, position: [76, 22], stance: 2}
+        - {type: e3, owner: enemy, position: [78, 23], stance: 2}
+        - {type: e3, owner: enemy, position: [76, 24], stance: 2}
+        - {type: fact, owner: enemy, position: [120, 4]}
+    win_condition:
+      all_of:
+        - {enemy_key_buildings_destroyed: {types: [fact]}}
+        - {within_ticks: 5400}
+        - {units_lost_lte: 2}
+    fail_condition:
+      any_of:
+        - {after_ticks: 5401}
+        - {not: {units_lost_lte: 2}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 62

tests/test_combat_bait_counter_attack.py

@@ -0,0 +1,443 @@
+"""combat-bait-counter-attack — bait-and-flank counter-attack micro.
+
+The bar: intended bait-then-strike (bait jeep pulls a SIDE of a leashed
+GUARD cluster off the enemy fact; strike tanks engage the now-isolated
+guards and then destroy the briefly-undefended fact) WINS on every
+level and every hard seed (1..4). STALL (only observe), BRUTE FRONTAL
+(attack-move all units east at the fact), and BAIT-ONLY (jeep flanks
+south but no strike) all LOSE on every level and every hard seed.
+Non-win is a real reachable timeout LOSS via the `after_ticks` fail
+clause; `units_lost_lte` provides the second LOSS path (brute frontal
+trades the strike force).
+
+Validation is scripted (no model / network).
+"""
+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-bait-counter-attack.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-bait-counter-attack"
+    assert pack.meta.capability == "reasoning"
+    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 all 3 anchors, got {anchors!r}"
+    )
+    joined = " ".join(anchors).lower()
+    for needle in ("sc2", "feint", "cicero"):
+        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, lost=0, fact_destroyed=False):
+    """Synthesize a WinContext for predicate-level checks."""
+    import types
+
+    types_count = {"fact": 1} if fact_destroyed else {}
+    sig = types.SimpleNamespace(
+        game_tick=tick,
+        units_killed=0,
+        units_lost=lost,
+        cash=0,
+        resources=0,
+        own_buildings=[],
+        own_building_types=set(),
+        enemies_seen_ids=set(),
+        enemy_buildings_seen_ids=set(),
+        enemy_buildings_destroyed=1 if fact_destroyed else 0,
+        enemy_buildings_destroyed_types=types_count,
+        enemy_buildings_destroyed_records=(
+            [("fact", 80, 20)] if fact_destroyed else []
+        ),
+    )
+    return WinContext(
+        signals=sig,
+        render_state={"units_summary": list(units)},
+    )
+
+
+def _alive(n):
+    return [
+        {"cell_x": 10, "cell_y": 20, "type": "2tnk", "id": str(1000 + i)}
+        for i in range(n)
+    ]
+
+
+def test_easy_predicates():
+    c = compile_level(load_pack(PACK_PATH), "easy")
+    # Intended: fact destroyed, 1 unit lost (bait), in budget → WIN
+    assert evaluate(
+        c.win_condition,
+        _ctx(units=_alive(3), tick=3000, lost=1, fact_destroyed=True),
+    )
+    # Fact NOT destroyed → not a win even if in budget and few losses
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=_alive(3), tick=3000, lost=1, fact_destroyed=False),
+    )
+    # Loss cap (3) tripped → not a win
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=_alive(0), tick=3000, lost=4, fact_destroyed=True),
+    )
+    # Past deadline → not a win
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=_alive(3), tick=5401, lost=1, fact_destroyed=True),
+    )
+    # Timeout with bar unmet → fail (after_ticks 5401)
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=_alive(3), tick=5500, lost=1, fact_destroyed=False),
+    )
+    # Force-wipe → fail (not own_units_gte:1)
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=[], tick=3000, lost=4, fact_destroyed=False),
+    )
+    # Loss cap tripped (>3) → fail
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=_alive(0), tick=3000, lost=4, fact_destroyed=True),
+    )
+
+
+def test_medium_predicates():
+    c = compile_level(load_pack(PACK_PATH), "medium")
+    # Intended: fact destroyed, ≤2 lost → WIN
+    assert evaluate(
+        c.win_condition,
+        _ctx(units=_alive(3), tick=3000, lost=2, fact_destroyed=True),
+    )
+    # 3 lost (one too many) → not a win, AND fail
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=_alive(2), tick=3000, lost=3, fact_destroyed=True),
+    )
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=_alive(2), tick=3000, lost=3, fact_destroyed=True),
+    )
+    # Timeout with fact intact → fail
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=_alive(4), tick=5500, lost=1, fact_destroyed=False),
+    )
+
+
+def test_hard_predicates():
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    # Intended: fact destroyed, ≤2 lost → WIN (cap is 2: bait + ≤1 tank)
+    assert evaluate(
+        c.win_condition,
+        _ctx(units=_alive(3), tick=3500, lost=2, fact_destroyed=True),
+    )
+    # 3 lost → not a win, AND fail
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=_alive(1), tick=3500, lost=3, fact_destroyed=True),
+    )
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=_alive(1), tick=3500, lost=3, fact_destroyed=True),
+    )
+
+
+def test_timeout_reachable_inside_max_turns():
+    """No draw degeneracy: after_ticks 5401 ≤ 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 5401 <= max_tick, (
+            f"{lvl}: after_ticks 5401 > max reachable tick {max_tick} "
+            f"(max_turns={c.max_turns}); deadline never bites"
+        )
+        assert 5400 <= max_tick, (
+            f"{lvl}: within_ticks 5400 > max tick {max_tick}"
+        )
+
+
+def test_hard_has_two_spawn_point_groups():
+    """Hard-tier curation: ≥2 distinct agent spawn_point groups so the
+    seed round-robins the staging latitude (north y=10 / south y=30).
+    Engine-roundtrip is asserted by tests/test_hard_tier.py."""
+    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_guard_bot_and_e3_cluster():
+    """The enemy must be the `guard` scripted bot (leashed defender) and
+    the cluster must be e3 rocket-infantry (anti-tank Dragon, range 5,
+    damage 5000 vs Heavy) — these together make the bait-and-flank idiom
+    load-bearing (a hunter or patrol bot would not snap back, and an e1
+    cluster would not threaten the strike tanks)."""
+    pack = load_pack(PACK_PATH)
+    enemy = pack.base.get("enemy") if isinstance(pack.base, dict) else None
+    assert enemy is not None
+    bot = enemy.get("bot_type") or enemy.get("bot") or ""
+    assert bot == "guard", f"expected guard bot, got {bot!r}"
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        types = [a.type for a in c.scenario.actors if a.owner == "enemy"]
+        assert "e3" in types, f"{lvl}: cluster must be e3 rocket infantry"
+        assert "fact" in types, f"{lvl}: objective must include enemy fact"
+
+
+def test_objective_fact_and_sentinel_present():
+    """Two enemy `fact` per level: one objective fact (mid-map, ~80,20)
+    and one sentinel fact (far north ~120,4) keeping the episode alive
+    past objective-fact destruction so within_ticks / units_lost_lte
+    can evaluate on the terminal frame (the CLAUDE.md auto-terminate
+    footgun on MustBeDestroyed)."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        facts = [
+            (a.position[0], a.position[1])
+            for a in c.scenario.actors
+            if a.owner == "enemy" and a.type == "fact"
+        ]
+        assert len(facts) == 2, (
+            f"{lvl}: must have 2 enemy facts (objective + sentinel), "
+            f"got {len(facts)} at {facts}"
+        )
+        # One ~mid-map (objective), one far from that one (sentinel).
+        # Use the rough centre of the playable arena.
+        mid = [p for p in facts if 60 <= p[0] <= 100 and 14 <= p[1] <= 26]
+        far = [p for p in facts if not (60 <= p[0] <= 100 and 14 <= p[1] <= 26)]
+        assert len(mid) == 1 and len(far) == 1, (
+            f"{lvl}: expected 1 objective fact mid-map + 1 sentinel far, "
+            f"got mid={mid} far={far}"
+        )
+
+
+def test_guard_count_per_level():
+    """Difficulty axis: easy 3 guards, medium 5, hard 6 — one new
+    controlled variable per tier (cluster density). The loss cap also
+    tightens (3 → 2 → 2 with the hard tier additionally adding spawn
+    variation)."""
+    pack = load_pack(PACK_PATH)
+    expected = {"easy": 3, "medium": 5, "hard": 6}
+    for lvl, want in expected.items():
+        c = compile_level(pack, lvl)
+        n_e3 = sum(
+            1 for a in c.scenario.actors if a.owner == "enemy" and a.type == "e3"
+        )
+        assert n_e3 == want, f"{lvl}: expected {want} guards, got {n_e3}"
+
+
+# ── engine-driven scripted policies ─────────────────────────────────
+
+
+def _own_ids(rs):
+    return [str(u["id"]) for u in (rs.get("units_summary", []) or [])]
+
+
+def _of_type(rs, want_types):
+    out = []
+    for u in rs.get("units_summary", []) or []:
+        if u.get("type") in want_types:
+            out.append(u)
+    return out
+
+
+def _enemies_of_type(rs, want_types):
+    out = []
+    for e in (rs.get("enemy_summary") or []):
+        t = (e.get("type") or e.get("actor_type") or "").lower()
+        if t in want_types:
+            out.append(e)
+    return out
+
+
+def _stall(rs, Command):
+    """Pure observe — fact never takes damage; clock runs out → LOSS."""
+    return [Command.observe()]
+
+
+def _brute(rs, Command):
+    """Attack-move every unit straight east at the fact. The strike
+    column eats anti-tank fire from the whole guard cluster on
+    approach, trades 4 units (1 jeep + 3 tanks) before the fact
+    falls, trips the units_lost_lte cap → LOSS."""
+    cmds = []
+    for u in (rs.get("units_summary", []) or []):
+        cmds.append(Command.attack_move([str(u["id"])], 80, 20))
+    return cmds or [Command.observe()]
+
+
+def _bait_only(rs, Command):
+    """Jeep flanks south (pulls a side of the guards off), strike
+    tanks stand still. The fact survives — clock runs out → LOSS.
+    Tests that the bait without the counter-attack does not score."""
+    cmds = []
+    for u in (rs.get("units_summary", []) or []):
+        if u.get("type") == "jeep":
+            jx, jy = u["cell_x"], u["cell_y"]
+            if jy >= 31:
+                cmds.append(Command.move_units([str(u["id"])], 80, 28))
+            else:
+                cmds.append(Command.move_units([str(u["id"])], 80, 33))
+    return cmds or [Command.observe()]
+
+
+def _intended(rs, Command):
+    """Bait + counter-attack:
+      1. Detect the spawn hemisphere from the agent unit centroid
+         (avg_y < 20 = north spawn).
+      2. Bait the jeep into the MATCHING hemisphere flank, oscillating
+         on the far cell — this stays within GUARD_AGGRO (~16) of the
+         matching half of the guard cluster so they lunge off post,
+         but outside the e3 anti-tank Dragon range (5 cells) so the
+         jeep survives the kite.
+      3. Strike: pick the guard NEAREST the tank centroid (the most
+         immediate threat: typically one of the matching-side guards
+         being pulled OUT of formation toward the bait, so engaging it
+         away from its post is a favourable 3-vs-1 trade per kill).
+         Cycle until the cluster is broken.
+      4. Once no guards are in vision, attack-move onto the fact
+         coordinate. If a near fact is in vision, attack_unit it.
+    """
+    cmds = []
+    tanks = _of_type(rs, {"2tnk"})
+    jeeps = _of_type(rs, {"jeep"})
+    tank_ids = [str(t["id"]) for t in tanks]
+    if not (tanks or jeeps):
+        return [Command.observe()]
+
+    all_units = tanks + jeeps
+    avg_y = sum(u["cell_y"] for u in all_units) / len(all_units)
+    is_north = avg_y < 20
+
+    # Bait: oscillate at the matching-hemisphere flank to keep guards
+    # engaged without dying.
+    for j in jeeps:
+        jy = j["cell_y"]
+        if is_north:
+            target_y = 8 if jy > 9 else 12
+        else:
+            target_y = 33 if jy < 32 else 28
+        cmds.append(Command.move_units([str(j["id"])], 80, target_y))
+
+    if not tanks:
+        return cmds or [Command.observe()]
+
+    tx = sum(t["cell_x"] for t in tanks) / len(tanks)
+    ty = sum(t["cell_y"] for t in tanks) / len(tanks)
+
+    guards = _enemies_of_type(rs, {"e3"})
+    fact_id = None
+    for e in (rs.get("enemy_summary", []) or []):
+        et = (e.get("type") or "").lower()
+        if et == "fact" and e.get("cell_x", 200) < 100:
+            fact_id = str(e.get("id"))
+            break
+
+    if guards:
+        guards.sort(
+            key=lambda g: (g["cell_x"] - tx) ** 2 + (g["cell_y"] - ty) ** 2
+        )
+        cmds.append(Command.attack_unit(tank_ids, str(guards[0]["id"])))
+    elif fact_id is not None:
+        cmds.append(Command.attack_unit(tank_ids, fact_id))
+    else:
+        # Cluster broken but fact not yet in vision — push onto its
+        # known coordinate (it stays put as a building).
+        cmds.append(Command.attack_move(tank_ids, 80, 20))
+    return cmds or [Command.observe()]
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_intended_bait_then_strike_wins(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, _intended, seed=seed)
+    assert r.outcome == "win", (
+        f"{level} seed={seed}: intended bait-then-strike should WIN, "
+        f"got {r.outcome} after {r.turns} turns "
+        f"(lost={r.signals.units_lost}, "
+        f"bldgs_destroyed={r.signals.enemy_buildings_destroyed_types})"
+    )
+
+
+@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"(fact never takes damage), got {r.outcome}"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_brute_frontal_loses(level, seed):
+    """Attack-move all units straight east at the fact must LOSE on
+    every tier — the e3 anti-tank Dragons (range 5, damage 5000 vs
+    Heavy armour) shred the column on approach, trading the whole
+    strike force (4 lost) before the fact can be destroyed; the
+    units_lost_lte cap fails."""
+    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, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: brute frontal must LOSE "
+        f"(strike force traded), got {r.outcome} "
+        f"(lost={r.signals.units_lost}, "
+        f"bldgs={r.signals.enemy_buildings_destroyed_types})"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_bait_only_loses(level, seed):
+    """Bait-only (jeep kites south, strike tanks stand still) must LOSE
+    on every tier — the bait displacement yields ZERO objective
+    progress; the fact survives and the clock runs out. Discriminates
+    "bait without counter-attack" from the intended "bait AND counter-
+    attack" idiom."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _bait_only, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: bait-only must LOSE (fact not destroyed), "
+        f"got {r.outcome} (bldgs={r.signals.enemy_buildings_destroyed_types})"
+    )

tests/test_hard_tier.py

@@ -177,6 +177,14 @@ UPGRADED = [
     # always place and hit whichever latitude the agent occupies, so
     # a memorised pbox-lane placement cannot generalise across seeds.
     "tech-turtle-defensive-tech",
+    # Wave-4 Group D reasoning pack — SC2 bait-micro / military feint-
+    # and-flank doctrine. Hard tier defines two agent spawn_point groups
+    # (NORTH staging y=10 / SOUTH staging y=30) round-robined by seed;
+    # 6 enemy guards are split into NW + SW half-clusters around the
+    # objective `fact` so the working bait-direction + counter-attack-
+    # target pair flips per seed and a single memorised bait line
+    # cannot generalise across seeds.
+    "combat-bait-counter-attack",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation