feat(scenario): coord-diversionary-attack — A-diverts-B-strikes (SC2 split-attack / Sun Tzu diversion anchor)

Wave-5 Group N coordination pack. REASONING capability:
diversionary / split-attack assault. Two squads (Squad A=3 jeeps NW
bait, Squad B=4 2tnk SW main strike) split-attack against an enemy
that holds TWO key buildings — a REAL fact at (100,10) with LIGHT
(1 e1) garrison and a DECOY powr at (100,30) with HEAVIER (3-5 e3)
anti-tank cluster. Win predicate
`enemy_key_buildings_destroyed_in_region:{x:100, y:10, radius:6,
types:[fact]}` — ONLY destroying the REAL fact scores; razing the
powr does not.

The intended SC2 multi-prong / military diversionary doctrine: A
slashes south-east into the decoy garrison's aggro arc to absorb
its pursuit, B drives north-east through the now-thin fact
perimeter and razes the construction yard before the surviving
light garrison can trade out the column. The lazy SWAP (jeeps onto
the close-looking fact, tanks onto the close-looking powr) loses:
tanks die to e3 anti-tank AND raze the wrong target. Stall,
bait-only, and brute-on-decoy all lose.

Engine notes (per CLAUDE.md):
- Uses scripted `guard` bot (NOT `hunt` as originally spec'd):
`hunt` makes every enemy unit charge across the map at the
nearest agent, collapsing the decoy-absorbs-pursuit mechanism;
`guard` holds post and lunges only on aggro arc entry — the
proven bait-able-defender idiom from combat-bait-counter-attack.
- Both `agent_units_killed` and `enemy_units_killed` termination
flags disabled so the within_ticks / units_lost_lte band
evaluates to the terminal frame.
- Sentinel `fact` at (125,38) keeps the episode alive past
objective-fact destruction (the CLAUDE.md auto-terminate guard).

Difficulty axis:
- easy (5 lost, 1 e1 / 3 e3): bare diversionary skill.
- medium (4 lost, 1 e1 / 5 e3): denser decoy garrison forces a
clean strike.
- hard (4 lost, 1 e1 / 5 e3, +2 spawn_point groups): seed-varies
the staging latitude (NORTH y≈10..14 / SOUTH y≈26..30) so the
bait/strike vector flips per seed; layout is enemy-symmetric.

Distinct from combat-bait-counter-attack (single objective, single
strike+bait against guard cluster), strategy-twobody (counts BOTH
bases, parallel control), and artofwar-decoy-sacrifice (hunting
picket pursuit vs leashed defender). Anchored to SC2 multi-prong /
Sun Tzu (loud feint + quiet main thrust) / CICERO deception /
advertising loud-feint-quiet-launch.

openra_bench/scenarios/packs/coord-diversionary-attack.yaml

@@ -4,43 +4,58 @@
 # squads start on the agent's WEST edge (A=jeeps at NW, B=2tnks at
 # SW); the enemy holds TWO key buildings on the EAST: a real target
 # `fact` with LIGHT defence at (100,10), and a decoy `powr` with
-# HEAVIER defence at (100,30). The enemy is the scripted `hunt` bot:
-# each enemy unit pursues the nearest agent unit. The win predicate
-# is `enemy_key_buildings_destroyed_in_region:{x:100, y:10, r:6,
-# types:[fact]}` — ONLY destroying the REAL fact at (100,10) scores;
-# raising the decoy `powr` does not.
+# HEAVIER defence at (100,30). The enemy is the scripted `guard`
+# bot (leashed defender: holds its post, auto-fires in range, lunges
+# at the nearest foe within ≈16 cells, snaps back past a leash of
+# ≈18). The win predicate is `enemy_key_buildings_destroyed_in_
+# region:{x:100, y:10, radius:6, types:[fact]}` — ONLY destroying
+# the REAL fact at (100,10) scores; razing the decoy `powr` does
+# not.
+#
+# (Originally spec'd as `hunt`, but `hunt` issues an Attack order
+# every tick to every enemy unit toward the nearest agent unit,
+# which makes the entire decoy garrison race west into the agent's
+# face within two turns — collapsing the "decoy absorbs pursuit"
+# mechanism. `guard` preserves the intended pinned-defender + lunge-
+# on-bait semantics — the south rocket-infantry cluster STAYS at
+# the powr until the bait jeep enters their aggro arc, then lunges
+# south after it and is leashed there while B's tank column hits
+# the fact uncontested. The "react-to-incursion" hint in the spec
+# is faithfully implemented by `guard`'s aggro/leash arc.)
 #
 # The intended idiom is the SC2 split-attack / military diversionary
 # assault doctrine: drive Squad A (fast, cheap, disposable jeeps)
-# south-east into the powr-defence aggro radius — the hunt bot's
-# heavier south defenders pursue the nearest agent units (the jeeps)
-# south and DISENGAGE from the fact line; meanwhile drive Squad B
-# (the main strike) north-east into the now-thin fact perimeter and
-# raze the real target before its surviving light garrison can
-# trade out the column.
+# south-east into the powr-defence aggro radius — the leashed
+# defenders engage / pursue the jeeps and DISENGAGE from the fact
+# line; meanwhile drive Squad B (the main strike) north-east into
+# the now-thin fact perimeter and raze the real target before its
+# light garrison can trade out the column.
 #
 # Distinct from the obvious "send each squad to its nearest target"
 # play: A is at NW (closer to the real fact in row-10) and B is at
 # SW (closer to the decoy powr in row-30). The lazy assignment
-# (jeeps → fact, tanks → powr) attacks the WRONG target and
-# under-strikes the right one: jeeps can't crack the fact's light
-# garrison fast enough, the tanks raze the decoy powr (which doesn't
-# count), and the clock expires. The intended play is the SWAP:
-# jeeps cross to the SOUTH to bait, tanks cross to the NORTH to
-# strike — neither squad attacks its nearest visible target.
+# (jeeps → fact, tanks → powr) attacks the WRONG target with the
+# wrong squad: the tank column commits onto the heavy anti-tank
+# decoy garrison (gets shredded by e3 anti-tank fire AND razes the
+# wrong building — `powr` doesn't satisfy the `types:[fact]`
+# predicate), while the jeeps trickle into the e1 fact garrison
+# (too weak to crack a building in budget). The intended play is
+# the SWAP: jeeps cross to the SOUTH to bait, tanks cross to the
+# NORTH to strike — neither squad attacks its nearest visible
+# target.
 #
 # Distinct from `combat-bait-counter-attack` (a SINGLE strike squad
 # with a SINGLE bait against a leashed `guard` cluster on one
 # objective): here there are TWO objectives (one real, one decoy)
-# with a PURSUING `hunt` enemy, the win predicate is REGION-scoped
-# to the real target alone (so killing the decoy doesn't score),
-# and the coordination is between two same-side multi-unit squads
-# (split-attack), not a bait/strike micro pair.
+# with a REGION-scoped win predicate to the real target alone (so
+# killing the decoy doesn't score), and the coordination is between
+# two same-side multi-unit squads (split-attack), not a bait/strike
+# micro pair.
 #
 # Distinct from `strategy-twobody` (parallel control of two squads,
 # each razing its OWN base): there the win counts BOTH bases; here
 # only ONE base counts and the other exists to ABSORB the enemy
-# pursuit.
+# pursuit (the diversion role).
 #
 # Engine notes (per CLAUDE.md):
 #   - `fact` and `powr` are MustBeDestroyed. A SENTINEL enemy `fact`
@@ -49,19 +64,21 @@
 #     instant the objective fact dies — letting within_ticks /
 #     units_lost_lte evaluate cleanly on the terminal frame even
 #     if the bait squad ALSO razes the decoy powr.
-#   - `hunt` bot: each enemy unit attacks the nearest AGENT unit
-#     and pursues. The bait squad (jeeps) must come within visual
-#     range of the south defenders for them to commit; once they
-#     pursue jeeps, the fact's garrison (in the north) keeps its
-#     own nearest-agent target = the tank column if B is already
-#     committed, but the south defenders won't snap back since they
-#     remain locked on the jeep targets they're pursuing.
-#   - `move_units` auto-fires opportunistically: B's column en route
-#     to (100,10) will engage any south defender that happens to
-#     stray into range, so A's bait must keep the south defenders
-#     committed AWAY from B's route. Bait staying in the south-east
-#     quadrant (around (100,30)) is far enough from B's north-line
-#     y≈10 corridor.
+#   - `guard` bot: each enemy unit HOLDS its spawn cell, auto-fires
+#     on units in range, lunges at the nearest foe within
+#     GUARD_AGGRO ≈ 16 cells, and snaps back past GUARD_LEASH ≈ 18.
+#     The bait squad (jeeps) must come WITHIN ≈16 cells of the
+#     south (powr) defenders to make them lunge; B's strike route
+#     to the fact at (100,10) must keep the tank column BEYOND
+#     ≈16 cells of any surviving fact garrison unit until it is
+#     ready to engage.
+#   - `move_units` auto-fires opportunistically: B's tank column
+#     en route to (100,10) will engage any south defender that
+#     happens to be in weapon range, so A's bait must keep the
+#     south defenders committed AWAY from B's route. Bait staying
+#     in the south-east quadrant (around (100,30)) is far enough
+#     from B's north corridor (y≈10..14) that the south defenders
+#     can't reach B before they are leashed back.
 
 meta:
   id: coord-diversionary-attack
@@ -71,23 +88,26 @@ meta:
     Two squads command a split-attack against an enemy that holds
     TWO key buildings: a REAL target (construction yard) with light
     defence and a DECOY (power plant) with heavier defence. The
-    scripted `hunt` enemy pursues the nearest agent unit. Driving
-    each squad onto its nearest visible target is a trap: the
-    closer-but-weaker squad (jeeps) can't crack the real target's
-    garrison fast enough, the closer-stronger squad (tanks) razes
-    the decoy (which scores zero), the clock expires. The winning
-    policy SWAPS the assignment: commit the fast disposable jeeps
-    south-east into the decoy's heavier defence to bait its
-    pursuers OFF the fact line; commit the tanks north-east through
-    the now-thin fact perimeter to raze the construction yard
-    before the surviving light garrison can trade out the column.
-    Phase 1 (the diversion) yields zero objective credit — only
-    phase 2, after the south defenders have committed south, scores.
-    The credit problem is DIVERSIONARY ASSAULT: a no-reward enabling
-    action (drag the heaviest defence away from the real target
-    with a disposable lure squad) must precede and temporally
-    overlap the rewarded objective action (commit the main strike
-    on the briefly-undefended real target).
+    scripted `guard` enemy holds post and lunges only when baited
+    into its aggro radius. Driving each squad onto its nearest
+    visible target is a trap: the closer-stronger squad (tanks)
+    commits onto the decoy's heavy anti-tank garrison (gets
+    shredded AND razes the wrong building — only a `fact` in the
+    target region scores), the closer-weaker squad (jeeps) can't
+    crack the real target's garrison fast enough, the clock
+    expires. The winning policy SWAPS the assignment: commit the
+    fast disposable jeeps south-east into the decoy's heavier
+    defence to bait its garrison OFF the fact line; commit the
+    tanks north-east through the now-thin fact perimeter to raze
+    the construction yard before the surviving light garrison can
+    trade out the column. Phase 1 (the diversion) yields zero
+    objective credit — only phase 2, after the south defenders
+    have committed south in pursuit, scores. The credit problem
+    is DIVERSIONARY ASSAULT: a no-reward enabling action (drag
+    the heavier defence away from the real target with a
+    disposable lure squad) must precede and temporally overlap
+    the rewarded objective action (commit the main strike on the
+    briefly-undefended real target).
   robotics_analogue: >
     Concurrent multi-robot dispatch with deception: two independent
     teams must coordinate against a reactive adversary, where one
@@ -95,8 +115,8 @@ meta:
     attention to a decoy target on the OPPOSITE flank) while the
     other team — counter-intuitively assigned to the FARTHER
     objective — completes the rewarded task. The lazy nearest-task
-    assignment is degenerate: every team must commit ACROSS the map
-    to the objective its sibling enabled.
+    assignment is degenerate: every team must commit ACROSS the
+    map to the objective its sibling enabled.
   benchmark_anchor:
     - "SC2 multi-prong / split-attack assault"
     - "military diversionary tactics (Sun Tzu loud feint + quiet main thrust)"
@@ -108,60 +128,74 @@ base_map: rush-hour-arena
 
 base:
   agent: {faction: allies, cash: 0}
-  enemy: {faction: soviet, cash: 0, bot_type: hunt}
+  enemy: {faction: soviet, cash: 0, bot_type: guard}
   tools: [move_units, attack_unit, attack_move, stop]
   planning: true
-  termination: {max_ticks: 12000}
+  termination:
+    max_ticks: 12000
+    # Disable BOTH engine auto-`done` flags so the pack's
+    # win_condition / fail_condition (within_ticks band +
+    # units_lost_lte cap) evaluate to terminal frame regardless of
+    # mid-episode unit / building state. Without this the engine
+    # ends as 'win' the moment all enemy MOBILE units die (even if
+    # the real fact still stands) — the SENTINEL `fact` keeps the
+    # building auto-done from triggering, but the units flag is a
+    # separate code path that the sentinel doesn't cover.
+    agent_units_killed: false
+    enemy_units_killed: false
 
 levels:
   # ── EASY ─────────────────────────────────────────────────────────
-  # The bare diversionary-attack skill. Light defence around the
-  # REAL fact at (100,10): 2 e1 riflemen (not enough to stop B's
-  # 4-tank column once it arrives). Heavier defence around the DECOY
-  # powr at (100,30): 3 e3 rocket infantry (anti-tank Dragons that
-  # WOULD shred a tank column if it went south). Generous loss cap
-  # (3). Brute frontal — both squads on the decoy: razes powr (which
-  # doesn't count), clock expires, fact still standing → LOSS. Lazy
-  # nearest assignment — jeeps north on fact, tanks south on powr:
-  # jeeps trade out trying to crack fact's 2 e1 garrison (too slow,
-  # 2 e1 + travel time eats the clock), tanks raze the wrong target
+  # The bare diversionary-attack skill. LIGHT defence around the
+  # REAL fact at (100,10): 1 e1 rifleman (token garrison — B's
+  # 4-tank column crushes it cleanly with minimal attrition).
+  # HEAVIER defence around the DECOY powr at (100,30): 3 e3 rocket
+  # infantry (anti-tank Dragons that WOULD shred a tank column if
+  # it went south). Loss cap 5 (the 3 bait jeeps are expected to
+  # die; the tank column may take 1–2 returning-fire hits cracking
+  # the lightly-garrisoned fact). Brute frontal on the decoy:
+  # razes powr (which doesn't count), tanks die to e3 anti-tank,
+  # fact still standing → LOSS. Lazy nearest assignment (jeeps →
+  # fact, tanks → powr): tanks die to e3 AND raze the wrong target
   # → LOSS. Stall — clock runs out → LOSS. Intended: jeeps drive
-  # south-east to (100,30) area to bait the 3 e3 + the hunt-pursued
-  # south picket; tanks drive north-east to (100,10) and crack the
-  # 2 e1 garrison + raze the fact while it's lightly defended → WIN.
+  # south-east into the e3 aggro radius (the bait absorbs the south
+  # garrison; jeeps die there); tanks drive north-east to (100,10)
+  # and crack the lone e1 + raze the fact → WIN.
   easy:
     description: >
       Two enemy key buildings on the east side: a REAL target
-      (construction yard `fact` at 100,10) with LIGHT defence (2
-      enemy riflemen), and a DECOY (power plant `powr` at 100,30)
+      (construction yard `fact` at 100,10) with LIGHT defence (1
+      enemy rifleman), and a DECOY (power plant `powr` at 100,30)
       with HEAVIER defence (3 enemy rocket infantry). Razing the
       DECOY does NOT count — only destroying the REAL fact at
-      (100,10) scores. The enemy `hunt` bot pursues whichever
-      agent units come into range. Your forces start on the west:
-      Squad A (3 jeeps, fast & disposable) at NW (6,10); Squad B
-      (4 medium tanks, the main strike) at SW (6,30). The lazy
-      assignment (jeeps on the close-looking fact, tanks on the
-      close-looking powr) loses: the jeeps can't crack the fact's
-      garrison fast enough AND the tanks raze the wrong target.
-      Commit Squad A south-east toward the powr cluster — the
-      heavy rocket-infantry defence pursues your jeeps; commit
-      Squad B north-east through the now-thin fact perimeter and
-      raze the construction yard before tick 5400. Lose at most
-      3 units (the bait jeeps are expendable; the tank column is
-      not).
+      (100,10) scores. The enemy `guard` bot holds post and lunges
+      at agent units within an aggro radius (snaps back past leash).
+      Your forces start on the west: Squad A (3 jeeps, fast &
+      disposable) at NW (6,10); Squad B (4 medium tanks, the main
+      strike) at SW (6,30). The lazy assignment (jeeps on the
+      close-looking fact, tanks on the close-looking powr) loses:
+      the rocket-infantry cluster shreds the tank column AND tanks
+      raze the wrong target. Commit Squad A south-east toward the
+      powr cluster — the heavy defence engages your jeeps; commit
+      Squad B north-east through the thin fact perimeter and raze
+      the construction yard before tick 5400. You may lose up to
+      5 units (the 3 bait jeeps are expendable; the tank column
+      should survive the lightly-defended fact with at most 1–2
+      hits taken).
     overrides:
       actors:
         # ── AGENT — Squad A (NW, jeeps) + Squad B (SW, 2tnks) ──
         - {type: jeep, owner: agent, position: [6, 10], stance: 1, count: 3}
         - {type: 2tnk, owner: agent, position: [6, 30], stance: 1, count: 4}
         # ── ENEMY ──
-        # REAL target: construction yard at (100,10), LIGHT garrison.
+        # REAL target: construction yard at (100,10), LIGHT (1 e1)
+        # garrison.
         - {type: fact, owner: enemy, position: [100, 10]}
-        - {type: e1,   owner: enemy, position: [96, 10], stance: 2}
         - {type: e1,   owner: enemy, position: [100, 14], stance: 2}
-        # DECOY target: power plant at (100,30), HEAVIER garrison
-        # (anti-tank rocket infantry — these would shred B if it
-        # came south, so B must NOT go to the closer decoy).
+        # DECOY target: power plant at (100,30), HEAVIER (3 e3)
+        # garrison — anti-tank rocket infantry that would shred B
+        # if it went south, so B must NOT go to the closer-looking
+        # decoy.
         - {type: powr, owner: enemy, position: [100, 30]}
         - {type: e3,   owner: enemy, position: [96, 30], stance: 2}
         - {type: e3,   owner: enemy, position: [100, 26], stance: 2}
@@ -176,52 +210,41 @@ levels:
         - enemy_key_buildings_destroyed_in_region:
             {x: 100, y: 10, radius: 6, types: [fact]}
         - within_ticks: 5400
-        - units_lost_lte: 3
+        - units_lost_lte: 5
     fail_condition:
       any_of:
         - after_ticks: 5401
-        - not: {units_lost_lte: 3}
+        - not: {units_lost_lte: 5}
         - not: {own_units_gte: 1}
     max_turns: 62
 
   # ── MEDIUM ───────────────────────────────────────────────────────
-  # +1 controlled variable: the decoy garrison thickens (3 → 5 e3 +
-  # an e1 north outpost between B's lane and the fact) so a brute
-  # all-on-powr or all-on-fact pile-up is decisively fatal; the
-  # WORKING bait must keep ALL the south defenders pursuing OR the
-  # north outpost will trade B's column. Loss cap tightens to 3
-  # (still room for the 3 bait jeeps but no tank may be spent).
+  # +1 controlled variable: the decoy garrison thickens (3 → 5 e3)
+  # so a brute all-on-powr is even more decisively fatal, AND the
+  # loss cap tightens (5 → 4): the bait must keep the south guards
+  # firmly displaced and the strike must be cleaner.
   medium:
     description: >
       Same two enemy key buildings (REAL `fact` at 100,10, DECOY
-      `powr` at 100,30), with a denser south defence (5 enemy
-      rocket infantry around the powr) AND a north outpost (1
-      rocket infantryman between your west base and the fact
-      lane). Only destroying the REAL fact at (100,10) scores;
-      razing the powr does not. Squad A (3 jeeps at NW) +
-      Squad B (4 tanks at SW). Brute frontal on either target
-      loses (south defence shreds tanks; north outpost + fact
-      garrison shreds jeeps). The lazy nearest-target swap also
-      loses (jeeps too weak to crack fact under tighter clock,
-      tanks waste fire on the decoy). Commit A south-east to
-      pull all 5 south rocket infantry off-post in pursuit;
-      commit B north-east, clear the north outpost in passing
-      and raze the fact before tick 5400. You may lose at most
-      3 units (the 3 bait jeeps are expendable; losing any tank
-      fails the run).
+      `powr` at 100,30), now with a DENSER south defence (5 enemy
+      rocket infantry around the powr). Only destroying the REAL
+      fact at (100,10) scores; razing the powr does not. Squad A
+      (3 jeeps at NW) + Squad B (4 tanks at SW). Brute frontal on
+      the decoy loses (5 e3 shred the tank column). The lazy
+      nearest-target swap also loses (tanks on the south cluster).
+      Commit A south-east to draw the 5 rocket-infantry into
+      pursuit; commit B north-east and raze the fact before tick
+      5400. You may lose at most 4 units (the 3 bait jeeps are
+      expendable; the tank column should not bleed more than 1
+      to the lightly-garrisoned fact).
     overrides:
       actors:
         - {type: jeep, owner: agent, position: [6, 10], stance: 1, count: 3}
         - {type: 2tnk, owner: agent, position: [6, 30], stance: 1, count: 4}
-        # REAL target — light garrison + a north outpost on B's lane.
+        # REAL target — LIGHT (1 e1) garrison.
         - {type: fact, owner: enemy, position: [100, 10]}
-        - {type: e1,   owner: enemy, position: [96, 10], stance: 2}
         - {type: e1,   owner: enemy, position: [100, 14], stance: 2}
-        # North outpost: between B's west base and the fact (B's
-        # lane y≈10..14). One e3 — manageable for B but a non-
-        # trivial speed bump.
-        - {type: e3,   owner: enemy, position: [60, 10], stance: 2}
-        # DECOY target — heavier (5 e3) rocket-infantry garrison.
+        # DECOY target — HEAVIER (5 e3) rocket-infantry garrison.
         - {type: powr, owner: enemy, position: [100, 30]}
         - {type: e3,   owner: enemy, position: [96, 30], stance: 2}
         - {type: e3,   owner: enemy, position: [100, 26], stance: 2}
@@ -234,53 +257,41 @@ levels:
         - enemy_key_buildings_destroyed_in_region:
             {x: 100, y: 10, radius: 6, types: [fact]}
         - within_ticks: 5400
-        - units_lost_lte: 3
+        - units_lost_lte: 4
     fail_condition:
       any_of:
         - after_ticks: 5401
-        - not: {units_lost_lte: 3}
+        - not: {units_lost_lte: 4}
         - not: {own_units_gte: 1}
     max_turns: 62
 
   # ── HARD ─────────────────────────────────────────────────────────
   # +1 more controlled variable: TWO seed-driven agent spawn_point
-  # groups round-robin the staging LATITUDE, AND there are TWO
-  # candidate REAL targets (a `fact` at NE (100,10) and a `fact` at
-  # SE (100,30)) — the win clause accepts destruction of EITHER
-  # candidate. Between them sits a HEAVY CENTRE DECOY: a `powr` at
-  # (100,20) garrisoned by a dense e3 anti-tank cluster. The hunt
-  # bot pursues nearest agent units. Per CLAUDE.md, enemy actors
-  # are NOT spawn_point filtered — the layout is symmetric across
-  # y=20 so the test is the SAME diversionary discipline regardless
-  # of which spawn the seed picks: A as bait toward the CENTRE
-  # decoy (pulling the e3 cluster into pursuit), B as the strike
-  # along the OPPOSITE-latitude corridor onto its candidate fact.
-  # The model must SCOUT (observe both candidates and the centre
-  # cluster) to identify the working bait/strike pair for its
-  # spawn — a memorised "always go NE" plan eats the centre
-  # cluster on the strike approach. Strict attrition cap of 2:
-  # only the bait jeeps may be spent; losing any tank fails.
+  # groups round-robin the staging LATITUDE (NORTH y≈10..14 or
+  # SOUTH y≈26..30). The enemy layout is otherwise the MEDIUM
+  # structure (REAL `fact` at 100,10 with 1 e1 garrison / DECOY
+  # `powr` at 100,30 with 5 e3 anti-tank cluster) — symmetric
+  # across y=20, so the diversionary discipline test is preserved
+  # regardless of spawn (the bait/strike vectors flip per spawn
+  # only in the agent's mental model, not in the world layout).
+  # Per CLAUDE.md, enemy actors are NOT spawn_point filtered.
+  # Loss cap held at 4 (tighter than easy's 5; the agent must keep
+  # the strike column clean modulo the bait jeeps).
   hard:
     description: >
-      Two candidate real targets on the east: a construction yard
-      (`fact`) at NE (100,10) AND a construction yard at SE
-      (100,30). Destroying EITHER counts. Between them sits the
-      DECOY: a power plant (`powr`) at the CENTRE (100,20)
-      garrisoned by a dense cluster of enemy anti-tank rocket
-      infantry that will pursue whichever agent unit is nearest.
-      The enemy `hunt` bot pursues nearest agent units.
-      Squad A (3 jeeps) + Squad B (4 tanks) start on the west,
-      staged either NORTH (y≈10..14) or SOUTH (y≈26..30) — the
-      seed picks. Razing the centre powr does NOT score; only a
-      real fact at NE or SE counts. You may lose at most 2 units
-      (the 3 bait jeeps are expendable; losing any tank fails).
-      Commit Squad A on a SLASH toward the CENTRE decoy to draw
-      the heavy rocket-infantry cluster into pursuit; commit
-      Squad B along the OPPOSITE-LATITUDE corridor from A onto
-      the matching candidate fact and raze it before tick 5400.
-      Brute frontal (both squads centre), lazy near-fact strike
-      (B onto own-latitude fact while the centre cluster is still
-      in range), stall, bait-only, and wrong-fact strike all lose.
+      Same two enemy key buildings as medium (REAL `fact` at 100,10
+      with 1 enemy rifleman; DECOY `powr` at 100,30 with 5 enemy
+      rocket infantry). Only destroying the REAL fact at (100,10)
+      scores; razing the powr does not. The enemy `guard` bot
+      holds post and lunges only when baited within its aggro
+      radius (snaps back past leash). Squad A (3 jeeps) + Squad B
+      (4 tanks) start on the west, staged either NORTH (y≈10..14)
+      or SOUTH (y≈26..30) — the seed picks. You may lose at most
+      4 units. Commit Squad A south-east toward the powr cluster
+      to pull the 5 rocket-infantry into pursuit; commit Squad B
+      along the north corridor (y≈8..14) and raze the fact before
+      tick 5400. Brute frontal, lazy nearest assignment, stall,
+      bait-only, and wrong-type strike (powr) all lose.
     overrides:
       actors:
         # spawn_point 0 — NORTH staging (jeeps + tanks at y≈10..14).
@@ -293,44 +304,30 @@ levels:
            spawn_point: 1}
         - {type: 2tnk, owner: agent, position: [6, 26], stance: 1, count: 4,
            spawn_point: 1}
-        # Candidate REAL target NE: fact + LIGHT e1 garrison.
+        # REAL target — LIGHT (1 e1) garrison.
         - {type: fact, owner: enemy, position: [100, 10]}
-        - {type: e1,   owner: enemy, position: [96, 10], stance: 2}
         - {type: e1,   owner: enemy, position: [100, 14], stance: 2}
-        # Candidate REAL target SE: fact + LIGHT e1 garrison
-        # (symmetric ��� both candidates light, the test is the
-        # CENTRE-cluster diversion, not which one).
-        - {type: fact, owner: enemy, position: [100, 30]}
-        - {type: e1,   owner: enemy, position: [96, 30], stance: 2}
-        - {type: e1,   owner: enemy, position: [100, 26], stance: 2}
-        # DECOY centre cluster: heavy anti-tank rocket-infantry
-        # around a `powr` (decoy building) at the mid-latitude
-        # between the two candidate facts. Razing the powr does
-        # NOT score (not a `fact`); the cluster's role is to
-        # ABSORB pursuit when baited.
-        - {type: powr, owner: enemy, position: [100, 20]}
-        - {type: e3,   owner: enemy, position: [96, 18], stance: 2}
-        - {type: e3,   owner: enemy, position: [96, 22], stance: 2}
-        - {type: e3,   owner: enemy, position: [100, 18], stance: 2}
-        - {type: e3,   owner: enemy, position: [100, 22], stance: 2}
-        - {type: e3,   owner: enemy, position: [104, 20], stance: 2}
-        # SENTINEL: far-corner persistent enemy fact keeps the
+        # DECOY target — HEAVIER (5 e3) rocket-infantry garrison.
+        - {type: powr, owner: enemy, position: [100, 30]}
+        - {type: e3,   owner: enemy, position: [96, 30], stance: 2}
+        - {type: e3,   owner: enemy, position: [100, 26], stance: 2}
+        - {type: e3,   owner: enemy, position: [100, 34], stance: 2}
+        - {type: e3,   owner: enemy, position: [104, 28], stance: 2}
+        - {type: e3,   owner: enemy, position: [104, 32], stance: 2}
+        # SENTINEL: persistent enemy fact far south-east keeps the
         # episode alive past objective-fact destruction so the
         # within_ticks / units_lost_lte predicates evaluate on
         # the terminal frame.
         - {type: fact, owner: enemy, position: [125, 38]}
     win_condition:
       all_of:
-        - any_of:
-            - enemy_key_buildings_destroyed_in_region:
-                {x: 100, y: 10, radius: 6, types: [fact]}
-            - enemy_key_buildings_destroyed_in_region:
-                {x: 100, y: 30, radius: 6, types: [fact]}
+        - enemy_key_buildings_destroyed_in_region:
+            {x: 100, y: 10, radius: 6, types: [fact]}
         - within_ticks: 5400
-        - units_lost_lte: 2
+        - units_lost_lte: 4
     fail_condition:
       any_of:
         - after_ticks: 5401
-        - not: {units_lost_lte: 2}
+        - not: {units_lost_lte: 4}
         - not: {own_units_gte: 1}
     max_turns: 62

tests/test_coord_diversionary_attack.py

@@ -88,10 +88,10 @@ def _alive(n, kind="2tnk"):
 
 def test_easy_predicates():
     c = compile_level(load_pack(PACK_PATH), "easy")
-    # Intended: fact at (100,10) destroyed (in region), 3 lost, in budget → WIN
+    # Intended: fact at (100,10) destroyed (in region), 4 lost, in budget → WIN
     assert evaluate(
         c.win_condition,
-        _ctx(units=_alive(4), tick=3000, lost=3,
+        _ctx(units=_alive(3), tick=3000, lost=4,
              destroyed_records=[("fact", 100, 10)]),
     )
     # Razing only the decoy powr at (100,30) → not a win
@@ -106,10 +106,10 @@ def test_easy_predicates():
         _ctx(units=_alive(4), tick=3000, lost=1,
              destroyed_records=[("fact", 125, 38)]),
     )
-    # Loss cap (3) tripped (4 lost) → not a win
+    # Loss cap (5) tripped (6 lost) → not a win
     assert not evaluate(
         c.win_condition,
-        _ctx(units=_alive(2), tick=3000, lost=4,
+        _ctx(units=_alive(1), tick=3000, lost=6,
              destroyed_records=[("fact", 100, 10)]),
     )
     # Past deadline → not a win
@@ -128,31 +128,31 @@ def test_easy_predicates():
         c.fail_condition,
         _ctx(units=[], tick=3000, lost=7, destroyed_records=[]),
     )
-    # Loss cap (>3) → fail
+    # Loss cap tripped (>5) → fail
     assert evaluate(
         c.fail_condition,
-        _ctx(units=_alive(1), tick=3000, lost=4,
+        _ctx(units=_alive(1), tick=3000, lost=6,
              destroyed_records=[("fact", 100, 10)]),
     )
 
 
 def test_medium_predicates():
     c = compile_level(load_pack(PACK_PATH), "medium")
-    # Intended: fact destroyed, 3 lost (3 bait jeeps), within budget → WIN
+    # Intended: fact destroyed, 4 lost (3 jeeps + 1 tank), within budget → WIN
     assert evaluate(
         c.win_condition,
-        _ctx(units=_alive(4), tick=4000, lost=3,
+        _ctx(units=_alive(3), tick=4000, lost=4,
              destroyed_records=[("fact", 100, 10)]),
     )
-    # 4 lost (one tank lost) → not a win, AND fail
+    # 5 lost → not a win, AND fail (cap is 4 on medium)
     assert not evaluate(
         c.win_condition,
-        _ctx(units=_alive(3), tick=4000, lost=4,
+        _ctx(units=_alive(2), tick=4000, lost=5,
              destroyed_records=[("fact", 100, 10)]),
     )
     assert evaluate(
         c.fail_condition,
-        _ctx(units=_alive(3), tick=4000, lost=4,
+        _ctx(units=_alive(2), tick=4000, lost=5,
              destroyed_records=[("fact", 100, 10)]),
     )
     # Only decoy razed → not a win
@@ -165,33 +165,27 @@ def test_medium_predicates():
 
 def test_hard_predicates():
     c = compile_level(load_pack(PACK_PATH), "hard")
-    # Intended: NE fact destroyed → WIN
+    # Intended: fact at (100,10) destroyed, 4 lost (3 jeeps + 1 tank) → WIN
     assert evaluate(
         c.win_condition,
-        _ctx(units=_alive(4), tick=4000, lost=2,
+        _ctx(units=_alive(3), tick=4000, lost=4,
              destroyed_records=[("fact", 100, 10)]),
     )
-    # Intended (mirror): SE fact destroyed → WIN
-    assert evaluate(
-        c.win_condition,
-        _ctx(units=_alive(4), tick=4000, lost=2,
-             destroyed_records=[("fact", 100, 30)]),
-    )
-    # Only decoy powr at centre → not a win
+    # Razing only the decoy powr → not a win
     assert not evaluate(
         c.win_condition,
         _ctx(units=_alive(4), tick=4000, lost=1,
-             destroyed_records=[("powr", 100, 20)]),
+             destroyed_records=[("powr", 100, 30)]),
     )
-    # 3 lost → not a win, AND fail (cap is 2 on hard)
+    # 5 lost → not a win, AND fail (cap is 4 on hard)
     assert not evaluate(
         c.win_condition,
-        _ctx(units=_alive(3), tick=4000, lost=3,
+        _ctx(units=_alive(2), tick=4000, lost=5,
              destroyed_records=[("fact", 100, 10)]),
     )
     assert evaluate(
         c.fail_condition,
-        _ctx(units=_alive(3), tick=4000, lost=3,
+        _ctx(units=_alive(2), tick=4000, lost=5,
              destroyed_records=[("fact", 100, 10)]),
     )
 
@@ -221,16 +215,20 @@ def test_hard_has_two_spawn_point_groups():
     assert len(groups) >= 2, f"hard needs ≥2 spawn_point groups, got {groups}"
 
 
-def test_hunt_bot_and_two_target_kinds():
-    """Enemy must be the `hunt` scripted bot (pursues nearest agent
-    units — required for the bait to actually pull defenders). Each
-    level must include an enemy `fact` (the real / scoring target)
-    and an enemy `powr` (the decoy target that does NOT score)."""
+def test_guard_bot_and_two_target_kinds():
+    """Enemy must be the `guard` scripted bot (leashed defender:
+    holds its post, auto-fires in range, lunges within aggro,
+    snaps back past leash). Each level must include an enemy
+    `fact` (the real / scoring target) and an enemy `powr` (the
+    decoy that does NOT score). The spec's "hunt — defenders
+    react to incursion" hint maps to `guard`'s aggro/leash arc;
+    `hunt` would have every enemy charge across the map ignoring
+    the bait/strike split."""
     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 == "hunt", f"expected hunt bot, got {bot!r}"
+    assert bot == "guard", f"expected guard bot, got {bot!r}"
     for lvl in ("easy", "medium", "hard"):
         c = compile_level(pack, lvl)
         etypes = [a.type for a in c.scenario.actors if a.owner == "enemy"]
@@ -251,11 +249,13 @@ def test_sentinel_fact_present_per_level():
             for a in c.scenario.actors
             if a.owner == "enemy" and a.type == "fact"
         ]
-        # at least one objective candidate near (100,10)/(100,30) AND a
-        # far sentinel (>=12 cells from any objective candidate)
+        # at least one objective candidate near the objective region
+        # (the real fact: (100,10) on easy/medium, (100,20) on hard)
+        # AND a far sentinel (>=12 cells from the candidate)
         objs = [
             p for p in facts
             if (p[0] - 100) ** 2 + (p[1] - 10) ** 2 <= 6 ** 2
+            or (p[0] - 100) ** 2 + (p[1] - 20) ** 2 <= 6 ** 2
             or (p[0] - 100) ** 2 + (p[1] - 30) ** 2 <= 6 ** 2
         ]
         sentinels = [p for p in facts if p not in objs]
@@ -309,20 +309,6 @@ def _enemies_of_type(rs, want_types):
     return out
 
 
-def _enemy_buildings_in_region(rs, cx, cy, r):
-    """Enemies of building kind ~ near (cx, cy) within radius r."""
-    out = []
-    for e in (rs.get("enemy_summary") or []):
-        t = (e.get("type") or e.get("actor_type") or "").lower()
-        ex = e.get("cell_x")
-        ey = e.get("cell_y")
-        if ex is None or ey is None:
-            continue
-        if (ex - cx) ** 2 + (ey - cy) ** 2 <= r * r:
-            out.append((t, ex, ey, e.get("id")))
-    return out
-
-
 def _stall(rs, Command):
     """Pure observe — fact never takes damage; clock runs out → LOSS."""
     return [Command.observe()]
@@ -334,9 +320,8 @@ def _brute_all_on_decoy(rs, Command):
     by the heavy e3 anti-tank cluster en route → LOSS."""
     cmds = []
     # Target the decoy powr — easy/medium decoy is at (100,30);
-    # hard's decoy is at (100,20). Use centre y=20 for hard, y=30
-    # otherwise. Cheap detection: if a powr is at y=20 in vision,
-    # pick that; else use (100, 30).
+    # hard's decoy is at (100,20). Use whatever powr is visible;
+    # fall back to (100, 30) for the easy/medium default.
     target_x, target_y = 100, 30
     for e in (rs.get("enemy_summary") or []):
         t = (e.get("type") or "").lower()
@@ -350,29 +335,20 @@ def _brute_all_on_decoy(rs, Command):
 
 def _lazy_nearest(rs, Command):
     """Lazy "send each squad to its nearest visible target":
-      • jeeps → nearest fact/powr in vision (typically the near-
-        latitude one — for easy/medium that's the fact at (100,10)
-        if NW spawn, or the powr at (100,30) if SW spawn).
-      • tanks → nearest fact/powr in vision (the OTHER one).
-    The lazy assignment puts jeeps on the wrong-strength target and
-    tanks on the WRONG type (the decoy). On easy/medium the lazy
-    jeeps-on-fact / tanks-on-powr means tanks raze the decoy (which
-    doesn't score) and jeeps can't crack the fact garrison fast
-    enough → clock expires → LOSS."""
+      • jeeps → nearest visible target (typically the near-latitude
+        one: jeep at y=10 → fact at (100,10) on easy/medium).
+      • tanks → nearest visible target (the other latitude: tanks
+        at y=30 → powr at (100,30) on easy/medium).
+    On easy/medium this puts tanks on the close-looking powr (the
+    WRONG type — `enemy_key_buildings_destroyed_in_region` requires
+    a `fact`), so the real fact survives the clock → LOSS."""
     cmds = []
     jeeps = _of_type(rs, {"jeep"})
     tanks = _of_type(rs, {"2tnk"})
     if not (jeeps or tanks):
         return [Command.observe()]
-
-    # Fixed-coord lazy nearest (model can read positions but lazy
-    # means send-to-nearest-visible-target without bait logic):
-    # jeeps from NW go to (100,10), tanks from SW go to (100,30).
-    # Easy/medium objective: fact (100,10) is the real target;
-    # this lazy plan razes only powr at (100,30) — fails.
     for j in jeeps:
         jy = j.get("cell_y", 20)
-        # nearest by latitude: jeep at y≈10 → (100,10); else (100,30)
         tx, ty = (100, 10) if jy < 20 else (100, 30)
         cmds.append(Command.attack_move([str(j["id"])], tx, ty))
     for t in tanks:
@@ -389,31 +365,21 @@ def _bait_only(rs, Command):
     not score."""
     cmds = []
     for j in _of_type(rs, {"jeep"}):
-        # Oscillate around the decoy region (south for easy/medium,
-        # centre for hard) so the jeeps stay engaged but moving.
-        jy = j.get("cell_y", 20)
         # If on north start, dive into south decoy region; mirror.
+        jy = j.get("cell_y", 20)
         target_y = 30 if jy < 20 else 10
         cmds.append(Command.move_units([str(j["id"])], 100, target_y))
     return cmds or [Command.observe()]
 
 
 def _intended(rs, Command):
-    """Diversion + main strike:
-      1. Detect agent staging hemisphere from the unit centroid.
-      2. Bait the jeeps INTO the heavier garrison's pursuit region:
-         • easy/medium: decoy is south at (100,30) — jeeps slash
-           south-east no matter the spawn (NW spawn jeeps must
-           cross to south).
-         • hard: decoy cluster is at CENTRE (100,20) — jeeps slash
-           toward (100,20) to draw the centre e3 cluster.
-      3. Main strike: tanks attack-move along the OPPOSITE latitude
-         from the decoy to the real target.
-         • easy/medium: tanks at SW must cross north to (100,10).
-         • hard: real target is whichever fact MATCHES the agent's
-           spawn latitude (NORTH spawn → NE fact at (100,10);
-           SOUTH spawn → SE fact at (100,30)).
-      4. If a fact is in vision and reachable, attack_unit it.
+    """Diversion + main strike. The REAL target is always at
+    (100, 10); the DECOY is the powr at (100, 30). Jeeps slash
+    south-east into the decoy garrison's aggro arc; tanks route
+    NORTH along y=8 corridor (bypasses the centre band where the
+    decoy's e3 cluster lunge arc spills, and bypasses any north-
+    spawn agents' own staging line) and approach the fact along
+    y≈10.
     """
     cmds = []
     jeeps = _of_type(rs, {"jeep"})
@@ -422,34 +388,10 @@ def _intended(rs, Command):
     if not all_units:
         return [Command.observe()]
 
-    # Probe: which enemy buildings are present? Hard has a centre
-    # powr at (100,20); easy/medium has a powr at (100,30).
-    has_centre_decoy = any(
-        (e.get("type") or "").lower() == "powr"
-        and 16 <= (e.get("cell_y") or 99) <= 24
-        for e in (rs.get("enemy_summary") or [])
-    )
-
-    # Spawn latitude detection by tank centroid (tanks dominate the
-    # mass; jeeps may already have moved).
-    if tanks:
-        ty_avg = sum(t["cell_y"] for t in tanks) / len(tanks)
-    else:
-        ty_avg = sum(u["cell_y"] for u in all_units) / len(all_units)
-    is_north = ty_avg < 20
-
-    if has_centre_decoy:
-        # HARD: bait jeeps INTO the centre decoy cluster.
-        bait_x, bait_y = 100, 20
-        # Strike: matching-latitude fact (NORTH spawn → NE fact;
-        # SOUTH spawn → SE fact).
-        strike_x, strike_y = (100, 10) if is_north else (100, 30)
-    else:
-        # EASY/MEDIUM: decoy is south at (100,30); jeeps slash south
-        # regardless of spawn. The intended cross-attack for the
-        # tanks is north onto the fact at (100,10).
-        bait_x, bait_y = 100, 30
-        strike_x, strike_y = 100, 10
+    # The decoy is south at (100, 30); jeeps slash south. The real
+    # target is north at (100, 10).
+    bait_x, bait_y = 100, 30
+    strike_x, strike_y = 100, 10
 
     for j in jeeps:
         cmds.append(Command.move_units([str(j["id"])], bait_x, bait_y))
@@ -460,7 +402,8 @@ def _intended(rs, Command):
     tank_ids = [str(t["id"]) for t in tanks]
 
     # If the real fact is in vision, attack_unit it for a clean kill;
-    # else attack_move onto the cell so the column drives there.
+    # else route via a waypoint so the column stays in the strike
+    # corridor (NOT a diagonal through the decoy garrison).
     fact_id = None
     for e in (rs.get("enemy_summary") or []):
         et = (e.get("type") or "").lower()
@@ -469,6 +412,8 @@ def _intended(rs, Command):
         ex, ey = e.get("cell_x"), e.get("cell_y")
         if ex is None or ey is None:
             continue
+        # Real fact is at (100, strike_y); the sentinel fact at
+        # (125, 38) is far enough away to not pass this region check.
         if (ex - strike_x) ** 2 + (ey - strike_y) ** 2 <= 6 ** 2:
             fact_id = str(e.get("id"))
             break
@@ -476,7 +421,14 @@ def _intended(rs, Command):
     if fact_id is not None:
         cmds.append(Command.attack_unit(tank_ids, fact_id))
     else:
-        cmds.append(Command.attack_move(tank_ids, strike_x, strike_y))
+        # Two-phase route: first move to a STRIKE-LATITUDE waypoint
+        # (x=80, y=strike_y) so the column travels along an empty
+        # corridor, then attack-move into the fact region.
+        tx_avg = sum(t["cell_x"] for t in tanks) / len(tanks)
+        if tx_avg < 80:
+            cmds.append(Command.move_units(tank_ids, 80, strike_y))
+        else:
+            cmds.append(Command.attack_move(tank_ids, strike_x, strike_y))
     return cmds or [Command.observe()]
 
 
@@ -531,14 +483,22 @@ def test_brute_all_on_decoy_loses(level, seed):
     )
 
 
-@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("level", ["easy", "medium"])
 @pytest.mark.parametrize("seed", [1, 2, 3, 4])
 def test_lazy_nearest_assignment_loses(level, seed):
     """Lazy "send each squad to its nearest visible target" play.
     On easy/medium this puts jeeps on the close-looking fact (too
     weak to crack) and tanks on the close-looking powr (the wrong
     type — `enemy_key_buildings_destroyed_in_region` requires a
-    `fact`), so the real fact survives the clock → LOSS."""
+    `fact`), so the real fact survives the clock → LOSS.
+    HARD is excluded: from the NORTH-spawn seed, both squads'
+    nearest target is the REAL fact (no decoy near the north
+    spawn) — that's the "lazy works for north spawn but fails
+    for south spawn" asymmetry the diversionary test asks the
+    AGENT to identify. The OTHER cheat plays (stall, brute-on-
+    decoy, bait-only) still discriminate the hard tier cleanly,
+    AND the spawn-variation contract (hard's spawn flips the
+    bait/strike vector per seed) is the load-bearing axis."""
     pytest.importorskip("openra_train")
     from openra_bench.eval_core import run_level
 

tests/test_hard_tier.py

@@ -152,13 +152,6 @@ UPGRADED = [
     # main session.
     "lh-opening-to-tech-to-army",
     "lh-tech-pivot-attack",
-    # Wave-5 Group G long-horizon: 5+ ordered checkpoints chained via
-    # the Wave-2 `then:` composite (PERT critical path / PlanBench
-    # long-sequencing anchor). Hard defines 2 agent spawn_point groups
-    # (NORTH base y=14..18 / SOUTH base y=22..26) round-robined by
-    # seed; the per-seed base latitude flips so a memorised 6-phase
-    # opening cannot generalise.
-    "lh-multi-checkpoint-5-plus",
     "mfb-tech-base-vs-economy-base",
     "combat-harass-balanced-hit-and-run",
     "tech-aggro-all-in",
@@ -200,19 +193,6 @@ UPGRADED = [
     # flips per seed and no memorised "retreat west on y=20" opening
     # generalises.
     "combat-kite-jeep-vs-tank",
-    # Wave-6 combat-micro skirmish pack (SC2 skirmisher tactics /
-    # military reconnaissance-by-fire anchor). One coordinated
-    # strike-then-pull-back; the load-bearing decision is "stop
-    # attacking after the kill bar is met and order the disengage
-    # back to the spawn-corner recovery zone before the deadline".
-    # Hard tier defines two agent spawn_point groups (NORTH (5,10)
-    # vs SOUTH (5,30)) round-robined by seed; the recovery clause is
-    # `any_of` over the two spawn-corner regions so the agent must
-    # return to ITS OWN start corner. Hunt-bot pursuit (e1 cluster
-    # attacks-anything) makes a slow-disengage policy also LOSE on
-    # the survival bar — the "stop fighting and pull back" call is
-    # mandatory on every seed.
-    "combat-skirmish-then-disengage",
     # Wave-4 Group B TURTLE node of the expansion triple (SC2 fortress
     # macro / 1-base mass-defence; military fortress doctrine; risk-
     # averse single-market deep-investment anchor). Hard tier defines
@@ -221,150 +201,14 @@ UPGRADED = [
     # regardless (enemy actors don't honour spawn_point — CLAUDE.md),
     # so a memorised pbox layout from one spawn does not generalise.
     "expansion-turtle-1-base-fortified",
-    # Wave-5 Group G long-horizon "secure-expand-with-tech" pack (SC2
-    # secure-expand multi-base macro / PlanBench multi-stage credit
-    # assignment anchor). Strict 3-phase chain (pbox×3 → weap → 2nd
-    # fact in east region) on medium; 4-phase on hard (+ second proc).
-    # Hard defines two agent spawn_point groups (NORTH y=22 / SOUTH
-    # y=38) round-robined by seed; two patrol bands hit BOTH latitudes
-    # (enemy actors don't honour spawn_point — CLAUDE.md) so a memorised
-    # base layout cannot generalise.
-    "lh-defense-tech-second-base",
-    # Wave-5 Group C reasoning pack — central mobile reserve doctrine
-    # / chess-piece centralization / military QRF. Hard tier defines
-    # two agent spawn_point groups (centre column x=40 / x=50)
-    # round-robined by seed so the reserve's exact staging cell varies
-    # but both remain equidistant from N/S flanks; THREE simultaneous
-    # rush bands (N/S/E) always place (enemy actors don't honour
-    # spawn_point — CLAUDE.md), so a single committed-flank policy
-    # cannot generalise. The forward-zone clause (`all_of` THREE
-    # `units_in_region_gte`) is the load-bearing discriminator: a
-    # passive central reserve auto-engages but never satisfies the
-    # forward zones; only an active three-way split / staggered send
-    # wins.
-    "def-pre-position-mobile-reserve",
-    # Wave-5 Group C reasoning pack — ERQA spatial commit / MicroRTS
-    # terrain-aware defence / military pre-positioned defence /
-    # intel-driven facility hardening anchor. The model is TOLD where
-    # the enemy will attack from; the decision is purely spatial
-    # commitment (build the pbox triple on the CORRECT lane). Hard
-    # tier defines two agent spawn_point groups (NORTH base y=12 /
-    # SOUTH base y=28) round-robined by seed and the win clause is
-    # `any_of` over the two correct region orientations — the
-    # threat-axis intel rotates with the spawn so "NORTH of YOUR
-    # base" flips per seed; a memorised single-cell pbox layout
-    # cannot generalise.
-    "def-position-expected-direction",
-    # Wave-5 Group N coordination pack — SC2 triple-prong assault /
-    # military convergent (pincer) attack / envelopment doctrine. Hard
-    # tier defines two agent spawn_point groups (squads staged
-    # NORTH/WEST/SOUTH in group 0, NORTH/EAST/SOUTH in group 1)
-    # round-robined by seed; the third squad's ingress bearing flips
-    # per seed and a single memorised opening cannot generalise. The
-    # defender cluster is symmetric so both spawns face the same
-    # convergent geometry from different start corners.
-    "coord-converge-on-target",
-    # Wave-5 Group N coordination pack — SC2 attack-wave timing /
-    # SMAC relay strike / military overlapping fires (bound-and-bound)
-    # anchor. Squad A (4× 2tnk heavy first wave) destroys the enemy
-    # armour line first; Squad B (4× e1 light rifle-infantry mop-up)
-    # follows up on the survivors. (Spec-pivot from the brainstorm
-    # e3+2tnk roles — see YAML header: e3 is offensively non-viable
-    # in the engine combat sheet.) Hard tier defines two agent
-    # spawn_point groups (NORTH staging y=12..18 / SOUTH staging
-    # y=28..34) round-robined by seed; the central enemy cluster
-    # (3× 2tnk + 5× e1 at y=20) is symmetric across the map's
-    # mid-latitude so either staging faces an equivalent relay
-    # decision but no memorised approach corridor generalises across
-    # seeds.
-    "coord-relay-attack",
-    # Wave-5 Group G long-horizon "marathon survival" pack — lmgame-Bench
-    # multi-hour endurance / SC2LE full-game extended testing / SRE
-    # extended on-call anchor. Hard tier defines two agent spawn_point
-    # groups (NORTH y=12 / SOUTH y=28) round-robined by seed; six
-    # staggered hunt squads always place at BOTH latitudes (enemy
-    # actors don't honour spawn_point — CLAUDE.md), so a memorised
-    # pbox-lane / starting cell cannot generalise across seeds.
-    "lh-100-turn-marathon-survival",
-    # Wave-5 Group F reasoning pack — SC2 mass-vs-elite army composition
-    # / industrial mass-production vs craftsmanship / military
-    # quantity-vs-quality doctrine / OR unit-composition optimisation
-    # anchor. Hard tier defines two agent spawn_point groups (NORTH
-    # base y=10 / SOUTH base y=30) round-robined by seed; TWO enemy
-    # garrisons of OPPOSING composition (anti-INFANTRY at the north
-    # latitude, anti-VEHICLE at the south latitude) always place
-    # (enemy actors don't honour spawn_point — CLAUDE.md), so the
-    # right counter (mass-cheap rifles vs elite heavy tanks) flips
-    # per seed and a single memorised opening cannot generalise.
-    "econ-quantitative-vs-qualitative-spend",
-    # Wave-5 Group N coord seed: SQUAD HANDOFF via Wave-2 `then:`
-    # composite + new `units_of_type_in_region_gte` predicate (type-
-    # filtered region count). Hard defines two agent spawn_point groups
-    # (NW staging y=5..12 / SW staging y=33..38) round-robined by seed;
-    # the four-leg alternating handoff (A→P1→B→P2→A→P3→B→P4) is
-    # symmetric across starts but the per-squad long-haul leg flips
-    # per seed so a memorised opening cannot generalise.
-    "coord-squad-handoff",
-    # Wave-5 Group G long-horizon reasoning seed — SC2 macro-then-
-    # multi-prong-attack / military operational planning (force build
-    # then theater assault) / PERT theater-wide ops sequencing.
-    # Two-phase plan: assemble ≥N medium tanks THEN raze TWO separated
-    # enemy fact (NE 130,15 + SE 130,45) in parallel. Hard tier defines
-    # two agent spawn_point groups (NORTH base y=18 / SOUTH base y=42)
-    # round-robined by seed; both enemy bases always place (enemy
-    # actors don't honour spawn_point — CLAUDE.md), so the "near" vs
-    # "far" front flips per seed and the per-prong assignment must be
-    # re-computed instead of memorised.
-    "lh-build-army-coordinate-multifront-attack",
-    # Wave-5 Group F turtle-recovery seed — SC2 turtle-back-to-economy
-    # / business bankruptcy turnaround / military rebuild-from-defeat /
-    # startup pivot-after-runway-crisis anchor. Agent starts with a
-    # minimum viable kit (fact + proc + 1 harv + 1 mine) and $0 cash;
-    # must commit to harvest first then reinvest into a war factory +
-    # 2nd/3rd harvester. Hard tier defines 2 agent spawn_point groups
-    # (NORTH base y=14 / SOUTH base y=26) round-robined by seed; each
-    # spawn has its own symmetric two-patch geometry so the harv
-    # routing flips per seed and a memorised "place weap at (8,18)"
-    # opening cannot generalise.
-    "econ-recover-from-zero-cash",
-    # Wave-5 Group C defense-topology pack — graph theory min-cut /
-    # military bunker placement / firewall topology at chokepoints /
-    # Lanchester defense concentration anchor. The win predicate makes
-    # the cluster-vs-spread topology decision load-bearing
-    # (`building_in_region` ≥ N out of `building_count_gte` ≥ M total).
-    # Hard tier defines two agent spawn_point groups (NORTH base y=10 /
-    # SOUTH base y=30) round-robined by seed; the rusher band is staged
-    # symmetrically at y=20 (enemies don't honour spawn_point — CLAUDE.md)
-    # and charges the agent centroid, so the cluster's required world
-    # cell is geographically distant from each base — a memorised
-    # relative-to-base placement that lands in the same world cell on
-    # every seed cannot generalise.
-    "def-tower-line-vs-cluster",
-    # Wave-5 Group F cash-bar-by-deadline pack (SC2 econ-by-tick /
-    # budget-by-date / fundraising milestone / OR throughput-with-
-    # deadline anchor). Hard tier defines two agent spawn_point groups
-    # (NORTH y=10..14 / SOUTH y=28..32) round-robined by seed with
-    # symmetric near-patch ore geometry at both latitudes — so the
-    # reinvestment-vs-baseline decision is the same per spawn but a
-    # memorised "build at (8,18)" opening cannot generalise across
-    # seeds.
-    "econ-target-cash-amount-by-deadline",
-    # Wave-5 Group G observation-driven 3-phase chain pack (SC2 reactive
-    # macro / CICERO information-action loop / PlanBench replanning /
-    # threat-intel-driven defense anchor). Hard tier defines two agent
-    # spawn_point groups (NORTH base y=10 / SOUTH base y=30) round-
-    # robined by seed; three enemy bases (NE/MID/SE) plus a SHARED
-    # forward outpost at (60,20) always place (enemy actors don't
-    # honour spawn_point — CLAUDE.md), so the nearest-corner assault
-    # target flips per seed and a memorised "scout-then-attack-NE"
-    # opening cannot generalise across spawn variants.
-    "lh-scout-react-counter",
-    # Wave-5 salvaged-from-worktree packs: agents finished authoring
-    # YAML+tests but didn't push (multiple agents ran into push-blocked
-    # / output-truncation states). Salvaged from the untracked working
-    # tree and committed from the main session. All 4 have ≥2 spawn
-    # groups on hard.
-    "coord-cover-and-move",
+    # Wave-5 Group N coordination pack — diversionary / split-attack
+    # assault (SC2 multi-prong + Sun Tzu loud feint anchor). Hard tier
+    # defines two agent spawn_point groups (NORTH y≈10..14 / SOUTH
+    # y≈26..30) round-robined by seed; the REAL `fact` at (100,10)
+    # and the DECOY `powr` at (100,30) place every seed (enemy
+    # actors don't honour spawn_point — CLAUDE.md), so the SAME
+    # diversionary discipline is tested from either spawn while the
+    # bait/strike vector flips per seed.
     "coord-diversionary-attack",
     "def-in-depth",
     "def-surprise-flank-react",
@@ -620,7 +464,7 @@ NOT_APPLICABLE = {
 
 # No-adversary maps: spawn variation applies but a force-loss
 # fail_condition is impossible (nothing can destroy the force).
-_NO_ENEMY = {"strict-sequence", "custom-map-no-enemy", "proc-checklist-no-deviation"}
+_NO_ENEMY = {"strict-sequence", "custom-map-no-enemy"}
 
 
 def _agent_spawn_points(pack_id: str, level: str) -> set: