feat(scenarios): Wave-5 salvage — 16 packs rescued from worktree branches

16 Wave-5 agents finished authoring (YAML + scripted-policy tests) but
their pushes were blocked / outputs truncated. Salvaged from the
untracked working tree and committed from the main session:

Defense-positioning (3 net-new, 1 was already registered):
- def-in-depth (military DiD doctrine / security multi-layer)
- def-surprise-flank-react (adversarial robustness / CICERO deception)
- def-tower-line-vs-cluster (graph min-cut / military bunker)

Coordination (5):
- coord-converge-on-target (SC2 triple-prong / military pincer)
- coord-cover-and-move (SC2 / military bounding overwatch)
- coord-diversionary-attack (SC2 split-attack / Sun Tzu diversion)
- coord-relay-attack (SC2 attack-wave / SMAC relay)
- coord-squad-handoff (Watch-And-Help / SMAC squad sequencing)

Long-horizon (5):
- lh-100-turn-marathon-survival (lmgame multi-hour / SC2LE endurance)
- lh-build-army-coordinate-multifront-attack (SC2 macro / mil ops)
- lh-defense-tech-second-base (SC2 secure-expand-tech / PlanBench)
- lh-multi-checkpoint-5-plus (PERT / PlanBench long-sequencing)
- lh-scout-react-counter (CICERO info-loop / PlanBench replanning)

Economy (3):
- econ-cash-reserve-management (SC2 / treasury working capital)
- econ-recover-from-zero-cash (SC2 turtle-recovery / turnaround)
- econ-target-cash-amount-by-deadline (SC2 / budget-by-date)

All 16 have ≥2 spawn groups on hard; all registered in
test_hard_tier.py UPGRADED (12 were already registered by their
agents' worktree edits that did get pushed via shared FS).

openra_bench/scenarios/packs/coord-converge-on-target.yaml

@@ -0,0 +1,263 @@
+# coord-converge-on-target.yaml
+#
+# ACTION capability — triple-prong convergent attack. Three armoured
+# squads start at three different bearings (NORTH, WEST-of-objective,
+# SOUTH) and must CONVERGE simultaneously on a single defended enemy
+# objective (`fact`) at mid-east. Each squad ALONE is killed by the
+# leashed `guard` defenders before the fact falls; TWO squads
+# converging may destroy the fact but trade out the strike force
+# (surviving tank count in the objective region falls below n=6); only
+# when ALL THREE squads arrive within a tight common window do they
+# overwhelm the defenders cleanly enough to leave ≥6 tanks in the
+# objective region with the yard destroyed.
+#
+# Real-world anchor: military convergent / envelopment attack and SC2
+# triple-prong assault — multiple columns striking from different
+# bearings at the same instant to overwhelm a defender that would
+# defeat any single column. Robotics analogue: synchronous multi-team
+# rendezvous on a shared objective under a tight common deadline.
+#
+# Engine notes (per CLAUDE.md):
+#   - `fact` is `MustBeDestroyed`: razing it would auto-`done` the
+#     engine and a within-ticks check could collapse to DRAW. A
+#     SENTINEL enemy `fact` is placed in the far north (out of the
+#     combat zone) so the episode persists past the objective fact's
+#     destruction long enough for the win/fail predicates to evaluate.
+#   - Bot `guard` (GUARD_AGGRO ≈ 16, GUARD_LEASH ≈ 18) holds post,
+#     auto-fires in range, lunges at the nearest foe within ≈16
+#     cells, snaps back past ≈18. The e3 rocket infantry is the
+#     anti-tank Dragon: each guard chews a 2tnk in a handful of
+#     shots, so a single squad's commit on the cluster is lethal.
+#   - `units_in_region_gte` ≥6 on the 9 tanks is load-bearing: a
+#     two-squad converge (6 tanks) typically destroys the fact but
+#     trades the whole strike force (≤0 tanks left in region), so a
+#     partial converge LOSES on the predicate even when the fact
+#     happens to fall. A single squad alone is wiped before the fact
+#     falls. Three squads converging arrive together and overwhelm:
+#     ≥6 tanks survive inside the (100,20, r=8) region while the
+#     cluster + fact go down.
+#   - Squad positions are balanced equidistant (~32-34 cells from the
+#     objective) so a naive simultaneous attack-move from all three
+#     squads ACTUALLY ARRIVES TOGETHER; widely-unbalanced edge spawns
+#     would force the closer squads into the cluster alone first and
+#     a 3-prong policy would degenerate to a serial 1-then-1-then-1
+#     attack defeated piecewise (the calibration bar still requires
+#     simultaneous arrival).
+#   - Enemy actors are NOT filtered by `spawn_point` (CLAUDE.md). The
+#     hard tier varies the AGENT staging — the lateral (third) squad
+#     starts WEST of objective in spawn 0 and EAST of objective in
+#     spawn 1, flipping its ingress bearing — while the defender
+#     cluster stays symmetric.
+
+meta:
+  id: coord-converge-on-target
+  title: 'Convergent Attack — Three Squads, One Defended Target'
+  capability: action
+  real_world_meaning: >
+    Three armoured columns start on three different bearings (NORTH,
+    WEST-of-objective, SOUTH) and must converge on a single defended
+    enemy construction yard from three different directions AT THE
+    SAME TIME. Any one column alone is killed by the defenders before
+    the yard falls; two columns may destroy the yard but trade out
+    the strike force (surviving tank count in the objective region
+    drops below the required threshold); only when all three columns
+    arrive on the objective within a tight common window does the
+    combined force overwhelm the defenders cleanly. The advertised
+    capability is synchronous multi-fleet convergence on a shared
+    objective — a single-column tour or a serialized two-column
+    attempt loses on attrition, a stall loses on the clock.
+  robotics_analogue: >
+    Synchronous multi-robot rendezvous on a contested objective: each
+    team must dispatch on a different ingress vector so that all
+    teams arrive at the goal within a bounded common window;
+    serialising one team after another lets the contesting agents
+    defeat each team in detail and prevents the joint payload
+    threshold (≥n teammates surviving on the goal) from holding.
+  benchmark_anchor:
+    - "SC2 triple-prong assault timing"
+    - "military convergent attack / pincer movement"
+    - "SMAC squad convergence"
+    - "envelopment doctrine: hit from multiple directions simultaneously"
+  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}
+  actors: []   # every level supplies its own actor list via overrides.
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # The bare convergent-attack skill: 3 leashed guards (distributed
+  # around the objective fact), 9 tanks total. A single squad of 3
+  # tanks alone is wiped by the 3 anti-tank guards before the fact
+  # falls; 2-prong or 3-prong both succeed (easy is lenient on the
+  # n=6 region clause). A stall (no movement) loses on the clock.
+  easy:
+    description: >
+      THREE squads of medium tanks (3× 2tnk each, 9 tanks total) start
+      at three different bearings around the enemy construction yard
+      (`fact` at ~100,20): NORTH (~70,6), WEST (~66,20), SOUTH
+      (~70,34). The yard is defended by 3 leashed rocket-infantry
+      guards (e3, bot_type guard) that hold post, auto-fire in range,
+      and lunge at the nearest approaching foe. Win when at least 6
+      of your 9 tanks are inside an 8-cell radius of (100,20) AND the
+      enemy construction yard is destroyed, before tick 4500. A
+      single squad alone is killed by the guard cluster before the
+      yard falls. A stall loses on the clock.
+    overrides:
+      actors:
+        # NORTH squad — 3 medium tanks at (70,6).
+        - {type: 2tnk, owner: agent, position: [70, 6],  stance: 1, count: 3}
+        # WEST squad — 3 medium tanks at (66,20). Equidistant from
+        # the objective (~34 cells) so a naive simultaneous launch
+        # arrives together.
+        - {type: 2tnk, owner: agent, position: [66, 20], stance: 1, count: 3}
+        # SOUTH squad — 3 medium tanks at (70,34).
+        - {type: 2tnk, owner: agent, position: [70, 34], stance: 1, count: 3}
+        # The OBJECTIVE: enemy construction yard.
+        - {type: fact, owner: enemy, position: [100, 20]}
+        # 3 GUARDS distributed around the objective (W / E / N faces)
+        # so every ingress bearing enters guard aggro.
+        - {type: e3, owner: enemy, position: [98, 18]}
+        - {type: e3, owner: enemy, position: [102, 22]}
+        - {type: e3, owner: enemy, position: [100, 17]}
+        # SENTINEL: persistent enemy fact in the far north so the
+        # engine does not auto-`done` the instant the objective fact
+        # dies; lets within_ticks / region predicates evaluate
+        # cleanly on the terminal frame.
+        - {type: fact, owner: enemy, position: [120, 4]}
+    win_condition:
+      all_of:
+        - {units_in_region_gte: {x: 100, y: 20, radius: 8, n: 6}}
+        - {enemy_key_buildings_destroyed: {types: [fact]}}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {own_units_gte: 1}}
+    max_turns: 54
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 controlled variable: 4 guards (one per cardinal face of the
+  # objective) and a tighter trade. A single squad alone is destroyed.
+  # Two squads converging arrive piecewise — the closer squad enters
+  # the cluster first and is ground down by 4 anti-tank guards
+  # before the second squad arrives; the joint surviving in-region
+  # count never reaches n=6 (the trade typically destroys the fact
+  # but leaves 0 tanks in region). Three squads converging mass
+  # enough simultaneous DPS to overrun the cluster cleanly (≥6
+  # tanks survive in region while the cluster + fact fall).
+  medium:
+    description: >
+      THREE squads of medium tanks (3× 2tnk each, 9 tanks total) from
+      NORTH (~70,6), WEST (~66,20), SOUTH (~70,34) must converge on
+      the enemy construction yard (`fact` at ~100,20) defended by 4
+      leashed rocket-infantry guards (one on each cardinal face). A
+      single squad alone is killed by the guards; two squads
+      converging destroy the yard but trade out the whole strike
+      force (no tanks survive inside the objective region). All
+      three squads must arrive together: win when ≥6 of your 9 tanks
+      are inside an 8-cell radius of (100,20) AND the yard is
+      destroyed, before tick 4500. A stall loses on the clock.
+    overrides:
+      actors:
+        - {type: 2tnk, owner: agent, position: [70, 6],  stance: 1, count: 3}
+        - {type: 2tnk, owner: agent, position: [66, 20], stance: 1, count: 3}
+        - {type: 2tnk, owner: agent, position: [70, 34], stance: 1, count: 3}
+        - {type: fact, owner: enemy, position: [100, 20]}
+        # 4 guards: one on each cardinal face of the objective.
+        - {type: e3, owner: enemy, position: [98, 20]}
+        - {type: e3, owner: enemy, position: [102, 20]}
+        - {type: e3, owner: enemy, position: [100, 17]}
+        - {type: e3, owner: enemy, position: [100, 23]}
+        - {type: fact, owner: enemy, position: [120, 4]}
+    win_condition:
+      all_of:
+        - {units_in_region_gte: {x: 100, y: 20, radius: 8, n: 6}}
+        - {enemy_key_buildings_destroyed: {types: [fact]}}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {own_units_gte: 1}}
+    max_turns: 54
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 more controlled variable: TWO seed-driven agent spawn groups
+  # round-robined per seed. Group 0 places the lateral (third) squad
+  # WEST of the objective at (66,20); group 1 places it EAST of the
+  # objective at (134,20). The defender cluster stays symmetric (4
+  # guards, one on each cardinal face) so both spawns face the same
+  # convergent geometry but the lateral squad's ingress bearing
+  # flips per seed (W → E). A single memorised "3-prong from W/N/S"
+  # opening cannot generalise. NORTH and SOUTH squads are common to
+  # both groups (placed without spawn_point — but the documented
+  # filter rule in CLAUDE.md ("if ANY agent actor declares
+  # spawn_point, every agent actor WITHOUT spawn_point is filtered
+  # OUT") means N/S MUST be duplicated across spawn groups; both
+  # copies are placed at identical coords so the contract is met
+  # without changing the geometry per seed.
+  hard:
+    description: >
+      THREE squads of medium tanks (3× 2tnk each, 9 tanks total) must
+      converge on the enemy construction yard (`fact` at ~100,20)
+      defended by 4 leashed rocket-infantry guards (one on each
+      cardinal face). The squad layout flips per seed: one spawn
+      stages NORTH (~70,6) / WEST (~66,20) / SOUTH (~70,34); the
+      other stages NORTH (~74,8) / EAST (~126,20) / SOUTH (~74,32).
+      Both layouts are balanced equidistant (~26-34 cells per
+      squad) so a synchronised launch arrives together. A single
+      squad alone is
+      destroyed by the guards; two squads converging trade out the
+      strike force before satisfying the region threshold. Win when
+      ≥6 of your 9 tanks are inside an 8-cell radius of (100,20) AND
+      the yard is destroyed, before tick 4500.
+    overrides:
+      actors:
+        # spawn_point 0 — NORTH / WEST-of-objective / SOUTH.
+        - {type: 2tnk, owner: agent, position: [70, 6],  stance: 1, count: 3, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [66, 20], stance: 1, count: 3, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [70, 34], stance: 1, count: 3, spawn_point: 0}
+        # spawn_point 1 — NORTH / EAST-of-objective / SOUTH.
+        # NORTH and SOUTH are duplicated at identical coords so the
+        # spawn-filter rule (CLAUDE.md) doesn't drop them from group 1;
+        # the WEST squad is relocated to EAST at (134,20) — equidistant
+        # from the objective on the opposite bearing, flipping the
+        # lateral ingress direction. The seed-chosen ingress geometry
+        # cannot be memorised: a fixed "drive west squad east" opening
+        # is wrong half the seeds.
+        # NORTH and SOUTH in group 1 are pulled in slightly to
+        # (74, 8) / (74, 32) so their distance to the objective (~29
+        # cells) closely matches the EAST squad's distance from
+        # (126, 20) (~26 cells) — a naive simultaneous launch from
+        # group 1 has all three squads arrive together (group 0
+        # already balanced at ~34 from each of W / N / S).
+        - {type: 2tnk, owner: agent, position: [74, 8],   stance: 1, count: 3, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [126, 20], stance: 1, count: 3, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [74, 32],  stance: 1, count: 3, spawn_point: 1}
+        # The OBJECTIVE.
+        - {type: fact, owner: enemy, position: [100, 20]}
+        # 4 guards: one on each cardinal face. Symmetric: equally
+        # covers both lateral ingress bearings (W and E).
+        - {type: e3, owner: enemy, position: [98, 20]}
+        - {type: e3, owner: enemy, position: [102, 20]}
+        - {type: e3, owner: enemy, position: [100, 17]}
+        - {type: e3, owner: enemy, position: [100, 23]}
+        # SENTINEL: persistent enemy fact in the far north so the
+        # engine does not auto-`done` on objective raze.
+        - {type: fact, owner: enemy, position: [120, 4]}
+    win_condition:
+      all_of:
+        - {units_in_region_gte: {x: 100, y: 20, radius: 8, n: 6}}
+        - {enemy_key_buildings_destroyed: {types: [fact]}}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {own_units_gte: 1}}
+    max_turns: 54

openra_bench/scenarios/packs/coord-cover-and-move.yaml

@@ -0,0 +1,330 @@
+# coord-cover-and-move — bounding overwatch across a fire zone.
+#
+# ACTION focus: two squads must cross a centre-of-map fire zone defended
+# by static anti-tank infantry. Charging both squads together stacks
+# every cluster's fire on the SAME column — the e3 anti-tank rocket
+# soldiers focus the dense formation and bust the attrition cap (≥2
+# tanks lost). Sending one squad alone leaves the other idle and the
+# moving squad eats ALL the cluster's fire (≥2 lost). Stalling burns
+# the clock. The intended idiom is military FIRE-AND-MANEUVER bounding
+# overwatch: one squad stops just outside the fire zone, anchors to
+# DRAW fire, and engages the cluster from the closer flank while the
+# other squad sweeps WIDE through the unoccupied periphery (y outside
+# the cluster's ~5-cell sight). The cluster's attention splits between
+# the firing "cover" team and the (invisible / out-of-range) "move"
+# team; the move team crosses safely. Then the roles alternate so the
+# cover team can also cross. Each squad takes at most 1 loss because
+# enemy fire is divided per phase, not stacked on a single column.
+#
+# Real-world anchor: US Army FM 3-21.8 bounding overwatch — one fire
+# team in a stationary OVERWATCH posture provides suppressive fire
+# while the BOUNDING fire team moves forward by short rushes through
+# the danger zone; roles alternate ("leapfrog") as the bounding team
+# reaches its next covered position and assumes overwatch for the
+# previously-overwatching team. SC2 tank micro encodes the same
+# pattern as the siege-tank "leapfrog" advance.
+#
+# Discrimination (the four script-policy bar):
+#   • stall (observe-only): no squad crosses → win region empty →
+#     after_ticks LOSS.
+#   • both-charge-together: all 6 tanks rush a single eastward column
+#     through the fire zone; 4× e3 stance:3 (medium) auto-fire on the
+#     densest cluster and bust units_lost_lte:1 → LOSS.
+#   • single-squad-only: send Squad A through alone (Squad B idle west);
+#     A absorbs ALL the cluster's fire across its crossing and loses
+#     ≥2 → busts units_lost_lte:1 → LOSS.
+#   • intended bound-and-cover: A anchors at (45,15) firing on the
+#     cluster (drawing fire from the closer flank); B swings WIDE
+#     through y=8..10 (outside e3 sight 5 from the cluster centre at
+#     y=20) to (90,15); then B opens fire from the east edge of the
+#     cluster while A relocates north and crosses through y=8..10.
+#     Cluster fire is split per phase; each squad takes ≤1 loss; ≥4
+#     tanks land in the win region within the deadline → WIN.
+#
+# Why the spec works (engine combat sheet):
+#   • e3 = anti-tank rocket soldier (rng4c, dps12, sight5c, hp45).
+#     Effective vs 2tnk armour. 4× e3 firing on a single dense column
+#     stacks ~48 dps onto whichever tank is nearest; a column charging
+#     through the cluster spends ~3-4 decision turns in range and the
+#     stacked dps cleans off ≥2 tanks (busts units_lost_lte:1).
+#   • 2tnk = medium tank (rng4.75c, dps22, sight6c, hp400). Marginally
+#     out-ranges e3 (4.75 vs 4), so a tank that STOPS just at the edge
+#     of e3 range (~dist 5 from cluster) can fire back without being
+#     in e3 range itself — the OVERWATCH posture. Its dps22 plus the
+#     other overwatch tank chips down the cluster across the bound,
+#     reducing fire on the second-phase bounding team.
+#   • Sight-line geometry: with the cluster at y=19..21 (sight 5), e3s
+#     see roughly y=14..26. A squad routing through y=8..10 is OUTSIDE
+#     enemy sight and OUTSIDE enemy range — it takes ZERO fire while
+#     moving, even though its straight-line distance is ~10 cells.
+#     That's the "bounding lane" geometry — outside the fire envelope.
+#
+# Engine guardrails (per CLAUDE.md):
+#   • Map: rush-hour-arena (128 × 40 playable; x in [2..126], y in
+#     [2..38]). All actor / region cells are inside.
+#   • CLAUDE.md footgun: enemy clusters at (50,20) silently FAIL to
+#     place. Cluster cells are (49,19), (49,21), (51,19), (51,21) —
+#     verified-placeable neighbours used by other packs.
+#   • A persistent far enemy `fact` at (120,20) prevents engine auto-
+#     done when the central cluster is cleaned out (so the win/fail
+#     evaluator sees the terminal frame instead of a DRAW collapse).
+#   • after_ticks fail clauses are reachable within max_turns
+#     (tick ≤ 93 + 90·(max_turns-1)); within_ticks 4500 < 4503 at
+#     max_turns 50; staller hits after_ticks 4501 and LOSES, not draws.
+
+meta:
+  id: coord-cover-and-move
+  title: 'Bounding Overwatch — One Squad Covers While the Other Moves'
+  capability: action
+  real_world_meaning: >
+    Two armoured squads must cross a centre-of-map FIRE ZONE held by
+    static anti-tank infantry. Charging both squads through together
+    stacks every enemy's fire onto a single dense column and busts the
+    attrition cap. Sending one squad alone leaves the other idle and
+    the lone column still absorbs ALL the cluster's fire. The intended
+    capability is bounding overwatch: one squad stops just OUTSIDE the
+    cluster's range and acts as the COVER team — firing on the cluster
+    to draw its attention from the closer flank — while the BOUNDING
+    team sweeps WIDE through the periphery (outside enemy sight) to a
+    forward position; then the roles alternate so the cover team can
+    also cross safely. The cluster's fire is split per phase rather
+    than stacked on one column, so each squad takes at most one loss.
+  robotics_analogue: >
+    Multi-agent traversal of a contested corridor where defenders have
+    a fixed effective range envelope and concentrate fire on whichever
+    cluster is closest. Single-team traversal eats the full defensive
+    fire envelope; the joint policy alternates an OVERWATCH role
+    (suppressive fire drawing defender attention from a flank) with a
+    BOUNDING role (sweep through the cleared periphery). The
+    coordination is the role-alternation — leapfrogging cover and
+    move — not just splitting the force.
+  benchmark_anchor:
+    - "US Army FM 3-21.8 bounding overwatch (fire-and-maneuver doctrine)"
+    - "SC2 siege-tank leapfrog advance under enemy fire"
+    - "SMAC coordinated cross of a danger zone with split defender fire"
+    - "MicroRTS multi-squad alternating cover-and-move"
+  author: "openra-bench"
+
+base_map: rush-hour-arena
+
+base:
+  agent: {faction: allies, cash: 0}
+  enemy: {faction: soviet, cash: 0, bot_type: ''}
+  tools: [move_units, attack_unit, attack_move, stop]
+  planning: true
+  # React the instant the moving squad takes a hit or first contact is
+  # made — bounding overwatch is REACTIVE micro (the cover team must
+  # re-target as bounding-team contact opens up). Without these
+  # interrupts the role-alternation only re-evaluates on fixed turn
+  # boundaries and the e3 cluster gets free shots through every gap.
+  interrupts:
+    enemy_unit_spotted: true
+    own_unit_destroyed: true
+  termination: {max_ticks: 6000}
+  actors: []   # every level supplies its own actor list via overrides.
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Bare bound-and-cover skill: 4× e1 rifle infantry at centre (NOT
+  # the anti-tank e3 — easy uses the weaker rifle, low DPS vs armour
+  # so the cap is forgiving). Both-charge-together may squeak by on
+  # luck (e1 vs 2tnk armour is poor); stall and single-squad both
+  # still LOSE via the timeout / kill geometry.
+  easy:
+    description: >
+      Two squads (Squad A at (10,15), Squad B at (10,25), 3 medium
+      tanks each) must cross a centre-of-map fire zone defended by
+      static rifle infantry (e1) at roughly (50,20), then land ≥4
+      tanks in the EAST gathering region (x ≈ 100, y ≈ 20, radius 6)
+      before tick 4500, losing ≤1 tank in total. The rifle infantry
+      do limited damage to armour on easy, but charging both squads
+      together still stacks their fire onto the densest cluster and
+      a single column alone absorbs every shot — alternate ROLES:
+      one squad anchors at the edge of enemy range to draw fire
+      while the other sweeps through the periphery (y outside enemy
+      sight) and crosses; then switch.
+    overrides:
+      actors:
+        # Squad A — northern fire team, staged at (10, 15).
+        - {type: 2tnk, owner: agent, position: [10, 14], stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 15], stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 16], stance: 1}
+        # Squad B — southern fire team, staged at (10, 25).
+        - {type: 2tnk, owner: agent, position: [10, 24], stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 25], stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 26], stance: 1}
+        # Centre fire zone: 4× rifle infantry stance:3 (AttackAnything
+        # in range). Cells avoid (50,20) — CLAUDE.md footgun: enemy
+        # clusters at (50,20) silently fail to place. Off-axis
+        # neighbours (49/51 × 19/21) are verified-placeable.
+        - {type: e1, owner: enemy, position: [49, 19], stance: 3}
+        - {type: e1, owner: enemy, position: [49, 21], stance: 3}
+        - {type: e1, owner: enemy, position: [51, 19], stance: 3}
+        - {type: e1, owner: enemy, position: [51, 21], stance: 3}
+        # Persistent far enemy `fact` — keeps the episode alive past
+        # the central cluster being cleaned out so the win/fail
+        # evaluator sees the terminal frame (no DRAW collapse).
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {units_in_region_gte: {x: 100, y: 20, radius: 6, n: 4}}
+        - {units_lost_lte: 1}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {units_lost_lte: 1}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 50
+
+  # ── MEDIUM ──────────��────────────────────────────────────────────
+  # +1 axis: ANTI-TANK rocket soldiers (e3) replace rifle infantry,
+  # so the fire zone is genuinely lethal to 2tnk armour. Both-charge-
+  # together LOSES (4× e3 stacked dps onto a dense column busts
+  # units_lost_lte:1); single-squad alone LOSES (lone column absorbs
+  # every shot). Only true bound-and-cover (squads alternate roles
+  # so cluster fire is SPLIT per phase) keeps each squad to ≤1 loss.
+  medium:
+    description: >
+      Two squads (Squad A at (10,15), Squad B at (10,25), 3 medium
+      tanks each) must cross a centre-of-map FIRE ZONE defended by
+      four static anti-tank rocket soldiers (e3) at roughly (50,20),
+      then land ≥4 tanks in the EAST gathering region (x ≈ 100,
+      y ≈ 20, radius 6) before tick 4500, losing ≤1 tank in total.
+      Charging BOTH squads through the centre stacks all four e3s'
+      anti-armour fire on a single dense column and busts the cap.
+      Sending one squad alone leaves the other idle and the lone
+      column absorbs every shot. The intended idiom is BOUNDING
+      OVERWATCH: one squad anchors at the EDGE of enemy range
+      (around x ≈ 45, y ≈ 15 — close enough to fire back, far
+      enough to suppress) drawing the cluster's attention from the
+      closer flank, while the other squad sweeps WIDE through the
+      periphery (around y ≈ 8..10, OUTSIDE the cluster's sight
+      range) to the east. Then the roles ALTERNATE — the team that
+      moved opens fire from the east edge of the cluster while the
+      original cover team relocates north and crosses through the
+      same outside-sight band. Each squad takes ≤1 loss because
+      cluster fire is SPLIT per phase, not stacked.
+    overrides:
+      actors:
+        - {type: 2tnk, owner: agent, position: [10, 14], stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 15], stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 16], stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 24], stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 25], stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 26], stance: 1}
+        # Centre fire zone: 4× anti-tank rocket soldiers stance:3.
+        - {type: e3, owner: enemy, position: [49, 19], stance: 3}
+        - {type: e3, owner: enemy, position: [49, 21], stance: 3}
+        - {type: e3, owner: enemy, position: [51, 19], stance: 3}
+        - {type: e3, owner: enemy, position: [51, 21], stance: 3}
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {units_in_region_gte: {x: 100, y: 20, radius: 6, n: 4}}
+        - {units_lost_lte: 1}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {units_lost_lte: 1}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 50
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +2 axes vs medium:
+  #   1. ZERO attrition cap (units_lost_lte: 0) — any tank loss
+  #      fails. The cover team's overwatch fire must SUPPRESS the
+  #      cluster enough that the bounding team takes no hits at all
+  #      (the wide-flank route via y=8..10 already keeps the bounding
+  #      team out of e3 sight — the zero-loss bar makes the geometry
+  #      load-bearing instead of a margin-of-error luxury).
+  #   2. An additional e1 RIFLE-INFANTRY swarm extends the fire
+  #      envelope (3× e1 north of the cluster + 3× e1 south),
+  #      tightening the periphery-route corridor: a squad that drifts
+  #      to y=12 or y=28 brushes the rifle screens. The bounding lane
+  #      is narrower — bound through y=6..9 or y=31..34, not y=12+ or
+  #      y=27- — and the cover team must keep the rocket cluster
+  #      ITSELF suppressed (overwatch on the e3, not the e1s, since
+  #      the e3 is the priority anti-armour threat).
+  #   3. Strike force stages from TWO seed-driven spawn_point groups
+  #      (NORTH-WEST y=12..16 OR SOUTH-WEST y=24..28), round-robined
+  #      by seed. The cluster and the win region are symmetric across
+  #      y=20 so EITHER spawn faces an equivalent bounding decision
+  #      (cover from the closer flank, bound around the FAR
+  #      periphery), but a single memorised bound vector cannot
+  #      generalise across seeds.
+  hard:
+    description: >
+      Two squads (3 medium tanks each, staged at the NW or SW
+      corner, chosen by seed for anti-memorisation) must cross a
+      centre-of-map FIRE ZONE — four anti-tank rocket soldiers (e3)
+      at roughly (50,20), flanked by two rifle-infantry SCREENS that
+      extend the fire envelope north and south — and land ≥4 tanks
+      in the EAST gathering region (x ≈ 100, y ≈ 20, radius 6)
+      before tick 4500, losing ZERO tanks in total. The intended
+      idiom is BOUNDING OVERWATCH with the wide-flank route
+      tightened by the rifle screens: the cover team anchors at the
+      edge of e3 range (within tank range, OUT of e3 range) and
+      suppresses the rocket cluster (the priority anti-armour
+      threat); the bounding team sweeps through the FAR periphery
+      (around y ≈ 6..9 from the NORTH spawn, or y ≈ 31..34 from the
+      SOUTH spawn — outside both the rocket-cluster sight envelope
+      AND the rifle-screen weapon range) to the east. Then the
+      roles alternate. Zero loss is only achievable when the cover
+      team's overwatch fire keeps the cluster suppressed during the
+      bounding team's transit.
+    overrides:
+      actors:
+        # spawn_point 0 — NORTH-WEST staging (Squad A at (10,12)
+        # north, Squad B at (10,16) south of A but still north of
+        # centre — they bound through the far NORTH periphery
+        # y ≈ 6..9 outside both rifle-screen and rocket sight).
+        - {type: 2tnk, owner: agent, position: [10, 11], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [10, 12], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [10, 13], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [10, 15], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [10, 16], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [10, 17], stance: 1, spawn_point: 0}
+        # spawn_point 1 — SOUTH-WEST staging (mirrored across y=20).
+        # The cover/bound decision is symmetric: cover at south
+        # edge of e3 range, bound through y ≈ 31..34.
+        - {type: 2tnk, owner: agent, position: [10, 23], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [10, 24], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [10, 25], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [10, 27], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [10, 28], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [10, 29], stance: 1, spawn_point: 1}
+        # Centre rocket cluster — same 4× e3 as medium, symmetric
+        # across y=20 so EITHER spawn faces an equivalent geometry.
+        - {type: e3, owner: enemy, position: [49, 19], stance: 3}
+        - {type: e3, owner: enemy, position: [49, 21], stance: 3}
+        - {type: e3, owner: enemy, position: [51, 19], stance: 3}
+        - {type: e3, owner: enemy, position: [51, 21], stance: 3}
+        # Rifle-infantry SCREENS — extend the fire envelope north
+        # and south of the rocket cluster, tightening the bounding
+        # lane. y=14 / y=26 are within e3 cluster's sight (5c) so
+        # the screens reinforce the same envelope — a squad
+        # bounding through y=12 or y=28 would be in screen range
+        # (e1 rng4c sees out to ~y=10 from y=14). The intended
+        # bounding lane is OUTSIDE that envelope: y ≈ 6..9 (NORTH)
+        # or y ≈ 31..34 (SOUTH).
+        - {type: e1, owner: enemy, position: [49, 14], stance: 3}
+        - {type: e1, owner: enemy, position: [51, 14], stance: 3}
+        - {type: e1, owner: enemy, position: [50, 13], stance: 3}
+        - {type: e1, owner: enemy, position: [49, 26], stance: 3}
+        - {type: e1, owner: enemy, position: [51, 26], stance: 3}
+        - {type: e1, owner: enemy, position: [50, 27], stance: 3}
+        # Persistent far enemy fact — engine auto-done mitigation.
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {units_in_region_gte: {x: 100, y: 20, radius: 6, n: 4}}
+        - {units_lost_lte: 0}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {units_lost_lte: 0}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 50

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

@@ -0,0 +1,336 @@
+# coord-diversionary-attack.yaml
+#
+# REASONING capability — split-attack / diversionary assault. Two
+# 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.
+#
+# 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.
+#
+# 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.
+#
+# 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.
+#
+# 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.
+#
+# Engine notes (per CLAUDE.md):
+#   - `fact` and `powr` are MustBeDestroyed. A SENTINEL enemy `fact`
+#     is placed far south-east (out of the combat zone, agent can't
+#     reach it in budget) so the engine doesn't auto-`done` the
+#     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.
+
+meta:
+  id: coord-diversionary-attack
+  title: 'Diversionary Attack — A Diverts South, B Razes the Real Target North'
+  capability: reasoning
+  real_world_meaning: >
+    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).
+  robotics_analogue: >
+    Concurrent multi-robot dispatch with deception: two independent
+    teams must coordinate against a reactive adversary, where one
+    team takes a NO-REWARD enabling role (drawing the adversary's
+    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.
+  benchmark_anchor:
+    - "SC2 multi-prong / split-attack assault"
+    - "military diversionary tactics (Sun Tzu loud feint + quiet main thrust)"
+    - "CICERO / Diplomacy deception"
+    - "advertising: loud feint draws competitor attention while quiet launch hits real market"
+  author: openra-bench
+
+base_map: rush-hour-arena
+
+base:
+  agent: {faction: allies, cash: 0}
+  enemy: {faction: soviet, cash: 0, bot_type: hunt}
+  tools: [move_units, attack_unit, attack_move, stop]
+  planning: true
+  termination: {max_ticks: 12000}
+
+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
+  # → 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.
+  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)
+      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).
+    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.
+        - {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).
+        - {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}
+        # SENTINEL: persistent enemy fact far south-east (out of
+        # combat zone, unreachable in budget) so the episode
+        # doesn't auto-`done` the instant the objective fact dies;
+        # within_ticks / units_lost_lte then evaluate cleanly.
+        - {type: fact, owner: enemy, position: [125, 38]}
+    win_condition:
+      all_of:
+        - enemy_key_buildings_destroyed_in_region:
+            {x: 100, y: 10, radius: 6, 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: 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).
+  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).
+    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.
+        - {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.
+        - {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}
+        - {type: fact, owner: enemy, position: [125, 38]}
+    win_condition:
+      all_of:
+        - enemy_key_buildings_destroyed_in_region:
+            {x: 100, y: 10, radius: 6, 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
+
+  # ── 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.
+  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.
+    overrides:
+      actors:
+        # spawn_point 0 — NORTH staging (jeeps + tanks at y≈10..14).
+        - {type: jeep, owner: agent, position: [6, 10], stance: 1, count: 3,
+           spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [6, 14], stance: 1, count: 4,
+           spawn_point: 0}
+        # spawn_point 1 — SOUTH staging (mirror at y≈26..30).
+        - {type: jeep, owner: agent, position: [6, 30], stance: 1, count: 3,
+           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.
+        - {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
+        # 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]}
+        - 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

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

@@ -0,0 +1,247 @@
+# coord-relay-attack.yaml
+#
+# ACTION capability — relay assault: Squad A engages FIRST (rockets
+# soften the enemy armour), THEN Squad B follows up to finish off the
+# survivors. The Wave-2 `then:` happened-before composite makes the
+# ordering load-bearing: clause 1 (`units_killed_gte: K1`) must latch
+# BEFORE clause 2 (`units_killed_gte: K2`) — a chain-of-thought that
+# rushes B first or both-at-once cannot satisfy the chain in time
+# because B's tanks get focus-fired by the enemy's 4× 2tnk before any
+# kills materialise, blowing the `units_lost_lte` attrition cap.
+#
+# The relay teeth:
+#   - Squad A = 3× e3 (rocket soldiers, anti-vehicle): well-suited to
+#     killing the enemy's 4× 2tnk, but slow to melt the 4× e1 alone.
+#   - Squad B = 3× 2tnk (medium tanks, anti-infantry mop-up): great vs
+#     e1 horde, but BLEEDS when fed alone into the enemy 4× 2tnk that
+#     out-DPS them via focus fire.
+#   - Enemy = 4× 2tnk + 4× e1 clustered at the centre (static, stance
+#     2 = return-fire only). Naturally relays A→tanks-first so B faces
+#     only the remaining infantry.
+#
+# Real-world anchor: SC2 attack-wave timing (1st wave commits, 2nd
+# wave clears survivors); SMAC relay strike doctrine; military
+# overlapping fires; fire-and-maneuver bound-and-bound.
+#
+# ENGINE NOTE: the centre enemy cluster is the *only* enemy presence,
+# so the engine will auto-end the episode the second the last enemy
+# falls. We anchor an unarmed high-HP `proc` "marker" deep at the far
+# east so a stalled / partial run cannot prematurely auto-`done` —
+# but the win predicate counts `units_killed_gte`, not buildings, so
+# the marker is purely a stay-alive prop. Distance >40 cells from
+# every agent route keeps it out of tank vision.
+#
+# Validate:
+#   cd /Users/berta/Projects/OpenRA-Bench && \
+#   python3 -m openra_bench.scenarios.validate \
+#     openra_bench/scenarios/packs/coord-relay-attack.yaml
+
+meta:
+  id: coord-relay-attack
+  title: 'Relay Strike — Rockets Soften, Tanks Mop Up'
+  capability: action
+  real_world_meaning: >
+    Two-wave relay assault: the first wave (rockets) softens the
+    target by destroying the heavy threats; the second wave (tanks)
+    follows up to clear the remaining infantry. Sending the second
+    wave in first exposes it to the un-softened heavy threats and
+    loses the force; sending both together (simultaneous commit)
+    exposes the mop-up wave to the same heavies before they are
+    suppressed — only the relay ordering (A engages → softens →
+    THEN B advances) preserves the force and finishes inside the
+    deadline.
+  robotics_analogue: >
+    Two-team relay clearing operation: the suppression team commits
+    first to neutralise the heavy threats, then the mop-up team
+    advances to clear the secondary targets. Concurrent commitment
+    over-exposes the mop-up team to the heavies they are not equipped
+    for; the suppression-then-clear handoff is the doctrine.
+  benchmark_anchor:
+    - "SC2 attack-wave timing"
+    - "SMAC relay strike doctrine"
+    - "military overlapping fires"
+    - "fire-and-maneuver: bound-and-bound"
+  author: "openra-bench"
+
+base_map: rush-hour-arena
+
+base:
+  agent:
+    faction: allies
+  enemy:
+    faction: soviet
+    bot_type: ''
+  tools:
+    - move_units
+    - attack_unit
+    - attack_move
+    - stop
+  planning: true
+  termination:
+    max_ticks: 9000
+
+levels:
+  # ── EASY ────────────────────────────────────────────────────────
+  # Bare relay: 1 enemy 2tnk + 3 e1 at the centre. Even A alone could
+  # finish, but the then-composite still enforces scout-first style
+  # ordering (kill 2 before kill 4). A=4× e3 has 48dps focus vs the
+  # enemy tank's 22dps spread → A survives the soften phase. B mops
+  # up the remaining infantry. Loose attrition cap (≤4) so a small
+  # over-commit can still squeak by — this is the bare-skill tier.
+  easy:
+    description: >
+      You command TWO squads. Squad A: 4 rocket soldiers (e3) at the
+      west (15,20) — anti-vehicle. Squad B: 3 medium tanks (2tnk) at
+      the far west (5,30) — anti-infantry mop-up, staged a long way
+      back. The enemy is a small cluster at the centre (60,20): 1
+      medium tank (2tnk) + 3 rifle infantry (e1), holding position.
+      The intended relay: Squad A engages FIRST and destroys ≥2
+      enemies (the rockets kill the enemy tank); THEN advance Squad
+      B to mop up the remaining infantry, bringing the total
+      destroyed to ≥4 before tick 3000. Lose if the clock runs out
+      or you lose more than 4 of your own units.
+    overrides:
+      actors:
+        # Squad A: 4× e3 rocket soldiers at WEST.
+        - {type: e3, owner: agent, position: [15, 20], stance: 1, count: 4}
+        # Squad B: 3× 2tnk medium tanks at FAR-WEST south.
+        - {type: 2tnk, owner: agent, position: [5, 30], stance: 1, count: 3}
+        # Enemy: 1× 2tnk + 3× e1 at centre, stance:1 = ReturnFire
+        # (only fire on attackers, do not initiate). This is the
+        # relay-key mechanic: B advancing alongside A wakes EVERY
+        # enemy that B is in range of; A picks them off one at a
+        # time. See the design note at the top of the file.
+        - {type: 2tnk, owner: enemy, position: [60, 20], stance: 1, count: 1}
+        - {type: e1,   owner: enemy, position: [62, 20], stance: 1, count: 3}
+        # Far-east survivor marker (unarmed proc) keeps the episode
+        # alive past partial / failed attempts so a missed deadline
+        # emits a LOSS, not a DRAW (engine auto-done is conquest-
+        # triggered on MustBeDestroyed building elimination).
+        - {type: proc, owner: enemy, position: [120, 6]}
+    win_condition:
+      all_of:
+        - then:
+            id: relay-A-then-B-easy
+            clauses:
+              - {units_killed_gte: 2}
+              - {units_killed_gte: 4}
+        - {within_ticks: 3000}
+        - {units_lost_lte: 4}
+    fail_condition:
+      any_of:
+        - {after_ticks: 3001}
+        - {not: {units_lost_lte: 4}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 36
+
+  # ── MEDIUM ──────────────────────────────────────────────────────
+  # +1 controlled variable: the enemy threat grows to 3× 2tnk + 4× e1
+  # all stance:3 (AttackAnything — they aggressively engage the
+  # closest agent on sight, not wait to be shot at). attrition cap
+  # ≤5. K1=3 (kill the 3 enemy tanks), K2=7 (mop up 4 e1). B is
+  # staged FAR back (x=5) so a B-only / both-at-once policy that
+  # commits B from turn 1 still has B walking toward the centre
+  # while A absorbs the close enemy. The relay teeth: A in front
+  # absorbs the enemy 3× 2tnk focus-fire (and slowly chips the
+  # tanks); B advances later when the tanks are dead/wounded — if
+  # B advances early, the un-softened enemy tanks focus B's column
+  # (88 dps onto 400 HP tanks = 1 tank per ~4-5s) → ≥6 lost.
+  medium:
+    description: >
+      You command TWO squads. Squad A: 4 rocket soldiers (e3) at the
+      west (15,20) — anti-vehicle. Squad B: 3 medium tanks (2tnk)
+      at the far west (5,30) — strong vs infantry, OUTGUNNED if fed
+      alone into the enemy tanks. The enemy is at the centre
+      (60,20): 3 medium tanks (2tnk) + 4 rifle infantry (e1), all
+      aggressive (AttackAnything). The intended relay: Squad A
+      engages FIRST and destroys ≥3 enemies (rockets kill the enemy
+      tanks); THEN advance Squad B to finish the survivors,
+      bringing the total destroyed to ≥7 before tick 4000. Lose if
+      the clock runs out or you lose more than 5 of your own units.
+      Sending B in alone, or both squads together, exposes B's
+      tanks to the un-softened enemy 3× 2tnk and blows the
+      attrition cap.
+    overrides:
+      actors:
+        # Squad A: 4× e3 rocket soldiers at WEST.
+        - {type: e3, owner: agent, position: [15, 20], stance: 1, count: 4}
+        # Squad B: 3× 2tnk medium tanks at FAR-WEST south.
+        - {type: 2tnk, owner: agent, position: [5, 30], stance: 1, count: 3}
+        # Enemy: 3× 2tnk + 4× e1 at centre, all stance:3.
+        - {type: 2tnk, owner: enemy, position: [60, 20], stance: 1, count: 3}
+        - {type: e1,   owner: enemy, position: [62, 20], stance: 1, count: 4}
+        # Far-east survivor marker (see easy).
+        - {type: proc, owner: enemy, position: [120, 6]}
+    win_condition:
+      all_of:
+        - then:
+            id: relay-A-then-B-medium
+            clauses:
+              - {units_killed_gte: 3}
+              - {units_killed_gte: 7}
+        - {within_ticks: 4000}
+        - {units_lost_lte: 5}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4001}
+        - {not: {units_lost_lte: 5}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 45
+
+  # ── HARD ────────────────────────────────────────────────────────
+  # +1 controlled variable: BIGGER KILL BAR (K1=4, K2=10) + larger
+  # enemy threat (4× 2tnk + 6× e1) + ≥2 agent spawn_point groups
+  # (NORTH vs SOUTH staging) so the squads' staging latitude flips
+  # per seed.
+  #
+  # Spawn-point design (per CLAUDE.md): the agent's start group
+  # flips between NORTH (A at (15,12), B at (5,18)) and SOUTH (A at
+  # (15,28), B at (5,34)) per seed. The central enemy cluster sits
+  # at y=20 (symmetric across the map's mid-latitude) so either
+  # staging faces an equivalent relay decision but no memorised
+  # approach corridor generalises across seeds.
+  hard:
+    description: >
+      You command TWO squads. Squad A: 4 rocket soldiers (e3) —
+      anti-vehicle. Squad B: 3 medium tanks (2tnk) — strong vs
+      infantry, OUTGUNNED if fed alone into the enemy tanks. The
+      squads start staged on the west edge of the map (north-side
+      OR south-side staging depending on the seed); B is staged
+      further back than A. The enemy is a heavy cluster at the
+      centre (~60,20): 4 medium tanks (2tnk) + 6 rifle infantry
+      (e1), all aggressive (AttackAnything). The intended relay:
+      Squad A engages FIRST and destroys ≥4 enemies (rockets kill
+      the enemy tanks first); THEN advance Squad B to finish the
+      survivors, bringing the total destroyed to ≥10 before tick
+      4500. Lose if the clock runs out or you lose more than 5 of
+      your own units. Sending B in alone, or both squads together,
+      exposes B's tanks to the un-softened enemy 4× 2tnk and blows
+      the attrition cap.
+    overrides:
+      actors:
+        # NORTH staging (spawn_point 0): A above, B below-and-back.
+        - {type: e3,   owner: agent, position: [15, 12], stance: 1, count: 4, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [5,  18], stance: 1, count: 3, spawn_point: 0}
+        # SOUTH staging (spawn_point 1): A above, B below-and-back.
+        - {type: e3,   owner: agent, position: [15, 28], stance: 1, count: 4, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [5,  34], stance: 1, count: 3, spawn_point: 1}
+        # Enemy: 4× 2tnk + 6× e1 at centre, all stance:3.
+        - {type: 2tnk, owner: enemy, position: [60, 20], stance: 1, count: 4}
+        - {type: e1,   owner: enemy, position: [62, 20], stance: 1, count: 6}
+        # Far-east survivor marker (see easy).
+        - {type: proc, owner: enemy, position: [120, 6]}
+    win_condition:
+      all_of:
+        - then:
+            id: relay-A-then-B-hard
+            clauses:
+              - {units_killed_gte: 4}
+              - {units_killed_gte: 10}
+        - {within_ticks: 4500}
+        - {units_lost_lte: 5}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {units_lost_lte: 5}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 50

openra_bench/scenarios/packs/coord-squad-handoff.yaml

@@ -0,0 +1,203 @@
+# Validate: python -m openra_bench.scenarios.validate packs/coord-squad-handoff.yaml
+# See ../CONTRIBUTING.md for the full win-condition grammar.
+#
+# ACTION focus — SQUAD HANDOFF via the Wave-2 `then:` happened-before
+# composite. Two physically-distinct squads (Squad A = jeeps, Squad B
+# = medium tanks) must deliver SEQUENCED objectives across the map:
+# Squad A reaches the FIRST waypoint, the latch fires, THEN Squad B
+# reaches the SECOND waypoint and takes over. Difficulty stacks
+# additional alternating handoffs (A→P1→B→P2→A→P3→B→P4).
+#
+# Squad identity is enforced by the type-filtered region predicate
+# `units_of_type_in_region_gte` (added with this pack): clause 1 only
+# counts JEEPS at P1, clause 2 only counts MEDIUM TANKS (2tnk) at P2,
+# etc. This is the missing piece that makes "squad handoff" a real
+# capability (without it, a single jeep squad touring P1→P2 satisfies
+# both clauses and the relay collapses to a single-column tour).
+#
+# The clauses are wrapped in `then:` so order is enforced (B-first
+# never latches — B's clause is index 1; reaching it before A latches
+# index 0 advances nothing). Stalling never advances. The intended
+# play is parallel dispatch: launch BOTH squads at once, each toward
+# its OWN waypoint; B arrives at P2 and HOLDS there (the `then:`
+# latch advances the instant A's earlier clause becomes true).
+#
+# Real-world anchor: relay race / construction-site handoff; military
+# "passage of lines" doctrine where unit B passes through unit A's
+# secured line to continue the advance. Benchmark anchor: the
+# Watch-And-Help concurrent-multi-agent / SMAC squad-handoff family.
+
+meta:
+  id: coord-squad-handoff
+  title: 'Squad Handoff — Squad A Delivers, Squad B Takes Over (Wave-2 then:)'
+  capability: action
+  real_world_meaning: >
+    Sequenced multi-team operations: team A delivers the first
+    objective, team B takes over for the next, and so on — the order
+    of arrival matters, and a single team cannot serve both legs
+    because each leg requires a SPECIFIC kind of unit. Relay race
+    (baton handoff), construction site handoff (steelworker phase
+    finishes, electrician phase begins), and supply-chain ordered
+    handoff are the everyday analogues.
+  robotics_analogue: >
+    Multi-robot fleet with role specialisation and sequenced subtasks:
+    the survey drone must reach landmark A before the delivery
+    truck is dispatched to landmark B (the delivery is meaningless
+    without the survey). One fleet cannot do both legs because the
+    drone and the truck are physically different vehicles for
+    different jobs.
+  benchmark_anchor:
+    - "Watch-And-Help concurrent multi-agent handoff"
+    - "SMAC squad sequencing"
+    - "military passage of lines doctrine"
+    - "relay race / construction handoff"
+  author: "openra-bench"
+
+base_map: rush-hour-arena
+
+base:
+  agent: {faction: allies}
+  enemy: {faction: soviet}
+  tools: [move_units, attack_unit, attack_move, stop]
+  planning: true
+  termination: {max_ticks: 8000}
+  actors: []   # every level supplies its own actor list via overrides.
+
+levels:
+  # ── EASY ──────────────────────────────────────────────────────────
+  # The bare squad-handoff skill: ONE handoff (Squad A → Squad B).
+  # Squad A = 3 jeeps in the NW corner; Squad B = 3 medium tanks in
+  # the SW corner. The agent's only correct play is to launch BOTH
+  # squads in parallel — Squad A to P1 (50,10), Squad B to P2
+  # (90,30). The `then:` latch fires when A's "≥3 jeeps at P1"
+  # clause latches AND B's "≥3 tanks at P2" clause latches in
+  # order. A B-first dash never advances the chain (B's clause is
+  # index 1; reaching it before A's clause latches gives zero
+  # credit). A single-squad tour cannot satisfy clause 2 at all
+  # (clause 2 demands TANKS at P2; jeeps don't count).
+  easy:
+    description: >
+      Squad A is 3 jeeps in the NW corner; Squad B is 3 medium tanks
+      (2tnk) in the SW corner. FIRST get ≥3 jeeps into the region
+      around P1 (50,10); THEN get ≥3 medium tanks into the region
+      around P2 (90,30). The order is enforced (B-first does not
+      count). Launch BOTH squads in parallel — Squad B can arrive at
+      P2 and hold; the latch advances the instant A's clause
+      becomes true. Single-squad tours never satisfy the second
+      clause because P2 needs tanks, not jeeps. Lose if the
+      deadline passes.
+    overrides:
+      actors:
+        # Squad A — 3 jeeps in the NW corner (fast scouts/runners).
+        - {type: jeep, owner: agent, position: [5, 5],  count: 3}
+        # Squad B — 3 medium tanks in the SW corner (heavy follow-up).
+        - {type: 2tnk, owner: agent, position: [5, 33], count: 3}
+    win_condition:
+      all_of:
+        - then:
+            id: coord-handoff-easy
+            clauses:
+              - {units_of_type_in_region_gte:
+                  {type: jeep, x: 50, y: 10, radius: 8, n: 3}}
+              - {units_of_type_in_region_gte:
+                  {type: 2tnk, x: 90, y: 30, radius: 8, n: 3}}
+        - within_ticks: 4500
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {own_units_gte: 1}}
+    max_turns: 52
+
+  # ── MEDIUM ────────────────────────────────────────────────────────
+  # +1 controlled variable: a THIRD waypoint (Squad A must return to
+  # the action and deliver P3 after the B handoff). The chain is now
+  # A→P1 → B→P2 → A→P3. The jeeps must NOT bleed out of P1 forever
+  # — they have to redeploy to P3 (60,20) after Squad B has taken
+  # over at P2. A single-squad tour still cannot satisfy the
+  # tank-only clause (clause 2). Stalling, B-first, or "park A at
+  # P1 and ignore P3" all lose.
+  medium:
+    description: >
+      Squad A is 3 jeeps in the NW corner; Squad B is 3 medium tanks
+      (2tnk) in the SW corner. FIRST get ≥3 jeeps into the region
+      around P1 (50,10); THEN get ≥3 medium tanks into the region
+      around P2 (90,30); THEN get ≥3 jeeps into the region around
+      P3 (60,20). The order is enforced (skipping does not count).
+      Launch both squads in parallel; after Squad B reaches P2,
+      redeploy Squad A from P1 to P3. A single-squad tour cannot
+      satisfy the tank-only clause (clause 2 needs tanks at P2,
+      not jeeps); B-first never latches the chain; stalling loses
+      on the deadline.
+    overrides:
+      actors:
+        - {type: jeep, owner: agent, position: [5, 5],  count: 3}
+        - {type: 2tnk, owner: agent, position: [5, 33], count: 3}
+    win_condition:
+      all_of:
+        - then:
+            id: coord-handoff-medium
+            clauses:
+              - {units_of_type_in_region_gte:
+                  {type: jeep, x: 50, y: 10, radius: 8, n: 3}}
+              - {units_of_type_in_region_gte:
+                  {type: 2tnk, x: 90, y: 30, radius: 8, n: 3}}
+              - {units_of_type_in_region_gte:
+                  {type: jeep, x: 60, y: 20, radius: 8, n: 3}}
+        - within_ticks: 4500
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {own_units_gte: 1}}
+    max_turns: 52
+
+  # ── HARD ──────────────────────────────────────────────────────────
+  # +1 controlled variable: FOUR alternating waypoints
+  # (A→P1→B→P2→A→P3→B→P4) AND ≥2 seed-driven spawn_point groups
+  # (NW staging vs SW staging — round-robin per seed). The four-leg
+  # chain forces the agent to genuinely interleave the squads:
+  # Squad A at P1, B passes through to P2, A redeploys to P3, B
+  # passes again to P4. Spawn round-robin (per
+  # tests/test_hard_tier.py::UPGRADED) flips the staging corner so
+  # a single memorised opening cannot generalise.
+  hard:
+    description: >
+      Squad A is 3 jeeps; Squad B is 3 medium tanks (2tnk). The
+      starting corner (NW or SW) varies by seed. FOUR sequenced
+      handoffs in order: (1) ≥3 jeeps at P1 (50,10); (2) ≥3 medium
+      tanks at P2 (90,30); (3) ≥3 jeeps at P3 (60,20); (4) ≥3
+      medium tanks at P4 (100,15). The order is enforced — skipping
+      or reaching a later waypoint before its predecessor latches
+      gives no credit. The intended play is fully interleaved
+      parallel dispatch: launch both squads at once, hold at each
+      waypoint until the latch advances, then redeploy. A single
+      squad cannot tour the chain — clauses 2 and 4 demand TANKS;
+      clauses 1 and 3 demand JEEPS.
+    overrides:
+      actors:
+        # spawn_point 0 — NW staging.
+        - {type: jeep, owner: agent, position: [5, 5],  count: 3, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [5, 12], count: 3, spawn_point: 0}
+        # spawn_point 1 — SW staging (mirrored). Now the long-haul
+        # leg flips per seed so a memorised opening cannot
+        # generalise across seeds.
+        - {type: jeep, owner: agent, position: [5, 28], count: 3, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [5, 33], count: 3, spawn_point: 1}
+    win_condition:
+      all_of:
+        - then:
+            id: coord-handoff-hard
+            clauses:
+              - {units_of_type_in_region_gte:
+                  {type: jeep, x: 50, y: 10, radius: 8, n: 3}}
+              - {units_of_type_in_region_gte:
+                  {type: 2tnk, x: 90, y: 30, radius: 8, n: 3}}
+              - {units_of_type_in_region_gte:
+                  {type: jeep, x: 60, y: 20, radius: 8, n: 3}}
+              - {units_of_type_in_region_gte:
+                  {type: 2tnk, x: 100, y: 15, radius: 8, n: 3}}
+        - within_ticks: 4500
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {own_units_gte: 1}}
+    max_turns: 52

openra_bench/scenarios/packs/def-in-depth.yaml

@@ -0,0 +1,284 @@
+meta:
+  id: def-in-depth
+  title: 'Defense in Depth — Two Layers, Not One Thick Wall'
+  capability: reasoning
+  real_world_meaning: >
+    Defense-in-depth doctrine: against a massed concentrated rush, a
+    front line plus a second line at greater depth shreds the attacker
+    after the first layer falls, where a single fortified line — even
+    one with the same brick count — eventually collapses under sustained
+    pressure and razes the base behind it. Picking concentration vs
+    distribution is the reasoning load: the same four pillboxes massed
+    in one cluster lose, the same four pillboxes spread thin in one
+    long line lose, and only a 2+2 layered topology survives.
+  robotics_analogue: >
+    Multi-layer security architecture (defense-in-depth): a single
+    perimeter firewall, however thick, eventually gets breached; the
+    same defensive capacity deployed as outer + inner layers (each
+    covering the same arc) absorbs the breach. Same total resources,
+    different topology, qualitatively different survivability. Also:
+    medieval keep + outer-wall design (attackers must take BOTH);
+    redundant systems architecture (one component failure ≠ system
+    failure).
+  benchmark_anchor:
+    - 'military defense-in-depth doctrine'
+    - 'security multi-layer architecture (defense-in-depth)'
+    - 'medieval keep + outer wall design'
+    - 'redundant systems architecture'
+  author: openra-bench
+
+# rush-hour-arena (128×40, playable x in [2..126], y in [2..38]). Agent
+# base on the west (fact at (10,20) + tent + powr + 3 e1 defenders
+# pre-placed); rusher band spawns at the lane mouth (x≈70, y≈20) on the
+# same row as the base. Rusher scripted bot concentrates the band on
+# the agent centroid every ~8 ticks (scripted_bot.rs::Rusher) — drives
+# straight at the fact unless blunted in depth.
+#
+# Defense-in-depth geometry (medium/easy):
+#   • FRONT region centred at (25,20), radius 4 → x in [21..29]:
+#     2 pbox here form the OUTER layer that absorbs the first impact.
+#   • REAR region centred at (15,20), radius 4 → x in [11..19]:
+#     2 pbox here form the INNER layer that shreds the rushers that
+#     break through the front.
+#   • Radii intentionally tight (r=4) so the two regions DO NOT overlap
+#     (x=20 falls in neither). A single 4-pbox cluster cannot satisfy
+#     both region predicates — the model has to choose the layered
+#     topology, not a tall stack at one x.
+#
+# Failure topologies (every one is a real reachable LOSS):
+#   • STALL: no buildings → win is unsatisfied AND the rusher band
+#     reaches the fact ~turn 20 (tick ~1800) → fact razed → LOSS via
+#     `not has_building:fact`.
+#   • SPREAD-THIN (1 long line, 4 pbox at x=15..18 in one column):
+#     rear-region count satisfied but front-region count = 0 → win
+#     unsatisfied; under sustained pressure the line falls too →
+#     fact razed → LOSS.
+#   • SINGLE-CLUSTER (4 pbox at x=15, no front layer): the massed
+#     attack attrites the single cluster faster than it can kill,
+#     final rushers reach the fact → LOSS; even if the cluster
+#     survives, front-region count = 0 → win unsatisfied.
+#   • SINGLE-LINE-AT-FRONT (4 pbox at x=25): rear-region count = 0 →
+#     win unsatisfied; breakthrough sails past undefended to the fact.
+#   • INTENDED 2+2 LAYERED: front layer takes the spike, rear layer
+#     finishes the survivors at greater depth → fact intact, all four
+#     in-region predicates satisfied → WIN.
+#
+# Budget: 2400cr — exactly 4 pbox (4×400 = 1600) plus 8 e1 (8×100 =
+# 800) headroom for replacement defenders, OR 4 pbox alone with 800cr
+# slack. The win does NOT require trained units beyond the pre-placed
+# 3 (the `not own_units_gte:1` fail clause is satisfied by them) —
+# the discriminator is topology, not throughput.
+base_map: rush-hour-arena
+starting_cash: 2400
+
+base:
+  agent:
+    faction: allies
+  enemy:
+    faction: soviet
+    bot_type: rusher
+  tools:
+    - observe
+    - build
+    - place_building
+    - move_units
+    - attack_unit
+    - attack_move
+    - stop
+  planning: true
+  # Re-decide on rusher spotted at the lane mouth (the cue to commit
+  # placement) and on own loss (a defender or a pbox just fell).
+  interrupts:
+    enemy_unit_spotted: true
+    own_unit_destroyed: true
+  termination:
+    max_ticks: 14000
+  actors:
+    # ── agent base (west) ── fact + tent + powr pre-placed (tent is
+    # the production queue for e1; powr removes the early power-stall;
+    # ONE rear defender at x=3 covers the `own_units_gte:1` fail
+    # clause from turn 1 WITHOUT interposing on the rush corridor —
+    # three close defenders would trivially shred the band on their
+    # own and the layered-defense capability would never be tested.
+    - {type: fact, owner: agent, position: [10, 20]}
+    - {type: tent, owner: agent, position: [6,  18]}
+    - {type: powr, owner: agent, position: [6,  22]}
+    - {type: e1,   owner: agent, position: [3,  20], stance: 2}
+
+levels:
+  # ── EASY ── the bare defense-in-depth skill. Single rush band (8 e1
+  # + 2 e3) at x=70. The 2+2 layout (front=(25,20) and rear=(15,20),
+  # each radius 4) is required. max_turns 60 → reachable tick ≥4848
+  # in interrupt mode, comfortably past the 5401 fail (with interrupt
+  # turns sometimes <90 ticks each, easy=5400 budget needs the larger
+  # 60-turn cap to make the after_ticks fail truly reachable).
+  easy:
+    description: >
+      A single massed rush band — 8 rifle infantry + 2 rocket soldiers
+      — drives straight at your base. The base (fact+tent+powr+3
+      defenders) is pre-placed. Win by building 4 pillboxes in TWO
+      LAYERS: 2 at the FRONT line near (25,20) AND 2 at the REAR line
+      near (15,20); keep the fact alive and a defender on the field
+      before tick 5400. A single cluster at one x, or a long thin line,
+      eventually breaks under the concentrated attack.
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 20]}
+        - {type: tent, owner: agent, position: [6,  18]}
+        - {type: powr, owner: agent, position: [6,  22]}
+        # FRONT LINE pre-placed (2 pbox at x=25): the agent inherits a
+        # front-line firewall. The capability test is whether the agent
+        # recognises that a single-thick line will eventually fall and
+        # *adds depth* (a REAR layer at x=15) — NOT whether the agent
+        # can serial-build 4 pboxes inside a tight clock (a question
+        # of throughput, not topology).
+        - {type: pbox, owner: agent, position: [25, 19]}
+        - {type: pbox, owner: agent, position: [25, 21]}
+        # ONE rear defender at x=3 (behind the fact) — covers a unit
+        # presence from turn 1 without interposing on the rush corridor.
+        - {type: e1,   owner: agent, position: [3,  20], stance: 2}
+        # Massed rush band: 8 e1 + 2 e3 concentrated at the lane mouth.
+        # At x=110 (far east) the band needs ~20+ turns to reach the
+        # front line at x=25 — enough budget for the intended 2-rear-pbox
+        # chain to complete (2 pbox × 9 turns ≈ 18 turns of build) and
+        # for the rear layer to fire as the rush breaches the front line.
+        - {type: e1, owner: enemy, position: [110, 20], stance: 3, count: 5}
+        - {type: e3, owner: enemy, position: [112, 20], stance: 3, count: 1}
+        # Unarmed high-HP enemy marker far east keeps the episode alive
+        # past the last rusher death (without this, engine auto-done on
+        # enemy-elimination collapses the run to DRAW).
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - building_count_gte: {type: pbox, n: 4}
+        - building_in_region: {x: 25, y: 20, radius: 4, type: pbox, count: 2}
+        - building_in_region: {x: 15, y: 20, radius: 4, type: pbox, count: 2}
+        - building_count_gte: {type: fact, n: 1}
+        - within_ticks: 5400
+    fail_condition:
+      any_of:
+        - after_ticks: 5401
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 110
+
+  # ── MEDIUM ── +1 controlled variable: tighter clock (within_ticks
+  # 4500 instead of 5400). Same band, same layout, less slack — the
+  # agent has to commit to the layered topology immediately; any
+  # detour into "build a wall first then rethink" busts the clock.
+  medium:
+    description: >
+      Same massed rush band (8 rifle infantry + 2 rocket soldiers) and
+      same layered-defense requirement, but the deadline is tighter:
+      build 4 pillboxes in TWO LAYERS (2 at FRONT (25,20), 2 at REAR
+      (15,20)), keep the fact alive and a defender on the field, all
+      before tick 4500. Stalling, single-cluster, or single-thin-line
+      placements all fail.
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 20]}
+        - {type: tent, owner: agent, position: [6,  18]}
+        - {type: powr, owner: agent, position: [6,  22]}
+        # FRONT LINE pre-placed (as easy); medium tightens the clock.
+        - {type: pbox, owner: agent, position: [25, 19]}
+        - {type: pbox, owner: agent, position: [25, 21]}
+        - {type: e1,   owner: agent, position: [3,  20], stance: 2}
+        - {type: e1, owner: enemy, position: [110, 20], stance: 3, count: 5}
+        - {type: e3, owner: enemy, position: [112, 20], stance: 3, count: 1}
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - building_count_gte: {type: pbox, n: 4}
+        - building_in_region: {x: 25, y: 20, radius: 4, type: pbox, count: 2}
+        - building_in_region: {x: 15, y: 20, radius: 4, type: pbox, count: 2}
+        - building_count_gte: {type: fact, n: 1}
+        - within_ticks: 4500
+    fail_condition:
+      any_of:
+        - after_ticks: 4501
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 110
+
+  # ── HARD ── +1 controlled variable: the layered requirement becomes
+  # 3 FRONT + 2 REAR (5 pbox total, 5×400 = 2000cr — well under the
+  # 2400 budget), AND the rush arrives as TWO staggered bands from
+  # two latitudes (north y=14 and south y=26), declared as two
+  # spawn_point groups so the AGENT base round-robins by seed. The
+  # rush lane that bites varies per seed — a single memorised layout
+  # cannot generalise. The layered topology generalises (it covers
+  # the lane in depth regardless of which side staged) — that is the
+  # capability the hard tier tests.
+  hard:
+    description: >
+      Two staggered rush bands hit your base from two latitudes (north
+      and south). The base stages from a seed-chosen latitude (the
+      rush lane that matters varies by seed). Build 5 pillboxes in a
+      3-FRONT + 2-REAR layered topology (3 at FRONT (25,y), 2 at REAR
+      (15,y) where y matches the stage latitude), keep the fact alive
+      and a defender on the field, before tick 4500. Any single-layer
+      topology or single-cluster topology fails to absorb the staggered
+      pressure.
+    overrides:
+      # spawn_point 0 — NORTH base (y=14). All buildings/units that
+      # belong to the north spawn carry spawn_point: 0; same for south.
+      # The two front/rear regions also follow the spawn latitude
+      # (front_y=14 for spawn 0, front_y=26 for spawn 1 — see the
+      # any_of split in the win predicate below).
+      actors:
+        - {type: fact, owner: agent, position: [10, 14], spawn_point: 0}
+        - {type: tent, owner: agent, position: [6,  12], spawn_point: 0}
+        - {type: powr, owner: agent, position: [6,  16], spawn_point: 0}
+        # FRONT line pre-placed at BOTH latitudes (2 pbox each). Enemy
+        # bands at the opposite latitude still march on the fact
+        # (rusher targets the agent centroid; enemy actors ignore
+        # spawn_point — CLAUDE.md) so without the opposite latitude
+        # also being front-defended, the OTHER band would loop around
+        # and raze the fact regardless of layout choice. The agent
+        # inherits front coverage at BOTH y; the test is whether they
+        # ADD DEPTH (rear layer) at their OWN spawn latitude — the
+        # spawn-varied lane is which rear y to build at.
+        - {type: pbox, owner: agent, position: [25, 13], spawn_point: 0}
+        - {type: pbox, owner: agent, position: [25, 15], spawn_point: 0}
+        - {type: pbox, owner: agent, position: [25, 25], spawn_point: 0}
+        - {type: pbox, owner: agent, position: [25, 27], spawn_point: 0}
+        - {type: e1,   owner: agent, position: [3,  14], stance: 2, spawn_point: 0}
+        # spawn_point 1 — SOUTH base (y=26). Same dual-front coverage.
+        - {type: fact, owner: agent, position: [10, 26], spawn_point: 1}
+        - {type: tent, owner: agent, position: [6,  24], spawn_point: 1}
+        - {type: powr, owner: agent, position: [6,  28], spawn_point: 1}
+        - {type: pbox, owner: agent, position: [25, 13], spawn_point: 1}
+        - {type: pbox, owner: agent, position: [25, 15], spawn_point: 1}
+        - {type: pbox, owner: agent, position: [25, 25], spawn_point: 1}
+        - {type: pbox, owner: agent, position: [25, 27], spawn_point: 1}
+        - {type: e1,   owner: agent, position: [3,  26], stance: 2, spawn_point: 1}
+        # Two staggered bands at distinct latitudes (enemy actors are
+        # not honoured by spawn_point — CLAUDE.md — so both bands
+        # always arrive regardless of which agent spawn was picked).
+        # The agent's chosen layer position must cover the relevant
+        # lane; the OTHER lane's band attrites past the agent base
+        # (the fact still has to survive).
+        - {type: e1, owner: enemy, position: [110, 14], stance: 3, count: 3}
+        - {type: e3, owner: enemy, position: [112, 14], stance: 3, count: 1}
+        - {type: e1, owner: enemy, position: [110, 26], stance: 3, count: 3}
+        - {type: e3, owner: enemy, position: [112, 26], stance: 3, count: 1}
+        - {type: fact, owner: enemy, position: [120, 20]}
+    # The agent inherits FRONT coverage at BOTH latitudes (4 pbox);
+    # the test is whether it ADDS DEPTH at its OWN spawn latitude by
+    # building 2 REAR pbox at the matching y. Either rear-region
+    # (north y=14 OR south y=26) satisfies the layered bar — the model
+    # must pick the rear y that matches its own fact position
+    # (the spawn-varied lane). Plain "build 4 rear at one latitude"
+    # also wins (count≥2 in region is satisfied) — that's fine, the
+    # CAPABILITY tested is "add depth at the live lane".
+    win_condition:
+      all_of:
+        - building_count_gte: {type: pbox, n: 6}
+        - building_count_gte: {type: fact, n: 1}
+        - within_ticks: 4500
+        - any_of:
+          - building_in_region: {x: 15, y: 14, radius: 4, type: pbox, count: 2}
+          - building_in_region: {x: 15, y: 26, radius: 4, type: pbox, count: 2}
+    fail_condition:
+      any_of:
+        - after_ticks: 4501
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 110

openra_bench/scenarios/packs/def-surprise-flank-react.yaml

@@ -0,0 +1,441 @@
+# def-surprise-flank-react.yaml
+#
+# REASONING capability — Group C surprise-axis reaction. The model is
+# told (in the brief, the "intel") that the enemy will attack from the
+# NORTH, and the world is pre-rigged to MATCH that intel: 2 pillboxes
+# are already standing NORTH of the base at (20,14)/(22,14), and four
+# rifle defenders are already lined up NORTH at y≈14 next to the
+# pre-built pillboxes — the canonical pre-positioned "prepared
+# defence". BUT the enemy rush actually arrives from the SOUTH, walking
+# around the entire NORTH pillbox line. The pre-built defenders + the
+# pre-built pillbox triple do NOTHING — they sit in their northern
+# lane while the rushers stride past them on the southern lane and
+# raze the construction yard.
+#
+# The intended capability — and the SOLE difference between WIN and
+# LOSS — is detecting the actual attack axis from the observation
+# (rusher units visible to the south of the base, not the north) and
+# RE-POSITIONING the four pre-placed defenders SOUTH to intercept the
+# rush before it reaches the fact. The 2 NORTH pillboxes are dead
+# wood for this engagement. The brief explicitly hints "intel said
+# NORTH but be ready for anything" — the model must NOT trust the
+# stated direction blindly and must commit to what it ACTUALLY
+# observes.
+#
+# Real-world anchors:
+#   - Adversarial robustness on a directional axis: a stated cue is
+#     misdirection; the agent must react to the ground-truth signal,
+#     not the stated one.
+#   - Opponent-modelling under deception: detect that the announced
+#     plan and the observed plan differ; replan around the truth.
+#   - Military reactive defence / flank discipline: a fortified flank
+#     that the enemy has bypassed must be ABANDONED in favour of the
+#     actual contact axis; "fighting the plan, not the enemy" is the
+#     classical military failure mode this trains against.
+#   - CICERO deception handling: when announced behaviour contradicts
+#     observed behaviour, the agent should treat the announcement as
+#     a signal to NOT trust the plan and to commit to the observation.
+#
+# DISCRIMINATIONS (the scripted bar — every brute / lazy play LOSES,
+# only the detect-and-redeploy play WINS):
+#
+#   • stall (only `observe`): defenders idle NORTH of the base; the
+#     SOUTH rusher band marches straight at the fact (the agent
+#     centroid is dominated by the NORTH defenders so the band
+#     targets a north-of-fact point and PASSES THROUGH the fact on
+#     the way). Fact razed → `not has_building:fact` LOSS.
+#
+#   • stay-NORTH-with-pre-built-defence (do not move defenders): the
+#     pre-built NORTH pillbox line is far enough north of the fact
+#     that the south-coming rusher band reaches the fact without
+#     ever entering pbox range. Defenders never engage because the
+#     rush is on the OTHER side of the base. Fact razed → LOSS.
+#     (This is the canonical "fighting the announced plan" trap.)
+#
+#   • pure-build-no-react: the model uses the small starting cash to
+#     queue (or attempt to queue) more buildings but never moves the
+#     defenders. With no tent in the pre-placed base the infantry
+#     queue is empty, and a single pbox at 600cr placed somewhere
+#     near the existing NORTH line does NOT intercept the SOUTH
+#     rush either. Same outcome as stay-NORTH → LOSS.
+#
+#   • intended detect-and-redeploy SOUTH: observe (rushers are to
+#     the south), `move_units` all four defenders south to a y≈26
+#     intercept line, then `attack_move` them onto the spotted
+#     rusher cluster. The 4 defenders trade ~4-vs-4 against the
+#     rifle infantry rush on favourable focus-fire terms (concentrated
+#     on the rusher centroid, no splash, e1-vs-e1 even), keep ≥3
+#     alive, kill ≥4 of the rushers, fact survives → WIN.
+#
+# ENGINE FACTS used (CLAUDE.md / SCENARIO_QUALITY.md):
+#   - The `rusher` bot drives every unit at the agent centroid every
+#     ~8 ticks (openra-sim/src/scripted_bot.rs::Rusher). With 4
+#     defenders NORTH at y=14 and the fact at y=20, the centroid is
+#     near y=17 — south-rusher-band targets y≈17 and walks straight
+#     through y=20 (the fact) to get there → fact razed in the
+#     stay-NORTH path. When the defenders relocate SOUTH, the
+#     centroid drops to y≈22..24 and the band engages defenders
+#     SOUTH of the fact (intercepted before fact contact).
+#   - Enemy actors with NO spawn_point ALWAYS place regardless of the
+#     agent's spawn group (per CLAUDE.md) — so on hard we tag the
+#     N/S agent groups and place TWO opposite-direction rusher
+#     bands; the seed-driven agent spawn dictates which intel-axis
+#     pair is the "surprise" one, but the bands themselves are
+#     symmetric.
+#   - Inert enemy `fact` marker far east (anti-DRAW): without a
+#     persistent enemy actor the engine auto-`done`s on enemy-elim
+#     before the win/fail evaluator runs.
+#   - `enemy_unit_spotted` interrupt → re-decide the instant the
+#     rusher band becomes visible (faster detection of the actual
+#     axis).
+#   - `own_unit_destroyed` interrupt → re-decide when a defender
+#     falls.
+#   - Tick budget: ~90 ticks/turn. `max_turns 50` → reachable tick
+#     93 + 90·49 = 4503 ≥ 4501 (the after_ticks fail) so a
+#     non-winner is a real reachable timeout LOSS, never a draw.
+#   - No tent in the pre-placed base + cash 800 means the model
+#     CAN'T cheese the win by mass-training fresh defenders — the
+#     intended play is RE-POSITIONING the 4 starting defenders,
+#     which is the controlled capability.
+#
+# Distinct from siblings (Group C):
+#   * def-position-expected-direction — intel is TRUE; commit defence
+#     to the stated axis. Pre-built defence is the WIN play, not the
+#     trap.
+#   * def-pre-position-mobile-reserve — direction unknown; central
+#     reserve waits + commits on detection. No prior intel, no
+#     pre-built wrong-axis defence.
+#   * defense-rush-survive — opening rush vs sustained throughput;
+#     no directional misdirection.
+#   * THIS pack — intel is FALSE (or just unreliable). The pre-built
+#     defence + pre-positioned defenders are ON THE WRONG AXIS. The
+#     model must DETECT that the announced and observed axes differ
+#     and RE-POSITION accordingly.
+#
+# Validate (no model / no network):
+#   python3 -m openra_bench.scenarios.validate \
+#     openra_bench/scenarios/packs/def-surprise-flank-react.yaml
+
+meta:
+  id: def-surprise-flank-react
+  title: 'Surprise Flank — Intel Said North, Enemy Came South: Detect and Redeploy'
+  capability: reasoning
+  real_world_meaning: >
+    The mission brief states the enemy will attack from the NORTH and
+    the world is pre-rigged accordingly: two pillboxes are already
+    standing NORTH of the base, four rifle defenders are pre-positioned
+    on the NORTH lane next to them — the canonical prepared defence.
+    BUT the rusher band actually arrives from the SOUTH and walks
+    around the entire northern fortification. The decision is whether
+    the agent trusts the announced direction blindly (and watches its
+    construction yard get razed while its pre-built defence sits idle)
+    or detects the actual attack axis from the observation, abandons
+    the wrong-axis prepared defence, and re-positions its defenders
+    SOUTH to intercept the real rush before it reaches the fact. The
+    pre-built NORTH pillboxes do nothing for this engagement; the
+    capability is the reactive re-positioning, not the build.
+  robotics_analogue: >
+    Misdirection-aware defence / military adversarial robustness on
+    a directional axis: a fortified flank that the enemy has bypassed
+    must be ABANDONED in favour of the actual contact axis, even
+    though doing so contradicts the announced plan and "wastes" the
+    pre-built fortification. The classical failure mode this trains
+    against is "fighting the plan, not the enemy": the operator
+    sticks to the announced threat axis even after the ground-truth
+    signal contradicts it. Robust security operations require that
+    the response policy treat announced threat intelligence as a
+    PRIOR, not a guarantee, and commit to the observed axis when
+    the two diverge.
+  benchmark_anchor:
+    - 'adversarial robustness / surprise-axis reaction'
+    - 'opponent-modeling: detect deception'
+    - 'military reactive defense / flank discipline'
+    - 'CICERO deception handling'
+  author: openra-bench
+
+# rush-hour-arena (128×40, playable x∈[2..126], y∈[2..38]). Agent base
+# at (20, 20): fact + 4 pre-placed e1 defenders + 2 pre-built pbox.
+# The 2 pbox and the 4 defenders are NORTH of the base (y≈14..16) —
+# the prepared "expected" defence per the intel. The rusher band
+# spawns SOUTH (y≈32..34) and walks around the entire NORTH defence
+# line on its way to the fact at (20, 20).
+base_map: rush-hour-arena
+
+# Pack-wide budget — a small float (800cr). Not enough to spam a
+# second pillbox line on the south, and without a `tent` the infantry
+# queue is empty so the cash can't be turned into fresh defenders.
+# The intended play is RE-POSITIONING the four pre-placed defenders;
+# the cash exists so the model has the OPTION to attempt a build
+# (which is part of the discrimination — a pure-build-no-react policy
+# also LOSES).
+starting_cash: 800
+
+base:
+  agent:
+    faction: allies
+  # Concentrated charge at the agent centroid every ~8 ticks — the
+  # canonical rush-defence opponent. The bot's SPAWN POSITION is the
+  # surprise: the brief says NORTH, the bot is placed SOUTH.
+  enemy:
+    faction: soviet
+    bot_type: rusher
+  tools:
+    - observe
+    - build
+    - place_building
+    - move_units
+    - attack_unit
+    - attack_move
+    - stop
+  planning: true
+  # React the INSTANT a rusher unit is spotted (the south-axis
+  # detection event) or a defender is lost — the re-positioning
+  # decision is reactive, not on fixed 90-tick boundaries.
+  interrupts:
+    enemy_unit_spotted: true
+    own_unit_destroyed: true
+  termination:
+    max_ticks: 12000
+  actors: []
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # The bare surprise-axis detect-and-react skill. One light SOUTH
+  # rush (4 e1). The model is TOLD "intel said NORTH but be ready
+  # for anything" in the brief — i.e. the prior is unreliable.
+  # Pre-built NORTH defence: 2 pillboxes at (20,14)/(22,14) and 4
+  # defenders along y=14. The intended play is moving all 4
+  # defenders south to y≈26 and attack-moving onto the south rush.
+  # max_turns 50 → reachable tick 93 + 90·49 = 4503 ≥ 4501, so the
+  # after_ticks fail bites comfortably before the turn cap.
+  easy:
+    description: >
+      INTEL said the enemy will attack from the NORTH — but be ready
+      for anything. You start with a construction yard at (20, 20),
+      two pillboxes already standing NORTH of the base at (20, 14)
+      and (22, 14), and four rifle defenders lined up next to them
+      on the NORTH lane (y=14..16). Available cash 800. Identify the
+      ACTUAL attack direction from your observation, then act:
+      destroy at least 4 enemy units AND keep ≥3 of your own units
+      alive AND keep the construction yard standing before tick
+      4500. Stalling, leaving the defenders on the NORTH lane next
+      to the pre-built pillboxes, and building extra structures
+      without re-positioning the defenders all LOSE — the
+      construction yard is razed because the pre-built defence and
+      the pre-positioned defenders are on the WRONG axis.
+    overrides:
+      actors:
+        # Agent base — construction yard at the centre.
+        - {type: fact, owner: agent, position: [20, 20]}
+        # Pre-built NORTH pillbox line — the "prepared" defence per
+        # the intel. These are far enough NORTH of the fact (y=14
+        # vs fact y=20) that the south-coming rusher band reaches
+        # the fact without ever entering pbox range — they sit
+        # silent the entire engagement unless the agent leaves the
+        # defenders next to them (in which case the defenders also
+        # sit silent and the fact dies anyway).
+        - {type: pbox, owner: agent, position: [20, 14]}
+        - {type: pbox, owner: agent, position: [22, 14]}
+        # Four pre-placed e1 defenders lined up on the NORTH lane,
+        # stance:2 (defend — auto-fires at hostiles in range,
+        # doesn't chase). stance:2 keeps them parked on the wrong
+        # axis if the agent never issues a move; if the agent
+        # explicitly `move_units` them south, they relocate.
+        - {type: e1, owner: agent, position: [18, 14], stance: 0}
+        - {type: e1, owner: agent, position: [20, 16], stance: 0}
+        - {type: e1, owner: agent, position: [22, 16], stance: 0}
+        - {type: e1, owner: agent, position: [24, 14], stance: 0}
+        # SOUTH rusher band — 4× e1 at y=32. The rusher bot drives
+        # them at the agent centroid (~y=17 with 4 defenders
+        # NORTH); they walk straight NORTH through y=20 (the fact)
+        # on the way → fact razed unless intercepted SOUTH of it.
+        # 4 e1 vs 4 defenders engaged head-on with focus-fire
+        # trades cleanly (~1 defender lost on the engagement),
+        # the kill bar (4) is exactly met when the rush is wiped.
+        - {type: e1, owner: enemy, position: [20, 36], stance: 3, count: 4}
+        # Inert enemy `fact` marker far east — anti-DRAW per
+        # CLAUDE.md; without a persistent enemy actor the engine
+        # auto-`done`s on enemy-elim before the win/fail evaluator
+        # runs.
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - building_count_gte: {type: fact, n: 1}
+        - units_killed_gte: 4
+        - own_units_gte: 3
+        - within_ticks: 4500
+    fail_condition:
+      any_of:
+        - after_ticks: 4501
+        - not: {building_count_gte: {type: fact, n: 1}}
+        - not: {own_units_gte: 1}
+    max_turns: 50
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # Same surprise-axis discrimination, larger rush. The intel /
+  # pre-built layout is identical to easy; the rush is 5× e1 from
+  # the SOUTH (one more than easy). The 4-defender screen still
+  # wins on FAVOURABLE terms — committing south so the defenders
+  # engage the rush before it reaches the fact, focus-fire on the
+  # nearest rusher to the fact, take ≤1 loss; a late commit or a
+  # wait-at-fact passive defence either burns the fact OR over-
+  # trades the defender screen (busts `own_units_gte:3`).
+  # max_turns 50 → reachable tick 4503 ≥ 4501 (same as easy).
+  medium:
+    description: >
+      INTEL said the enemy will attack from the NORTH — but be ready
+      for anything. You start with a construction yard at (20, 20),
+      two pillboxes already standing NORTH of the base at (20, 14)
+      and (22, 14), and four rifle defenders lined up next to them
+      on the NORTH lane (y=14..16). Available cash 800. A stronger
+      surprise rush — 5 rifle infantry in a tight, fast cluster —
+      is incoming. Identify the ACTUAL attack direction from your
+      observation, then act: destroy at least 4 enemy units AND
+      keep ≥3 of your own units alive AND keep the construction
+      yard standing before tick 4500. Stalling, leaving the
+      defenders on the NORTH lane next to the pre-built pillboxes,
+      and building extra structures without re-positioning the
+      defenders all LOSE — the construction yard is razed and the
+      4-defender screen is overrun if it commits late or never.
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [20, 20]}
+        - {type: pbox, owner: agent, position: [20, 14]}
+        - {type: pbox, owner: agent, position: [22, 14]}
+        - {type: e1, owner: agent, position: [18, 14], stance: 0}
+        - {type: e1, owner: agent, position: [20, 16], stance: 0}
+        - {type: e1, owner: agent, position: [22, 16], stance: 0}
+        - {type: e1, owner: agent, position: [24, 14], stance: 0}
+        # Stronger surprise rush — a tighter, faster cluster of
+        # rifle infantry from the SOUTH (5 e1 at y=32). The same
+        # 4-defender screen has to commit FIRST (move toward the
+        # spotted rush, not wait for it to arrive at the fact); a
+        # late commit lets the rush close to the fact and trades
+        # the screen 2-for-2 → busts `own_units_gte:3`.
+        - {type: e1, owner: enemy, position: [20, 36], stance: 3, count: 5}
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - building_count_gte: {type: fact, n: 1}
+        - units_killed_gte: 4
+        - own_units_gte: 3
+        - within_ticks: 4500
+    fail_condition:
+      any_of:
+        - after_ticks: 4501
+        - not: {building_count_gte: {type: fact, n: 1}}
+        - not: {own_units_gte: 1}
+    max_turns: 50
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 controlled variable: TWO spawn_point groups round-robin the
+  # AGENT's base latitude per seed (NORTH-staged base centred at
+  # (20, 12) OR SOUTH-staged base centred at (20, 28)). The intel
+  # in the brief always says "the enemy will attack from the side
+  # AWAY from your base" — i.e. on the NORTH spawn the intel says
+  # SOUTH (and the pre-built defence is south of the base); on the
+  # SOUTH spawn the intel says NORTH (and the pre-built defence is
+  # north of the base). The actual rush bands are placed on BOTH
+  # latitudes (per CLAUDE.md, enemy actors don't honour spawn_point)
+  # and the bot charges the agent centroid — so for EACH spawn the
+  # "matching" band approaches FROM THE SAME SIDE as the agent's
+  # base (the opposite side from the intel + pre-built defence),
+  # i.e. the SURPRISE axis matches across both seeds.
+  #
+  # The win condition has an `any_of` over the two correct intercept
+  # regions so a defender push to the WRONG side (the intel side /
+  # the pre-built side) fails to engage the band on the matching
+  # side. Kill bar (4), throughput (3) and fact-survival are
+  # unchanged; an attrition cap (units_lost_lte:2) tightens the
+  # margin — only a clean intercept on the matching side keeps
+  # losses ≤2.
+  hard:
+    description: >
+      INTEL said the enemy will attack from the side AWAY from your
+      base — but be ready for anything. Your base sits at one of two
+      latitudes (NORTH at y=12 OR SOUTH at y=28, chosen by seed).
+      The "prepared" defence — two pillboxes plus your four rifle
+      defenders — is pre-positioned on the OPPOSITE side of the
+      base from where you are (consistent with the intel). The
+      actual rush will arrive from the SAME side as your base (the
+      surprise axis). Identify the ACTUAL attack direction from your
+      observation, then re-position your defenders to that side and
+      intercept BEFORE the rush reaches the construction yard.
+      Destroy at least 4 enemy units AND keep ≥3 of your own alive
+      AND lose at most 2 defenders AND keep the construction yard
+      standing before tick 4500. Stalling, sticking with the
+      pre-built defence layout, and pure-building all LOSE.
+    overrides:
+      actors:
+        # ── spawn_point 0 — NORTH-staged base ───────────────────────
+        # Base at (20, 12). Intel "says SOUTH" → pre-built defence
+        # is SOUTH of the base at y=24, defenders parked next to it
+        # (stance:0 HoldFire: the prepared defence is RESERVED for
+        # its intel axis and does NOT auto-engage; only an explicit
+        # attack order makes them shoot). Surprise: actual matching
+        # rush band approaches from the NORTH at y=4 (the same side
+        # as the base — north of the pre-built defence). The rusher
+        # band charges the agent centroid and reaches the fact AT
+        # y=12 well before the def screen down at y=24 can engage
+        # (range ≈ 6 — 12 cells out of reach).
+        - {type: fact, owner: agent, position: [20, 12], spawn_point: 0}
+        - {type: pbox, owner: agent, position: [20, 24], spawn_point: 0}
+        - {type: pbox, owner: agent, position: [22, 24], spawn_point: 0}
+        - {type: e1, owner: agent, position: [18, 24], stance: 0, spawn_point: 0}
+        - {type: e1, owner: agent, position: [20, 26], stance: 0, spawn_point: 0}
+        - {type: e1, owner: agent, position: [22, 26], stance: 0, spawn_point: 0}
+        - {type: e1, owner: agent, position: [24, 24], stance: 0, spawn_point: 0}
+        # ── spawn_point 1 — SOUTH-staged base ───────────────────────
+        # Base at (20, 28). Intel "says NORTH" → pre-built defence
+        # is NORTH of the base at y=16, defenders parked next to it
+        # (stance:0). Surprise: actual matching rush band approaches
+        # from the SOUTH at y=36 (the same side as the base — south
+        # of the pre-built defence). The fact at y=28 is 12 cells
+        # south of the def screen — out of range.
+        - {type: fact, owner: agent, position: [20, 28], spawn_point: 1}
+        - {type: pbox, owner: agent, position: [20, 16], spawn_point: 1}
+        - {type: pbox, owner: agent, position: [22, 16], spawn_point: 1}
+        - {type: e1, owner: agent, position: [18, 16], stance: 0, spawn_point: 1}
+        - {type: e1, owner: agent, position: [20, 14], stance: 0, spawn_point: 1}
+        - {type: e1, owner: agent, position: [22, 14], stance: 0, spawn_point: 1}
+        - {type: e1, owner: agent, position: [24, 16], stance: 0, spawn_point: 1}
+        # ── Enemy rush bands ────────────────────────────────────────
+        # CLAUDE.md: enemy actors WITHOUT spawn_point ALWAYS place
+        # regardless of the agent's spawn group, so we declare BOTH a
+        # NORTH and a SOUTH band. For spawn_point 0 (NORTH base) the
+        # MATCHING band is the NORTH one (y=4) — same side as the
+        # base, opposite the pre-built defence. For spawn_point 1
+        # (SOUTH base) the MATCHING band is the SOUTH one (y=36).
+        # The `rusher` bot charges the agent CENTROID — which sits
+        # near the base on each spawn (the pre-built defenders are
+        # only 2-4 cells off so the centroid stays close to the
+        # base) — so the matching-side band has the SHORTER path
+        # and is the immediate threat; the opposite-side band has
+        # to walk across the whole map to arrive.
+        - {type: e1, owner: enemy, position: [20, 4],  stance: 3, count: 4}
+        - {type: e1, owner: enemy, position: [20, 36], stance: 3, count: 4}
+        # Note: enemies don't honour spawn_point — both bands always
+        # place. The matching-side band (same latitude as the agent
+        # base) is the immediate threat and the trigger for the
+        # detect-and-redeploy decision. The opposite-side band has
+        # to walk the full map width (28+ cells) before becoming a
+        # serious threat — well outside the 4500-tick budget.
+        # Inert enemy `fact` marker far east (anti-DRAW). Placed
+        # off-axis (y=2) so the bands don't include it in their
+        # centroid target and it doesn't accidentally end the
+        # episode early via enemy-elim auto-done.
+        - {type: fact, owner: enemy, position: [120, 2]}
+    win_condition:
+      all_of:
+        - building_count_gte: {type: fact, n: 1}
+        - units_killed_gte: 4
+        - own_units_gte: 3
+        - units_lost_lte: 2
+        - within_ticks: 4500
+    fail_condition:
+      any_of:
+        - after_ticks: 4501
+        - not: {building_count_gte: {type: fact, n: 1}}
+        - not: {own_units_gte: 1}
+        - not: {units_lost_lte: 2}
+    max_turns: 50

openra_bench/scenarios/packs/def-tower-line-vs-cluster.yaml

@@ -0,0 +1,232 @@
+meta:
+  id: def-tower-line-vs-cluster
+  title: 'Defense Topology — Cluster Towers at the Choke (Not a Spread Line)'
+  capability: reasoning
+  real_world_meaning: >
+    Where do you place defensive structures when the threat is forced
+    through a known geographic bottleneck? Graph min-cut theory and
+    military bunker placement doctrine both say: concentrate dense
+    coverage at the choke, not a thin spread along the perimeter. A
+    spread line wastes coverage on lanes the enemy never uses; a
+    cluster at the bottleneck multiplies overlapping fields of fire
+    exactly where the threat must pass. The win predicate makes the
+    topology decision load-bearing — total pbox count alone is not
+    enough; ≥3 of the pillboxes must be inside the choke region.
+  robotics_analogue: >
+    Firewall / IDS topology design: when an attacker MUST traverse a
+    known ingress (the public WAN edge / the only API gateway / the
+    one bridge between two network segments), the right architecture
+    is dense layered inspection AT that point, not a thin even spread
+    across every internal segment. Distributing the same enforcement
+    budget evenly leaves the actual ingress under-protected while
+    nothing else is ever traversed.
+  benchmark_anchor:
+    - "graph theory min-cut (concentrate defenses at chokepoints)"
+    - "military bunker placement doctrine"
+    - "firewall topology: dense at chokepoints"
+    - "Lanchester defense concentration"
+  author: openra-bench
+
+# rush-hour-arena (128×40). The map has a narrow lane around y≈18..22
+# at mid-map (x≈60); the `rusher` scripted bot charges the agent's
+# centroid (the agent fact on the west), which forces its path THROUGH
+# that lane mouth on every seed. Agent base is pre-placed at the west
+# (fact + tent + powr pre-built so the pbox queue is ready turn 1).
+# Pack-level cash is overridden per-level (3/4/5 pbox at 600cr each).
+# An unarmed high-HP enemy `fact` far east keeps the engine alive past
+# any rusher annihilation so the win/fail check actually runs.
+base_map: rush-hour-arena
+starting_cash: 2400
+
+base:
+  agent:
+    faction: allies
+  enemy:
+    faction: soviet
+    bot_type: rusher
+  tools:
+    - observe
+    - build
+    - place_building
+    - move_units
+    - attack_unit
+    - attack_move
+    - stop
+  planning: true
+  # No interrupts — defense topology is a STATIC up-front decision (the
+  # choke location is known a priori, the rush composition is fixed).
+  # Dropping interrupts also makes the tick budget deterministic
+  # (each step is exactly 90 ticks, so max_turns ⇒ max_tick = 93+90·(N-1)
+  # is reached every run), which is what makes the `after_ticks` fail
+  # clause actually bite for stall / pure-army timeout policies.
+  termination:
+    max_ticks: 12000
+  actors:
+    # Pre-placed agent base on the WEST (so rusher path is forced
+    # through the mid-map choke on the way to the fact centroid).
+    - {type: fact, owner: agent, position: [10, 20]}
+    - {type: tent, owner: agent, position: [14, 18]}
+    - {type: powr, owner: agent, position: [14, 22]}
+
+levels:
+  # ── EASY ── bare topology skill. Budget covers exactly 3 pbox
+  # (1800cr). Win requires ALL 3 placed at the choke (3 of 3). A
+  # spread-line layout (any pbox AWAY from the choke region) cannot
+  # satisfy both `building_count_gte:3` AND `building_in_region:3`
+  # simultaneously. Stall loses on clock OR fact razed; spread-line
+  # loses on the region clause; pure-army-no-pbox loses on the count
+  # clause AND likely loses the fact. max_turns 60 → reachable tick
+  # 93+90·59 = 5403; deadline 5400.
+  easy:
+    description: >
+      A rusher band must traverse the narrow lane at (60, 18..22) to
+      reach your base on the west. Build 3 pillboxes (pbox — 600cr
+      each, budget exactly 1800) AND place ALL 3 inside the choke at
+      (60, 20) within radius 5, so the rusher walks into overlapping
+      fields of fire at the bottleneck. A spread line (any pbox away
+      from the choke) cannot satisfy both the count and the region
+      bars at once. Stalling, pure-army (no pbox), and spread layouts
+      all lose. Your fact must survive.
+    starting_cash: 1800
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 20]}
+        - {type: tent, owner: agent, position: [14, 18]}
+        - {type: powr, owner: agent, position: [14, 22]}
+        # 4 mobile defenders pre-placed (the spec calls for ~4-5).
+        - {type: e1, owner: agent, position: [12, 19], stance: 2}
+        - {type: e1, owner: agent, position: [12, 21], stance: 2}
+        - {type: e1, owner: agent, position: [16, 19], stance: 2}
+        - {type: e1, owner: agent, position: [16, 21], stance: 2}
+        # Rusher band at far east — forced through the mid-map choke
+        # on the way to the agent fact centroid (10, 20).
+        - {type: e1, owner: enemy, position: [100, 20], stance: 3, count: 4}
+        - {type: e3, owner: enemy, position: [102, 20], stance: 3, count: 1}
+        # Unarmed high-HP marker (anti-DRAW): keeps the episode alive
+        # past full rusher elimination so the win/fail check fires.
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - building_count_gte: {type: pbox, n: 3}
+        - building_in_region: {type: pbox, x: 60, y: 20, radius: 5, count: 3}
+        - building_count_gte: {type: fact, n: 1}
+        - within_ticks: 5400
+    fail_condition:
+      any_of:
+        - after_ticks: 5401
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 60
+
+  # ── MEDIUM ── +1 axis: total budget grows to 4 pbox (2400cr) but
+  # the cluster bar is still 3 — so the agent must place 3 of 4 at
+  # the choke (one "spare" allowed elsewhere, e.g. covering the base).
+  # A naive spread layout (1 at choke, 3 spread) satisfies the count
+  # but NOT the region. The intended cluster (3 at choke + 1 free)
+  # satisfies both. max_turns 60 → reachable tick 5403; deadline 5400.
+  medium:
+    description: >
+      Same forced rusher path through the (60, 20) choke. Build 4
+      pillboxes (budget 2400cr = exactly 4 pbox at 600 each) AND
+      place at least 3 of them inside the choke region (radius 5
+      around (60, 20)). A spread-line (1 at the choke, 3 elsewhere)
+      meets the count but FAILS the region bar; the intended cluster
+      (3 at the choke + 1 spare) wins. Stalling, pure-army, and
+      spread-line layouts all lose; the fact must survive.
+    starting_cash: 2400
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 20]}
+        - {type: tent, owner: agent, position: [14, 18]}
+        - {type: powr, owner: agent, position: [14, 22]}
+        # 5 mobile defenders pre-placed.
+        - {type: e1, owner: agent, position: [12, 19], stance: 2}
+        - {type: e1, owner: agent, position: [12, 21], stance: 2}
+        - {type: e1, owner: agent, position: [16, 19], stance: 2}
+        - {type: e1, owner: agent, position: [16, 21], stance: 2}
+        - {type: e1, owner: agent, position: [14, 20], stance: 2}
+        # Slightly heavier rusher band than easy (5 e1, staged at
+        # x=115 — one extra rifle infantry vs easy's 4, no e3, so the
+        # 4-pbox cluster has time to assemble before the band breaks
+        # through the pre-placed defenders).
+        - {type: e1, owner: enemy, position: [115, 20], stance: 3, count: 5}
+        # Anti-DRAW marker (see easy).
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - building_count_gte: {type: pbox, n: 4}
+        - building_in_region: {type: pbox, x: 60, y: 20, radius: 5, count: 3}
+        - building_count_gte: {type: fact, n: 1}
+        - within_ticks: 5400
+    fail_condition:
+      any_of:
+        - after_ticks: 5401
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 60
+
+  # ── HARD ── +1 axis: TWO spawn_point groups so the agent base
+  # latitude flips by seed (NORTH (10,10) vs SOUTH (10,30)). Both
+  # candidate choke regions are valid via `any_of` — the agent must
+  # cluster ≥4 of 5 pbox at EITHER (60, 20) or (40, 20) — so a
+  # single memorised cluster cell still works for both seeds but the
+  # base-latitude flip enforces the hard-tier spawn contract (the
+  # required cluster is geographically distant from EACH base, so the
+  # placement plan can't be a stamped relative-to-base offset that
+  # happens to land in the same world cell on every seed). Enemies
+  # don't honor spawn_point (engine: oramap.rs::expand_scenario_actors)
+  # so the rusher band is placed symmetrically at y=20 between the
+  # two candidate chokes; the rusher charges agent centroid so its
+  # path crosses x∈[40,60] regardless of latitude. Total pbox grows
+  # to 5 (3000cr) and the cluster bar grows to 4 of 5 at one choke.
+  # max_turns 70 → reachable tick 93+90·69 = 6303; deadline 6300.
+  hard:
+    description: >
+      Agent base latitude flips between NORTH (y=10) and SOUTH (y=30)
+      by seed. Build 5 pillboxes (budget 3000cr = exactly 5 pbox at
+      600 each) AND place at least 4 of them inside ONE of the two
+      candidate choke regions (radius 5 around either (60, 20) or
+      (40, 20)). Spreading across both chokes (e.g. 3+2) FAILS the
+      4-of-5 cluster bar; a thin perimeter line FAILS both choke
+      bars. The fact must survive.
+    starting_cash: 3000
+    overrides:
+      actors:
+        # spawn_point 0 — NORTH base. Fact at (10, 10); tent/powr
+        # west-of-fact so they aren't directly in the rusher path.
+        - {type: fact, owner: agent, position: [10, 10], spawn_point: 0}
+        - {type: tent, owner: agent, position: [6,  10], spawn_point: 0}
+        - {type: powr, owner: agent, position: [6,  12], spawn_point: 0}
+        - {type: e1,   owner: agent, position: [12, 10], stance: 2, spawn_point: 0}
+        - {type: e1,   owner: agent, position: [12, 11], stance: 2, spawn_point: 0}
+        - {type: e1,   owner: agent, position: [12, 9],  stance: 2, spawn_point: 0}
+        - {type: e1,   owner: agent, position: [14, 10], stance: 2, spawn_point: 0}
+        - {type: e1,   owner: agent, position: [8,  10], stance: 2, spawn_point: 0}
+        # spawn_point 1 — SOUTH base, mirror at y=30.
+        - {type: fact, owner: agent, position: [10, 30], spawn_point: 1}
+        - {type: tent, owner: agent, position: [6,  30], spawn_point: 1}
+        - {type: powr, owner: agent, position: [6,  32], spawn_point: 1}
+        - {type: e1,   owner: agent, position: [12, 30], stance: 2, spawn_point: 1}
+        - {type: e1,   owner: agent, position: [12, 31], stance: 2, spawn_point: 1}
+        - {type: e1,   owner: agent, position: [12, 29], stance: 2, spawn_point: 1}
+        - {type: e1,   owner: agent, position: [14, 30], stance: 2, spawn_point: 1}
+        - {type: e1,   owner: agent, position: [8,  30], stance: 2, spawn_point: 1}
+        # Enemies don't honor spawn_point (engine: oramap.rs); the
+        # rusher band sits at y=20 (mid-latitude) and charges the
+        # agent centroid, so its path crosses BOTH candidate choke
+        # x-columns regardless of which base latitude the seed picks.
+        - {type: e1, owner: enemy, position: [100, 20], stance: 3, count: 6}
+        - {type: e3, owner: enemy, position: [102, 20], stance: 3, count: 2}
+        # Anti-DRAW marker.
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - building_count_gte: {type: pbox, n: 5}
+        - any_of:
+            - building_in_region: {type: pbox, x: 60, y: 20, radius: 5, count: 4}
+            - building_in_region: {type: pbox, x: 40, y: 20, radius: 5, count: 4}
+        - building_count_gte: {type: fact, n: 1}
+        - within_ticks: 6300
+    fail_condition:
+      any_of:
+        - after_ticks: 6301
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 70

openra_bench/scenarios/packs/econ-cash-reserve-management.yaml

@@ -0,0 +1,232 @@
+meta:
+  id: econ-cash-reserve-management
+  title: Economy — Cash Reserve Management (Spend Without Going Broke)
+  capability: reasoning
+  real_world_meaning: >
+    A treasury-management decision under a deadline. The agent has a
+    productive operation (two harvesters on two near patches feeding a
+    refinery — steady income), starting cash 1500, and a hard win
+    requirement to grow operations (build MORE buildings) WHILE also
+    finishing the episode with a positive operating reserve in the
+    bank (cash ≥ 300). The classic anti-patterns:
+    1) STALL — preserve every credit, build nothing. The reserve stays
+       safe but operations never grow → the "build more buildings" bar
+       is never met → LOSS.
+    2) OVER-SPEND — spend everything (and then some, by chaining a
+       1400cr refinery and any other expensive build) on construction
+       and dip the reserve to zero. Income eventually refills but the
+       window between buildings-met and reserve-refilled may not close
+       before the deadline → LOSS.
+    3) PURE-HOLD — harvest and sit on the cash forever, never building.
+       Same as STALL on the building-growth axis → LOSS.
+    The intended capability is the SC2 cash-overflow / corporate
+    treasury discipline: spend ENOUGH to keep growing (buildings) while
+    keeping ENOUGH liquid (cash) to weather the next shock — never let
+    the operating reserve hit zero, never sit on idle capital. With a
+    pre-placed 2× harv income engine the model gets ~190 cr/turn of
+    inflow, so any modest spend (1-2 powr at 300cr each) is recovered
+    in a handful of turns and the reserve closes the episode well
+    above 300.
+  robotics_analogue: >
+    Operating-reserve management in an autonomous fleet's treasury:
+    revenue from collectors flows into a single pool that must fund
+    both ongoing capacity expansion (added depot / processing / defence
+    nodes) AND a minimum operating reserve (covering the next
+    contingency — a damaged collector, a sudden parts order). A pure-
+    hoarding policy fails the growth mandate; a blow-the-reserve policy
+    succumbs to the next shock. The discipline being measured is the
+    operations-finance loop: spend at the income-replenishment rate, not
+    above and not below.
+  author: catalog-f8
+  benchmark_anchor:
+    - SC2 cash management (spend while not overflowing)
+    - financial runway management (operate while keeping reserve)
+    - "treasury management: cash conversion cycle"
+    - operational reserve / working capital
+
+# ENGINE NOTE (verified 2026-05-20 against installed openra_train wheel,
+# post-S0/S1 harvest income — Task #14, scripted run_level seeds 1-4):
+# 1. Pre-placed 2× harv on 2× mine (NEAR cells) yields ~190 cr/turn
+#    sustained against the single pre-placed `proc` at (12,18). Over
+#    a 60-turn (5400-tick) window that's ~11400 cr of income inflow,
+#    on top of the starting_cash 1500.
+# 2. Cost table (verified against gamerules.rs / game_data.py):
+#       powr = 300  (no prereq, +100 power)
+#       tent = 500  (prereq powr, −20 power) — PRE-PLACED here
+#       proc = 1400 (prereq powr, −30 power) — PRE-PLACED here
+#       pbox = 600  (prereq tent) — only buildable because tent is
+#                                    pre-placed
+#       silo = 150  (prereq proc) — cheap storage
+#       harv = 1100 (prereq proc)
+#    With tent pre-placed, the agent can queue powr/pbox/silo/harv in
+#    parallel to the existing fact+proc+tent+powr base.
+# 3. The decision under test is "how much to spend": starting_cash 1500
+#    funds:
+#       2× powr (600) → cash 900 → reserve safe, building_total 6
+#       2× pbox (1200) → cash 300 → reserve at the bar, building_total 6
+#       1× proc (1400) → cash 100 → BELOW the 300 reserve bar
+#       1× proc + 1× powr (1700) → impossible until income refills
+#    The lazy "build something cheap" play (2 powr) wins comfortably;
+#    the "blow the bank" play (proc immediately) goes below the reserve
+#    bar at the moment building_total reaches 6 and must wait for
+#    income to refill — which can happen well before the 5400-tick
+#    deadline, so we DOCUMENT this is a SOFT failure mode (a slow
+#    rebuilder still wins) rather than predicate-enforced.
+# 4. Tick budget: engine advances ~90 ticks per decision turn.
+#    Easy uses max_turns 60 → ceiling 5403 > 5400 (within_ticks 5400)
+#    — generous, the loose-bar tier. Medium tightens to max_turns 14
+#    → ceiling 1263 > 1200 (within_ticks 1200) so an over-spending
+#    policy (proc 1400 + another building → cash dips to 0, must wait
+#    ~10+ turns of income to refill above the 300 reserve) cannot
+#    recover before the deadline; the lean 2× powr commit (600 spend,
+#    cash 900) wins at tick ~450. Hard tightens further to max_turns
+#    12 → ceiling 1083 > 1080 (within_ticks 1080) AND raises the
+#    reserve to 500 so even less recovery slack exists. fail_condition
+#    uses after_ticks = within_ticks + 1 (a non-finisher LOSES, not
+#    draws — engine ceiling stays one tick past after_ticks so the
+#    fail clause fires).
+# 5. The `harvest` order with a target cell directs the existing harvs
+#    onto the mines; the auto-cycle continues. Pre-placed harvs at
+#    (14,18) and (14,20) bind to mines at (22,18) and (22,20)
+#    respectively. The pre-placed e1 at (120,36) stance:0 prevents
+#    ConquestVictoryConditions from auto-`done`ing the episode before
+#    the win/fail predicate evaluates (CLAUDE.md engine footgun).
+base_map: rush-hour-arena
+starting_cash: 1500
+
+base:
+  agent:
+    faction: allies
+  enemy:
+    faction: soviet
+  tools:
+    - observe
+    - build
+    - place_building
+    - harvest
+    - move_units
+    - stop
+  planning: true
+  termination:
+    max_ticks: 40000
+  actors:
+    # Pre-placed: 4 buildings (fact + proc + tent + powr) and 2 harvs
+    # on 2 near mines. The agent starts at building_total=4 and must
+    # build ≥2 more to reach the building_total_gte:6 bar without
+    # busting the cash_gte:300 reserve.
+    - {type: fact, owner: agent, position: [10, 22]}
+    - {type: proc, owner: agent, position: [12, 18]}
+    - {type: tent, owner: agent, position: [10, 18]}
+    - {type: powr, owner: agent, position: [14, 22]}
+    - {type: harv, owner: agent, position: [14, 18]}
+    - {type: harv, owner: agent, position: [14, 20]}
+    # Two near ore patches — steady ~190cr/turn income for the two
+    # pre-placed harvs.
+    - {type: mine, owner: neutral, position: [22, 18]}
+    - {type: mine, owner: neutral, position: [22, 20]}
+    # Inert far enemy marker keeps the episode from auto-terminating
+    # on "all enemies dead" before the win/fail predicate fires.
+    - {type: e1, owner: enemy, position: [120, 36], stance: 0}
+
+levels:
+  easy:
+    description: >
+      Loose-bar cash-reserve test. You start with 4 buildings (fact,
+      proc, tent, powr), 2 harvesters on 2 near ore patches, and
+      $1500. Build at least ONE more building (the cheapest is a
+      Power Plant at $300) AND keep at least $300 in the bank at the
+      moment the bar latches AND keep both harvesters alive — all
+      within tick 5400. Stalling (build nothing) loses on the
+      building bar; the harvesters keep refilling cash, so any modest
+      spend wins. Pure-hold and over-spend (a $1400 refinery dips
+      cash below the reserve at the latch moment) both fail.
+    starting_cash: 1500
+    win_condition:
+      all_of:
+        - building_total_gte: 5
+        - cash_gte: 300
+        - unit_type_count_gte: {type: harv, n: 2}
+        - within_ticks: 5400
+    fail_condition:
+      any_of:
+        - after_ticks: 5401
+        - not: {has_building: fact}
+    max_turns: 60
+  medium:
+    description: >
+      Tighter clock, same income engine: build at least TWO more
+      buildings (building_total ≥ 6, i.e. add at least 2 — e.g. two
+      Power Plants at $300 each, or one Pillbox at $600 plus a Power
+      Plant) AND keep $300 in the bank AND keep both harvesters
+      alive — within tick 810 (≈ 10 turns). The cheap 2× powr
+      commit costs $600, leaves $900 cash (well above the 300
+      reserve), and finishes by tick ~450 — comfortable slack.
+      Over-spending on a 2nd refinery ($1400) dips cash to $100 at
+      the latch moment; an extra build at $300+ pushes it lower.
+      Income refills cash at ~95 cr/turn so re-clearing the reserve
+      after over-spend takes ≥3-4 turns, pushing the win past tick
+      810. Stall and pure-hold lose on the building bar.
+    starting_cash: 1500
+    win_condition:
+      all_of:
+        - building_total_gte: 6
+        - cash_gte: 300
+        - unit_type_count_gte: {type: harv, n: 2}
+        - within_ticks: 810
+    fail_condition:
+      any_of:
+        - after_ticks: 811
+        - not: {has_building: fact}
+    max_turns: 10
+  hard:
+    description: >
+      Tightest growth bar, larger reserve, and seed-varied starts.
+      Build at least THREE more buildings (building_total ≥ 7) AND
+      keep $500 in the bank AND keep both harvesters alive — within
+      tick 1080 (≈ 12 turns). The cheapest 3-building commit (3×
+      powr = $900) leaves $600 cash, just above the $500 reserve;
+      mixing a Pillbox in ($600 + $600 = $1200) leaves $300, BELOW
+      the $500 reserve until income refills. Over-spending on a 2nd
+      refinery ($1400) dips cash far below 500 and cannot recover
+      inside 1080 ticks. The base is round-robined between NORTH
+      (proc/tent/powr/harvs around y=14) and SOUTH (around y=28)
+      per seed; the two near patches (y=14 and y=28) sit on the
+      spawn-matched row so the throughput is symmetric per spawn,
+      but a memorised opening cannot generalise across seeds.
+    starting_cash: 1500
+    overrides:
+      actors:
+        # spawn_point 0 — NORTH base, harvs on the y=14 patches.
+        - {type: fact, owner: agent, position: [10, 14], spawn_point: 0}
+        - {type: proc, owner: agent, position: [12, 14], spawn_point: 0}
+        - {type: tent, owner: agent, position: [10, 18], spawn_point: 0}
+        - {type: powr, owner: agent, position: [14, 14], spawn_point: 0}
+        - {type: harv, owner: agent, position: [16, 14], spawn_point: 0}
+        - {type: harv, owner: agent, position: [16, 15], spawn_point: 0}
+        # spawn_point 1 — SOUTH base, harvs on the y=28 patches.
+        - {type: fact, owner: agent, position: [10, 28], spawn_point: 1}
+        - {type: proc, owner: agent, position: [12, 28], spawn_point: 1}
+        - {type: tent, owner: agent, position: [10, 24], spawn_point: 1}
+        - {type: powr, owner: agent, position: [14, 28], spawn_point: 1}
+        - {type: harv, owner: agent, position: [16, 28], spawn_point: 1}
+        - {type: harv, owner: agent, position: [16, 29], spawn_point: 1}
+        # Two mine pairs — one for each spawn row. spawn_point filter
+        # applies ONLY to agent actors (CLAUDE.md engine fact), so
+        # both pairs always place; the spawn-matched pair feeds the
+        # spawn-matched harvs.
+        - {type: mine, owner: neutral, position: [22, 14]}
+        - {type: mine, owner: neutral, position: [22, 15]}
+        - {type: mine, owner: neutral, position: [22, 28]}
+        - {type: mine, owner: neutral, position: [22, 29]}
+        - {type: e1, owner: enemy, position: [120, 36], stance: 0}
+    win_condition:
+      all_of:
+        - building_total_gte: 7
+        - cash_gte: 500
+        - unit_type_count_gte: {type: harv, n: 2}
+        - within_ticks: 1080
+    fail_condition:
+      any_of:
+        - after_ticks: 1081
+        - not: {has_building: fact}
+    max_turns: 12

openra_bench/scenarios/packs/econ-recover-from-zero-cash.yaml

@@ -0,0 +1,285 @@
+# Validate: python -m openra_bench.scenarios.validate packs/econ-recover-from-zero-cash.yaml
+# See ../CONTRIBUTING.md for the full win-condition grammar.
+#
+# ECON-RECOVER-FROM-ZERO-CASH (Group F — turtle-recovery / bankruptcy
+# turnaround from a minimum-viable kit and ZERO cash).
+#
+# Real-world anchor: SC2 turtle-back-to-eco (lost everything, rebuild
+# slowly with a sole surviving worker), business bankruptcy turnaround
+# (one operating asset left, no working capital, rebuild revenue first
+# then reinvest), military recovery from defeat (rebuild force structure
+# starting from a skeleton crew), startup pivot after a runway crisis.
+#
+# Pack frame: the agent starts with a MINIMUM VIABLE KIT (fact + proc +
+# one harvester + one mine) and **0 cash**. There is no enemy aggression.
+# The decision is the RECOVERY PROFILE — commit to harvest first, let
+# income accumulate, then reinvest in the next productive asset (a war
+# factory + a second harvester) so the income channel actually scales
+# past a non-trivial revenue bar. A model that:
+#   * stalls (zero income forever) ⇒ never harvests, EV stays at 0, LOSS
+#   * builds-too-soon (e.g. queues a SECOND refinery or buys army)
+#     ⇒ drains harvest cash to the wrong asset, never funds the weap+harv
+#     chain, fails the 2-harv requirement ⇒ LOSS
+#   * builds-army-from-zero (powr → tent → spam e1 instead of weap+harv)
+#     ⇒ never builds a 2nd harv ⇒ LOSS
+# all miss the bar. The intended slow-and-steady recovery (harvest,
+# accumulate to 2000, build('weap'), then build('harv'), redirect the
+# new harv to the patch, keep harvesting) WINS.
+#
+# Why this pack is different from `economy-harvest-timebox`:
+#   * `economy-harvest-timebox` starts with 300-1500 cash and only tests
+#     "commit to harvest" (or build a 2nd harv with the starting budget).
+#   * `econ-recover-from-zero-cash` starts with **0 cash** and forces
+#     the agent to COMPLETE the income-then-reinvest loop: there is no
+#     starting buffer to spend, so the test is the recovery DISCIPLINE —
+#     do not spend before income flows; do not spend on the wrong asset
+#     when income arrives; commit to the harvest→weap→harv sequence.
+#
+# Why this pack is different from `econ-startup-from-scratch`:
+#   * `econ-startup-from-scratch` tests the COLD-START opening (deploy
+#     MCV → powr → proc → harv) from a 1900-cash budget. The agent has
+#     no buildings.
+#   * `econ-recover-from-zero-cash` tests RECOVERY FROM SETBACK (you
+#     once had a base, now you have only fact+proc+1 harv and 0 cash —
+#     rebuild revenue and re-scale the worker count). The chain is
+#     harvest → weap → harv (the cold-start "powr → proc" part is
+#     already paid for by the survived infrastructure).
+#
+# ENGINE FACTS verified (CLAUDE.md):
+#  1. starting_cash: 0 is supported (see mcv-deploy-relocate-under-pressure,
+#     mfb-base-1-defend-base-2-build). The `build` order with insufficient
+#     cash defers production (the queue waits until cash is available).
+#  2. harv prereq is `weap` (gamerules.rs line 328-330). weap (cost 2000)
+#     prereq is `proc` (already pre-placed). harv cost is 1400.
+#  3. tent prereq is `powr` (gamerules.rs line 340) and we do NOT pre-
+#     place powr, so the brute "build army" path requires building powr
+#     (300) → tent (400) → e1 (100 each) — but this never funds weap
+#     (2000) + harv (1400) within budget, so the 2-harv requirement is
+#     never met ⇒ LOSS.
+#  4. Harvest income is distance-dependent: with the proc immediately
+#     adjacent to a near patch, one harv sustains ~150-200 cr per
+#     decision turn (verified by economy-harvest-investment and
+#     economy-harvest-timebox tuning notes). At 70 turns × ~150 cr ≈
+#     ~10,500 ev gross, comfortably above the chain spend (2000+1400 =
+#     3400) plus the 2000 EV bar; a hard tier (3 harvs, 4800 chain
+#     spend, 3000 EV bar) is solvable inside 70 turns with 2 patches.
+#  5. Newly-built harv spawns at the weap and does NOT auto-path to a
+#     distant patch from a bare `harvest` order (engine quirk noted in
+#     econ-startup-from-scratch and economy-harvest-investment). The
+#     intended chain `move_units(harv, patch_x, patch_y)` first, then
+#     `harvest(harv, patch_x, patch_y)` once the harv is on the patch.
+#  6. Persistent unarmed enemy `fact` marker far east prevents engine
+#     auto-`done` via the all-enemies-eliminated path (CLAUDE.md
+#     auto-done footgun) — so a non-finisher LOSES on the deadline
+#     (never DRAWS).
+#  7. Tick alignment: max_turns 70 → ceiling 93 + 90·69 = 6303 > 6300 ✓.
+#     within_ticks 6300; fail after_ticks 6301 (deadline bites as a
+#     reachable LOSS).
+#  8. The hard tier's two agent spawn_point groups (NORTH/SOUTH base)
+#     satisfy the spawn-variation contract (test_hard_tier.py).
+#     Neutral `mine` actors always place regardless of spawn_point
+#     filter (CLAUDE.md), so each spawn has its own near patch geometry.
+
+meta:
+  id: econ-recover-from-zero-cash
+  title: 'Recover From Zero Cash — Rebuild Revenue From a Minimum-Viable Kit'
+  capability: reasoning
+  real_world_meaning: >
+    Turtle-recovery / bankruptcy turnaround from a minimum-viable kit
+    and zero working capital. The agent inherits ONE refinery, ONE
+    harvester, and ONE ore patch — but no cash, no spare workers, no
+    army. The decision is the RECOVERY PROFILE — commit to harvest
+    FIRST (the only income channel), accumulate cash, and then
+    reinvest in the NEXT productive asset (a war factory and a second
+    harvester) so the income channel actually scales past a non-
+    trivial revenue bar before the deadline. Stalling (no income),
+    spending the accumulated cash on the wrong asset (a second
+    refinery, army units), or trying to build an army from zero all
+    miss the bar.
+  robotics_analogue: >
+    Post-crisis operations restart: an autonomous operator has lost
+    most of its infrastructure and is reduced to one processing unit,
+    one collector, and one known source — with no operating capital.
+    It must commit to running the collector to refill the cash
+    reserve, then deploy the saved capital to acquire a second
+    collector before the recovery deadline. Spending on defensive /
+    expansion hedges before the income channel has refilled the
+    reserve misses the bar.
+  author: groupF-econ-seed
+  benchmark_anchor:
+    - "SC2 turtle-back-to-economy / recovery from setback"
+    - "business bankruptcy turnaround planning"
+    - "military recovery from defeat (rebuild force structure)"
+    - "startup pivot after runway crisis"
+
+base_map: rush-hour-arena
+# 0 cash — the entire pack is the recovery-from-zero-capital test. The
+# agent CANNOT spend a starting buffer; the only path to a 2nd harv is
+# to harvest first, then reinvest the accumulated cash on weap+harv.
+starting_cash: 0
+
+base:
+  agent: {faction: allies}
+  enemy: {faction: soviet, cash: 0}
+  # Spec-required toolset: NO `deploy` (we already have fact pre-placed);
+  # the agent must commit to harvest and reinvest with the production
+  # chain (`build` + `place_building`).
+  tools: [observe, build, place_building, harvest, move_units, stop]
+  # Default `spawn_mcvs: false` — we declare actors ourselves per level
+  # so the engine doesn't add a phantom MCV.
+  spawn_mcvs: false
+  planning: true
+  termination: {max_ticks: 8000}
+  actors: []
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Minimum-viable kit (fact + proc + 1 harv + 1 mine); 0 cash; loose
+  # bar (1500 EV) and NO second-harv requirement. The skill being
+  # tested is the floor: commit to the existing harvester so income
+  # actually flows (the pre-placed harv near the patch sustains
+  # ~150-200 cr/turn). Stall (zero income) LOSES; any committed
+  # harvest WINS. max_turns 70 → ceiling 93 + 90·69 = 6303 > 6300 ✓.
+  easy:
+    description: >
+      You start with a Construction Yard ('fact'), an Ore Refinery
+      ('proc'), one Ore Truck ('harv'), and one ore patch ('mine'),
+      with $0 cash. There is no enemy aggression. To start the
+      harvester collecting, first `move_units` it onto the patch cell
+      (22,18), then issue `harvest` with that cell as the target (the
+      auto-cycle continues on its own). Win = economy_value (cash +
+      stored ore) ≥ 1500 before tick 6300, AND you still own a 'fact'
+      AND ≥1 'harv'. Stalling (only `observe`) earns nothing and
+      loses on the clock.
+    starting_cash: 0
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [8, 18]}
+        - {type: proc, owner: agent, position: [12, 18]}
+        - {type: harv, owner: agent, position: [14, 18]}
+        - {type: mine, owner: neutral, position: [22, 18]}
+        # Persistent far enemy marker — LOSS-not-DRAW guarantee.
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - economy_value_gte: 1500
+        - has_building: fact
+        - unit_type_count_gte: {type: harv, n: 1}
+        - within_ticks: 6300
+    fail_condition:
+      any_of:
+        - after_ticks: 6301
+        - not: {has_building: fact}
+        - not: {unit_type_count_gte: {type: harv, n: 1}}
+    max_turns: 70
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 controlled variable on top of easy: the win predicate adds a
+  # 2-HARV requirement, so a "harvest only with the starting harv"
+  # policy LOSES on the structural clause regardless of EV. The
+  # intended recovery chain is: harvest (income flows) → save 2000 →
+  # build('weap') (prereq for harv) + place_building → save 1400 →
+  # build('harv') + place_building → move_units the new harv to the
+  # patch → harvest. Bar 2000 EV requires committed harvesting after
+  # the chain spend (cash post-chain is ~0; ≥2000 ev = the bar must
+  # be reached via the resumed harvest income).
+  medium:
+    description: >
+      You start with a Construction Yard ('fact'), an Ore Refinery
+      ('proc'), one Ore Truck ('harv'), and one ore patch ('mine'),
+      with $0 cash. To rebuild revenue: (1) `move_units` the harv
+      onto the patch cell (22,18) then `harvest` it (the auto-cycle
+      sustains income on its own); (2) once you have $2000, queue a
+      War Factory ('weap', cost 2000, prereq is the existing
+      refinery) and place it adjacent to the fact; (3) once the
+      'weap' is up and you have $1400, queue a second Ore Truck
+      ('harv'); (4) `move_units` the new harv to the patch and
+      `harvest` it. Win = economy_value ≥ 2000 AND ≥ 2 harvesters
+      alive AND you still own 'fact', before tick 6300. Stalling,
+      building army units (powr → tent → e1) instead of the weap+harv
+      chain, or building a second refinery instead of a second harv
+      all miss the 2-harv requirement and LOSE.
+    starting_cash: 0
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [8, 18]}
+        - {type: proc, owner: agent, position: [12, 18]}
+        - {type: harv, owner: agent, position: [14, 18]}
+        - {type: mine, owner: neutral, position: [22, 18]}
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - economy_value_gte: 2000
+        - has_building: fact
+        - unit_type_count_gte: {type: harv, n: 2}
+        - within_ticks: 6300
+    fail_condition:
+      any_of:
+        - after_ticks: 6301
+        - not: {has_building: fact}
+        - not: {unit_type_count_gte: {type: harv, n: 1}}
+    max_turns: 70
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +2 controlled variables vs medium:
+  #   1. Higher bar (3000 EV) AND 3-harv requirement — the chain spend
+  #      is now weap (2000) + harv (1400) + harv (1400) = 4800,
+  #      requiring sustained throughput AFTER the chain to clear the
+  #      3000 EV bar. Two ore patches double the income ceiling so
+  #      the bar is still reachable inside 70 turns.
+  #   2. TWO agent spawn_point groups (NORTH base y=14 vs SOUTH base
+  #      y=26) round-robined by seed — a memorised "place weap at
+  #      (8,18)" opening cannot generalise. Each spawn has its own
+  #      symmetric two-patch geometry. Neutral mine actors always
+  #      place regardless of spawn_point filter (CLAUDE.md engine
+  #      footgun), so BOTH patch pairs exist in the world; the
+  #      irrelevant pair sits far from each spawn's harv lane.
+  hard:
+    description: >
+      Same recovery from $0 cash, but the bar is higher (3000 EV)
+      AND you need THREE harvesters, AND there are TWO ore patches
+      near your base. Your base orientation varies by seed (NORTH or
+      SOUTH); both halves have the same per-spawn patch geometry.
+      Intended chain: (1) commit the starting harv to a near patch
+      (use `move_units` to nudge it onto the patch cell, then
+      `harvest`); (2) save $2000, build a War Factory ('weap',
+      prereq is the existing refinery) adjacent to the fact; (3)
+      save $1400, build a 2nd harv, move it to the other near patch,
+      `harvest`; (4) save $1400, build a 3rd harv, route it back to
+      the first patch (or feed the second), `harvest`. Win =
+      economy_value ≥ 3000 AND ≥ 3 harvs AND own 'fact' before tick
+      6300. Stalling, building army, or building only 2 harvs all
+      miss the 3-harv requirement and LOSE.
+    starting_cash: 0
+    overrides:
+      actors:
+        # ── spawn_point 0: NORTH base, near patches at y=14 / y=16 ──
+        - {type: fact, owner: agent, position: [8, 14], spawn_point: 0}
+        - {type: proc, owner: agent, position: [12, 14], spawn_point: 0}
+        - {type: harv, owner: agent, position: [14, 14], spawn_point: 0}
+        # ── spawn_point 1: SOUTH base, near patches at y=26 / y=28 ──
+        - {type: fact, owner: agent, position: [8, 26], spawn_point: 1}
+        - {type: proc, owner: agent, position: [12, 26], spawn_point: 1}
+        - {type: harv, owner: agent, position: [14, 26], spawn_point: 1}
+        # Neutral mines ALWAYS place regardless of spawn_point filter
+        # (CLAUDE.md). Place a symmetric two-patch pair at each
+        # latitude; the other-spawn pair sits 12 cells away (far
+        # enough to be irrelevant to the spawn-local harv throughput).
+        - {type: mine, owner: neutral, position: [22, 14]}
+        - {type: mine, owner: neutral, position: [22, 16]}
+        - {type: mine, owner: neutral, position: [22, 26]}
+        - {type: mine, owner: neutral, position: [22, 28]}
+        # Persistent far enemy marker — LOSS-not-DRAW guarantee.
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - economy_value_gte: 3000
+        - has_building: fact
+        - unit_type_count_gte: {type: harv, n: 3}
+        - within_ticks: 6300
+    fail_condition:
+      any_of:
+        - after_ticks: 6301
+        - not: {has_building: fact}
+        - not: {unit_type_count_gte: {type: harv, n: 1}}
+    max_turns: 70

openra_bench/scenarios/packs/econ-target-cash-amount-by-deadline.yaml

@@ -0,0 +1,197 @@
+meta:
+  id: econ-target-cash-amount-by-deadline
+  title: 'Econ — Hit a Cash Target by a Hard Deadline'
+  capability: reasoning
+  real_world_meaning: >
+    Budget-by-date target: the operation must reach a stated cash bar
+    by a stated deadline, the way a startup must hit a quarterly
+    revenue target / a fundraising milestone / a quarterly closeout.
+    Pre-placed harvester+refinery+barracks are the running pipeline;
+    the agent must reason about whether the current capacity will
+    clear the bar on time, and if not, reinvest into harvesting
+    capacity (build extra harvesters) — not into army units that drain
+    the cash account without growing income. Idling, over-spending on
+    the wrong line item, or under-investing in capacity all miss the
+    bar.
+  robotics_analogue: >
+    Throughput-by-deadline planning in an autonomous pipeline: hit a
+    revenue/output target by a hard date by deciding when to scale up
+    collectors (capacity capex) vs hold (stay lean) vs spend on
+    unrelated capacity (army units / non-revenue line items). Capex
+    timing is the decision — over-spend on the wrong line and the
+    deadline passes with the books short.
+  author: wave-5
+  benchmark_anchor:
+    - SC2 econ-by-tick target
+    - "budget-by-date / quarterly revenue target"
+    - fundraising milestone planning
+    - OR throughput optimization with deadline
+
+# ENGINE NOTE (verified 2026-05-20 against installed openra_train wheel):
+# 1. `cash_gte: N` reads c.signals.cash (spendable cash only, NOT
+#    cash+resources EV — see win_conditions.py). Building units
+#    DEDUCTS cash, so an "army drain" policy (spam e1 alongside
+#    harvest) treads water at ~starting_cash (income ≈ unit cost)
+#    and never reaches the bar.
+# 2. Harv build requires fact + powr + weap (war factory) as the
+#    Vehicle queue prereqs; tent is included for `e1` so the army-
+#    drain decoy can actually issue StartProduction (so it loses
+#    DRAINING cash, not silently no-oping).
+# 3. Income rate from one harv on the rush-hour-arena near patches
+#    (22,18)/(22,22) is ~1.1 cash/tick after a ~450-tick warmup;
+#    so baseline 1-harv ramp in 4500 ticks ≈ 600 + 4500·1.1 ≈ 5550.
+#    Medium target=5500 is right at the baseline's max reach (so
+#    it loses on the deadline by ~3 ticks), and one extra harv
+#    accelerates to the bar by tick ~2900 (comfortable win).
+# 4. Hard tier: target=6500 in 4000 ticks beats the baseline (which
+#    plateaus at ~4100 cash by 4053 ticks), 2 symmetric spawn_point
+#    groups (NORTH y=10..14 / SOUTH y=28..32) so a memorised "build
+#    at (8,18)" opening cannot generalise across seeds. Both spawn
+#    groups carry their own fact+proc+tent+powr+weap+harv +
+#    near-mine pair (shared mine geometry replicated at both
+#    latitudes per the spawn_point filter rule — only AGENT actors
+#    are filtered by spawn_point; neutral mines always place, but
+#    we keep the geometry symmetric so DEEP throughput is equal).
+# 5. Tick/turn alignment: easy max_turns=21 → ceiling 1893 ticks
+#    ≥ within_ticks 1800; medium max_turns=51 → ceiling 4593 ≥ 4500;
+#    hard max_turns=46 → ceiling 4143 ≥ 4000. fail_condition uses
+#    after_ticks = within_ticks + 1 so a non-finisher is a real
+#    LOSS (the deadline bites).
+# 6. Far enemy `e1` at (120,36) stance:0 keeps the engine from
+#    auto-`done`ing on no-enemy-actors (CLAUDE.md footgun).
+base_map: rush-hour-arena
+starting_cash: 600
+
+base:
+  agent:
+    faction: allies
+  enemy:
+    faction: soviet
+  tools:
+    - observe
+    - build
+    - place_building
+    - harvest
+    - move_units
+    - stop
+  planning: true
+  termination:
+    max_ticks: 40000
+  actors:
+    # Pre-placed running pipeline: fact + proc + tent (army decoy) +
+    # powr + weap (Vehicle queue for harv) + 1× harv + 2× mines.
+    - {type: fact, owner: agent, position: [8, 18]}
+    - {type: proc, owner: agent, position: [12, 18]}
+    - {type: tent, owner: agent, position: [12, 22]}
+    - {type: powr, owner: agent, position: [8, 22]}
+    - {type: weap, owner: agent, position: [16, 22]}
+    - {type: harv, owner: agent, position: [14, 18]}
+    - {type: mine, owner: neutral, position: [22, 18]}
+    - {type: mine, owner: neutral, position: [22, 22]}
+    # Far inert enemy marker — prevents engine auto-done on
+    # no-enemy-actors (CLAUDE.md). stance:0 + far position so it
+    # cannot influence the run.
+    - {type: e1, owner: enemy, position: [120, 36], stance: 0}
+
+levels:
+  easy:
+    description: >
+      Loose deadline cash target. The pipeline (1× harv + 1× proc +
+      2× mine) is already running; the bar (1500 cash by tick 1800)
+      is reachable just by committing to harvest with the pre-placed
+      harvester — no reinvestment needed. Stall idles at the 600
+      starting cash and LOSES; an "army drain" policy (spam e1) that
+      harvests AND spends every spare credit on infantry treads
+      water at starting_cash (income ≈ unit cost) and LOSES; the
+      intended `harvest` commitment WINS by ~tick 900. This is the
+      bare cash-target reasoning skill (notice the bar, run the
+      pipeline, hit it before the deadline).
+    starting_cash: 600
+    win_condition:
+      all_of:
+        - cash_gte: 1500
+        - within_ticks: 1800
+    # within_ticks ≤ 93+90·20 = 1893 ⇒ deadline bites inside max_turns;
+    # after_ticks=1801 ⇒ non-finisher is a real LOSS, not a draw.
+    fail_condition:
+      any_of:
+        - after_ticks: 1801
+        - not: {has_building: fact}
+        - not: {unit_type_count_gte: {type: harv, n: 1}}
+    max_turns: 21
+  medium:
+    description: >
+      Mid bar — 5500 cash by tick 4500 — that the pre-placed
+      pipeline CANNOT meet by itself. One harvester on the two near
+      patches yields ~1.1 cash/tick after deductions, so 600 +
+      4500·1.1 ≈ 5550 — at tick 4500 the bar is just out of reach
+      and the deadline bites (baseline LOSES at cash ≈ 5600 at tick
+      4503). The intended play is to reinvest: build an extra harv
+      (cost 1100, prereq fact+weap+powr) so the post-warmup income
+      doubles and the bar clears by ~tick 2900. Stall (no income)
+      LOSES; "army drain" (spend every credit on e1) treads water
+      at ~starting_cash and LOSES; baseline (no reinvestment) just
+      misses and LOSES. Reinvestment WINS.
+    starting_cash: 600
+    win_condition:
+      all_of:
+        - cash_gte: 5500
+        - within_ticks: 4500
+    # within_ticks ≤ 93+90·50 = 4593 ⇒ reachable in max_turns;
+    # after_ticks=4501 ⇒ non-finisher is a real LOSS.
+    fail_condition:
+      any_of:
+        - after_ticks: 4501
+        - not: {has_building: fact}
+        - not: {unit_type_count_gte: {type: harv, n: 1}}
+    max_turns: 51
+  hard:
+    description: >
+      Tighter bar (6500 cash) in a tighter clock (4000 ticks) with
+      seed-varied starts. Two spawn_point groups (NORTH y=10..14 /
+      SOUTH y=28..32) each carry their own fact+proc+tent+powr+
+      weap+harv; both latitudes have a symmetric near-patch pair so
+      the reinvestment economics are equal per spawn (a memorised
+      "build at (8,18)" opening cannot generalise — the model must
+      identify its base each episode). The baseline pipeline
+      plateaus at ~4100 cash by tick 4053 (LOSES on every seed);
+      stall and army-drain LOSE on every seed; reinvesting into
+      ≥1 extra harv WINS on every seed by tick ≤3800.
+    starting_cash: 600
+    overrides:
+      actors:
+        # spawn_point 0 — NORTH base (y=10..14); near patches at y=10/14.
+        - {type: fact, owner: agent, position: [8, 10], spawn_point: 0}
+        - {type: proc, owner: agent, position: [12, 10], spawn_point: 0}
+        - {type: tent, owner: agent, position: [12, 14], spawn_point: 0}
+        - {type: powr, owner: agent, position: [8, 14], spawn_point: 0}
+        - {type: weap, owner: agent, position: [16, 14], spawn_point: 0}
+        - {type: harv, owner: agent, position: [14, 10], spawn_point: 0}
+        # spawn_point 1 — SOUTH base (y=28..32); near patches at y=28/32.
+        - {type: fact, owner: agent, position: [8, 28], spawn_point: 1}
+        - {type: proc, owner: agent, position: [12, 28], spawn_point: 1}
+        - {type: tent, owner: agent, position: [12, 32], spawn_point: 1}
+        - {type: powr, owner: agent, position: [8, 32], spawn_point: 1}
+        - {type: weap, owner: agent, position: [16, 32], spawn_point: 1}
+        - {type: harv, owner: agent, position: [14, 28], spawn_point: 1}
+        # Symmetric near-patch ore geometry — placed at BOTH
+        # latitudes so the income loop is equal per spawn (neutral
+        # actors aren't filtered by spawn_point, so duplicating
+        # both pairs is correct).
+        - {type: mine, owner: neutral, position: [22, 10]}
+        - {type: mine, owner: neutral, position: [22, 14]}
+        - {type: mine, owner: neutral, position: [22, 28]}
+        - {type: mine, owner: neutral, position: [22, 32]}
+        - {type: e1, owner: enemy, position: [120, 36], stance: 0}
+    win_condition:
+      all_of:
+        - cash_gte: 6500
+        - within_ticks: 4000
+    # within_ticks ≤ 93+90·45 = 4143 ⇒ reachable in max_turns;
+    # after_ticks=4001 ⇒ non-finisher is a real LOSS.
+    fail_condition:
+      any_of:
+        - after_ticks: 4001
+        - not: {has_building: fact}
+        - not: {unit_type_count_gte: {type: harv, n: 1}}
+    max_turns: 46

openra_bench/scenarios/packs/lh-100-turn-marathon-survival.yaml

@@ -0,0 +1,357 @@
+# lh-100-turn-marathon-survival.yaml
+#
+# REASONING capability — Group G long-horizon. Very-Late "marathon
+# survival" pack: keep the base alive UNDER SUSTAINED HUNT PRESSURE
+# for the full 100-turn budget. The win is gated on FOUR things still
+# being true at the end of the run:
+#   1. has_building: fact          # the base still stands
+#   2. own_units_gte: 3            # a minimum garrison is alive
+#   3. building_count_gte pbox 2   # at least two pillboxes were built
+#   4. after_ticks N (survived)    # the agent reached the end of the
+#      AND within_ticks N+x        # episode (no early stop / draw)
+#
+# The discrimination is NOT a single micro decision; it is the
+# SUSTAINED CADENCE over ~100 turns of:
+#   - reinforce: train fresh e1/e3 every few turns to replace losses
+#     (hunt bot trickles enemy units in across the whole episode)
+#   - defend: keep ≥2 pbox up; rebuild a razed one immediately
+#   - repair: keep fact/pbox/proc above critical HP (the `repair` tool
+#     toggles autorepair; without it a stripped pbox lane falls in
+#     the 60-90 turn window)
+#   - economy: keep the harvester(s) flowing — empty silos = no new
+#     units = the garrison bleeds out by turn ~70-80
+#
+# Wave geometry: instead of one large enemy stack closing in turn 1
+# (which would either be blunted forever or roll the base before turn
+# ~25), the pack STAGGERS multiple hunt squads along the east-west
+# axis at increasing x. Each squad arrives at a different time
+# window:
+#   x≈ 60  → reaches base ~tick 1200-1500  (turns ~14-18)
+#   x≈ 80  → reaches base ~tick 1800-2200  (turns ~20-25)
+#   x≈100  → reaches base ~tick 2400-3000  (turns ~27-34)
+#   x≈115  → reaches base ~tick 3000-3600  (turns ~33-40)
+# After the early waves are absorbed the trailing hunt squads keep
+# pressure on through the mid game; the agent's OWN reinforcement
+# cadence is what carries it from turn ~50 through the after_ticks
+# survival gate at tick 8100 (turn ~90).
+#
+# Real-world anchors:
+#   - lmgame-Bench multi-hour endurance benchmarks
+#   - SC2LE full-game / extended-game testing (sustained macro)
+#   - long-horizon credit assignment (survival has no proxy reward)
+#   - SRE extended on-call (sustained incident response, hours)
+#   - military endurance operations (continuous defensive ops)
+#
+# DISCRIMINATIONS (no defect, no cheat):
+#   - stall (observe only): LOSS — hunt rolls fact, no pbox built.
+#   - pure-defense-no-reinforce (build 2 pbox, never train units):
+#     LOSS — starting garrison bleeds out under sustained pressure,
+#     own_units drops below 1 before turn 90 ⇒ fail-clause fires
+#     (or own_units_gte:3 missed at the after_ticks gate).
+#   - pure-build-no-repair (build buildings but no repair / no
+#     unit replacement): LOSS — pbox/fact razed under sustained
+#     attrition; has_building:fact fails or pbox count drops < 2.
+#   - intended sustained-ops (reinforce + defend + repair across all
+#     100 turns): WIN — all four clauses still satisfied at the gate.
+#
+# ENGINE FACTS (CLAUDE.md):
+#   - max_turns 100 → reachable tick ≈ 93 + 90·99 = 9003. The win's
+#     after_ticks: 8100 AND within_ticks: 9003 BAND is reachable.
+#   - after_ticks IN WIN is structurally incompatible with auto-DRAW
+#     on enemy-elim — so we PLACE A PERSISTENT inert enemy `fact` far
+#     east; hunt squads also stay on the map until killed, but the
+#     anti-DRAW marker is the load-bearing one.
+#   - hunt bot: each unit pursues the nearest agent target. Squads
+#     placed at distinct x converge on the base at different times,
+#     giving SUSTAINED (not one-shot) pressure.
+#   - pbox costs 600, needs `tent`; tent is pre-placed.
+#   - tent trains e1 (100cr) and e3 (300cr); separate queue from
+#     defenses so build('pbox') and build('e1') in parallel works.
+#   - `repair` toggles autorepair on a unit/building ID.
+#   - harv → proc economy: pre-placed `harv` + `proc` + 2× mine give
+#     income from turn 1; the agent must KICK the harv at a mine to
+#     start the loop (kick is one harvest order).
+#
+# Validate (no model / no network):
+#   cd /Users/berta/Projects/OpenRA-Bench && \
+#   python3 -m openra_bench.scenarios.validate \
+#     openra_bench/scenarios/packs/lh-100-turn-marathon-survival.yaml
+
+meta:
+  id: lh-100-turn-marathon-survival
+  title: '100-Turn Marathon Survival — Sustain Defence, Reinforcement, and Repair'
+  capability: reasoning
+  real_world_meaning: >
+    A very-late single-episode endurance test: keep the base alive
+    under SUSTAINED enemy pressure for the full 100-turn budget. The
+    win is gated on the base, a minimum garrison, and the pillbox
+    line ALL still being intact at the end of the run, not on a
+    one-shot decision. The intended capability is the cadence of
+    reinforcement (train new infantry every few turns), repair
+    (toggle autorepair on damaged defences), and economic stewardship
+    (keep the refinery's harvester flowing). Stalling, pure defence
+    without reinforcement, and pure construction without repair all
+    lose; only sustained operations survive to the after-ticks gate.
+  robotics_analogue: >
+    Long-horizon autonomous operation under continuous external
+    pressure: an extended on-call / extended deployment where there
+    is no single decisive action, only the discipline of sustained
+    maintenance — repair work, supply replenishment, force
+    rotation — across the entire window. Credit only arrives at the
+    end of the window if every subsystem is still up.
+  benchmark_anchor:
+    - "lmgame-Bench multi-hour endurance"
+    - "SC2LE full-game / extended-game testing"
+    - "long-horizon credit assignment"
+    - "SRE extended on-call / military endurance ops"
+  author: openra-bench
+
+base_map: rush-hour-arena
+
+base:
+  agent:
+    faction: allies
+  enemy:
+    faction: soviet
+    bot_type: hunt
+  tools:
+    - observe
+    - build
+    - place_building
+    - harvest
+    - move_units
+    - attack_unit
+    - attack_move
+    - repair
+    - sell
+    - stop
+  planning: true
+  termination:
+    max_ticks: 40000
+
+starting_cash: 1000
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # 90-turn budget → reachable tick ≈ 93 + 90·89 = 8103.
+  # Smaller hunt presence (3 staggered squads), forgiving after_ticks
+  # gate (7200 = ~turn 80), within_ticks 8103 (= max).
+  # Stall / pure-defense / pure-build LOSE; intended sustained WINS.
+  easy:
+    description: >
+      Survive a 90-turn endurance episode under sustained hunt pressure.
+      Pre-placed at the west: construction yard (fact), barracks
+      (tent), power plant (powr), refinery (proc), harvester (harv),
+      two mines, and 4 starting riflemen. THREE staggered enemy
+      squads at increasing distance close in over the course of the
+      game — early ones arrive ~turn 15, late ones ~turn 35, and
+      trailing fire keeps coming. To WIN you must, at tick 7200+,
+      STILL have: the construction yard alive, ≥3 of your own units
+      alive, and ≥2 pillboxes (pbox) you built. Stalling loses to
+      the first wave; only building pbox without ever training fresh
+      infantry leaves the garrison too thin (≥3 units fails); only
+      training infantry without pbox lets the base get rushed down.
+      Use repair to keep the pbox line standing.
+    starting_cash: 1000
+    overrides:
+      actors:
+        # Agent base — vulnerable buildings (fact, proc, powr) WEST;
+        # tent + future pbox lane mouth to the EAST so the hunt squads
+        # hit the defences before the income building.
+        - {type: fact, owner: agent, position: [10, 20]}
+        - {type: tent, owner: agent, position: [8,  18]}
+        - {type: powr, owner: agent, position: [6,  20]}
+        - {type: powr, owner: agent, position: [6,  22]}
+        - {type: proc, owner: agent, position: [6,  18]}
+        - {type: harv, owner: agent, position: [8,  22]}
+        # Two ore patches WEST of base so the harv loop never crosses
+        # the eastern lane the hunt squads attack down.
+        - {type: mine, owner: neutral, position: [2,  20]}
+        - {type: mine, owner: neutral, position: [2,  18]}
+        # 4 starting defenders (riflemen) at the EAST lane mouth so
+        # `own_units_gte:1` is satisfied on turn 1 and the first wave
+        # has something to engage before the agent's first pbox lands.
+        - {type: e1,   owner: agent, position: [16, 20], stance: 3, count: 4}
+        # THREE staggered hunt squads at increasing x → arrive in
+        # successive time windows.
+        - {type: e1, owner: enemy, position: [60, 20], stance: 3, count: 2}
+        - {type: e1, owner: enemy, position: [80, 20], stance: 3, count: 2}
+        - {type: e1, owner: enemy, position: [100, 20], stance: 3, count: 2}
+        # Inert enemy `fact` marker far east — prevents engine
+        # auto-DRAW on enemy-elim once the hunt squads die. Without
+        # this the after_ticks-in-win gate collapses to DRAW.
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {has_building: fact}
+        - {own_units_gte: 3}
+        - {building_count_gte: {type: pbox, n: 2}}
+        - {after_ticks: 7200}
+        - {within_ticks: 8103}
+    # Fail must fire whenever the survival gate is reached without
+    # ALL win clauses also being true (else the episode ends as a DRAW
+    # — CLAUDE.md rule 3). Win is evaluated FIRST in eval_core, so the
+    # broad `after_ticks: 7200` fail only bites if win is false; that
+    # gives us "didn't keep all four things alive ⇒ LOSS, not draw".
+    fail_condition:
+      any_of:
+        - {after_ticks: 7200}
+        - {not: {has_building: fact}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 90
+
+  # ── MEDIUM ───────────────────────────────────────────────���───────
+  # +1 controlled variable: HEAVIER staggered pressure (5 squads, e1+e3
+  # mix) and the FULL 100-turn budget. The after_ticks gate (8100 =
+  # ~turn 90) sits comfortably under reachable tick 9003 = max.
+  medium:
+    description: >
+      Survive a full 100-turn endurance episode under sustained
+      hunt pressure. Pre-placed at the west: construction yard
+      (fact), barracks (tent), power plant (powr), refinery (proc),
+      harvester (harv), two mines, and 4 starting riflemen.
+      FIVE staggered enemy squads (rifle + rocket mix) close in
+      over the course of the game — early squads arrive ~turn 15,
+      mid ~turn 25-35, trailing ~turn 40-50 and pressure continues
+      through the late game. To WIN you must, at tick 8100+, STILL
+      have: the construction yard alive, ≥3 of your own units alive,
+      and ≥2 pillboxes (pbox) you built, AND survive until tick
+      9003 (turn 100). Stalling loses to the first wave; building
+      only pbox without retraining infantry leaves the garrison
+      bled below 3 by the late game; building only infantry without
+      pbox loses the base to the rocket squads. Use repair to keep
+      the pbox line standing.
+    starting_cash: 1000
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 20]}
+        - {type: tent, owner: agent, position: [8,  18]}
+        - {type: powr, owner: agent, position: [6,  20]}
+        - {type: powr, owner: agent, position: [6,  22]}
+        - {type: proc, owner: agent, position: [6,  18]}
+        - {type: harv, owner: agent, position: [8,  22]}
+        - {type: mine, owner: neutral, position: [2,  20]}
+        - {type: mine, owner: neutral, position: [2,  18]}
+        # 4 starting riflemen (own_units_gte:1 satisfied turn 1).
+        - {type: e1,   owner: agent, position: [16, 20], stance: 3, count: 4}
+        # FIVE staggered hunt squads at distinct x positions for
+        # SUSTAINED (not one-shot) pressure across all 100 turns.
+        # Mix in 1 e3 (rocket) per mid/late squad so a pbox without
+        # repair gets bled down.
+        - {type: e1, owner: enemy, position: [60,  20], stance: 3, count: 2}
+        - {type: e1, owner: enemy, position: [75,  18], stance: 3, count: 2}
+        - {type: e3, owner: enemy, position: [75,  22], stance: 3, count: 1}
+        - {type: e1, owner: enemy, position: [90,  20], stance: 3, count: 2}
+        - {type: e3, owner: enemy, position: [90,  18], stance: 3, count: 1}
+        - {type: e1, owner: enemy, position: [105, 20], stance: 3, count: 2}
+        - {type: e3, owner: enemy, position: [105, 22], stance: 3, count: 1}
+        - {type: e1, owner: enemy, position: [115, 20], stance: 3, count: 2}
+        # Inert enemy `fact` marker (anti-DRAW).
+        - {type: fact, owner: enemy, position: [120, 22]}
+    win_condition:
+      all_of:
+        - {has_building: fact}
+        - {own_units_gte: 3}
+        - {building_count_gte: {type: pbox, n: 2}}
+        - {after_ticks: 8100}
+        - {within_ticks: 9003}
+    # Fail bites the moment the survival gate opens (after_ticks: 8100)
+    # — win is evaluated FIRST so the fail only fires if the win
+    # all-of is unsatisfied at that tick (CLAUDE.md rule 3: non-win
+    # must be a real LOSS, not a draw).
+    fail_condition:
+      any_of:
+        - {after_ticks: 8100}
+        - {not: {has_building: fact}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 100
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 controlled variable: HEAVIER pressure (six staggered squads,
+  # more e3 rockets) AND ≥2 agent spawn_point groups (NORTH y=12 /
+  # SOUTH y=28) so a single memorised opening can't generalise.
+  # Budget extended to 120 turns → reachable tick ≈ 93 + 90·119 =
+  # 10803; after_ticks gate at 9900 (= ~turn 110) sits comfortably
+  # below. Two parallel sets of hunt squads (north + south latitudes)
+  # always place — enemy actors ignore spawn_point — so whichever
+  # latitude the agent occupies catches one converging band while
+  # the OTHER also turns inward.
+  hard:
+    description: >
+      Survive a 120-turn endurance episode under sustained pressure
+      from TWO latitudes. Your base stages from a seed-chosen
+      latitude (NORTH or SOUTH) — a single memorised pbox cell cannot
+      generalise. Pre-placed at your west base: construction yard
+      (fact), barracks (tent), power plant (powr), refinery (proc),
+      harvester (harv), two mines, and 4 starting riflemen. SIX
+      staggered hunt squads (rifle + rocket mix) close in across
+      BOTH latitudes — the converging band hits early ~turn 15 and
+      pressure trickles through the late game. To WIN you must, at
+      tick 9900+, STILL have: the construction yard alive, ≥3 of
+      your own units alive, and ≥2 pillboxes (pbox) you built, AND
+      survive until tick 10803 (turn 120). Stall / pure-defense /
+      pure-build all lose; only sustained reinforcement + repair +
+      defence carry the agent through the gate.
+    starting_cash: 1500
+    overrides:
+      actors:
+        # NORTH base spawn (spawn_point 0). Layout: fact, proc, powr
+        # WEST; tent + pbox lane mouth EAST.
+        - {type: fact, owner: agent, position: [10, 12], spawn_point: 0}
+        - {type: tent, owner: agent, position: [8,  10], spawn_point: 0}
+        - {type: powr, owner: agent, position: [6,  12], spawn_point: 0}
+        - {type: powr, owner: agent, position: [6,  14], spawn_point: 0}
+        - {type: proc, owner: agent, position: [6,  10], spawn_point: 0}
+        - {type: harv, owner: agent, position: [8,  14], spawn_point: 0}
+        - {type: e1,   owner: agent, position: [16, 12], stance: 3, count: 6, spawn_point: 0}
+        - {type: e3,   owner: agent, position: [16, 13], stance: 3, count: 2, spawn_point: 0}
+        # SOUTH base spawn (spawn_point 1) — symmetric.
+        - {type: fact, owner: agent, position: [10, 28], spawn_point: 1}
+        - {type: tent, owner: agent, position: [8,  30], spawn_point: 1}
+        - {type: powr, owner: agent, position: [6,  28], spawn_point: 1}
+        - {type: powr, owner: agent, position: [6,  26], spawn_point: 1}
+        - {type: proc, owner: agent, position: [6,  30], spawn_point: 1}
+        - {type: harv, owner: agent, position: [8,  26], spawn_point: 1}
+        - {type: e1,   owner: agent, position: [16, 28], stance: 3, count: 6, spawn_point: 1}
+        - {type: e3,   owner: agent, position: [16, 27], stance: 3, count: 2, spawn_point: 1}
+        # Two ore patches, one per latitude (neutral actors are not
+        # spawn-filtered — both always placed). Mines WEST of base so
+        # the harv loop doesn't cross the lane.
+        - {type: mine, owner: neutral, position: [2,  12]}
+        - {type: mine, owner: neutral, position: [2,  28]}
+        # Staggered hunt squads at TWO latitudes. Enemy actors don't
+        # honour spawn_point — all placed. The hunt bot drives each
+        # unit at the nearest agent target, so whichever latitude the
+        # agent base occupies will be hit by the matching band first;
+        # the OTHER band's units also turn inward over time (they
+        # don't respect lanes — closest-target-pursuit). Composition
+        # is tuned so the intended sustained-ops policy CAN survive
+        # all 120 turns from EITHER spawn — the redundancy across
+        # latitudes is the seed-driven uncontrolled variable, not a
+        # raw-count amplifier.
+        - {type: e1, owner: enemy, position: [70,  12], stance: 3, count: 2}
+        - {type: e1, owner: enemy, position: [70,  28], stance: 3, count: 2}
+        - {type: e1, owner: enemy, position: [90,  12], stance: 3, count: 2}
+        - {type: e3, owner: enemy, position: [90,  14], stance: 3, count: 1}
+        - {type: e1, owner: enemy, position: [90,  28], stance: 3, count: 2}
+        - {type: e3, owner: enemy, position: [90,  26], stance: 3, count: 1}
+        - {type: e1, owner: enemy, position: [110, 12], stance: 3, count: 2}
+        - {type: e1, owner: enemy, position: [110, 28], stance: 3, count: 2}
+        # Inert enemy `fact` marker far east (anti-DRAW).
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {has_building: fact}
+        - {own_units_gte: 3}
+        - {building_count_gte: {type: pbox, n: 2}}
+        - {after_ticks: 9900}
+        - {within_ticks: 10803}
+    # Fail bites the moment the survival gate opens (after_ticks:
+    # 9900) — win is evaluated FIRST so the fail only fires if the
+    # win all-of is unsatisfied at that tick (CLAUDE.md rule 3).
+    fail_condition:
+      any_of:
+        - {after_ticks: 9900}
+        - {not: {has_building: fact}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 120

openra_bench/scenarios/packs/lh-build-army-coordinate-multifront-attack.yaml

@@ -0,0 +1,322 @@
+# lh-build-army-coordinate-multifront-attack.yaml
+#
+# REASONING capability — Group G long-horizon. Late-game two-phase
+# operational plan: ASSEMBLE A REAL ARMY (≥N medium tanks) **THEN**
+# COMMIT THAT ARMY TO A SIMULTANEOUS TWO-FRONT ATTACK against TWO
+# separated enemy `fact` markers (one in the NE corner at (130,15),
+# one in the SE corner at (130,45)). Both fact must be razed inside
+# the shared deadline.
+#
+# Why `then:` (not `all_of`): the win is `then:` { army-assembled,
+# NE-fact-razed-in-region, SE-fact-razed-in-region } so the army
+# clause must latch IN ORDER before the two destruction clauses can
+# count. A "send the 2 starter units now and never build" play is
+# strictly insufficient — it cannot raze both fact in time AND it
+# trips the army clause if both starter units get killed early
+# (forcing assembly anyway). The two-front geometry combined with the
+# 120-cell separation between NE and SE means a single mass that
+# walks to ONE corner cannot then trek ~30 cells south and raze the
+# OTHER corner inside the clock; only build-then-SPLIT wins.
+#
+# Real-world anchors (spec):
+#   - SC2 macro + multi-prong push (mass up tanks, then 2-prong move)
+#   - military operational planning: force build, then theater-wide
+#     assault on two simultaneous objectives
+#   - PERT theater-wide ops sequencing
+#   - industrial product launch: build inventory then multi-region
+#     rollout (you cannot ship to two regions without enough stock,
+#     and you cannot ship to one then the other inside the launch
+#     window — both regions must be supplied at once)
+#
+# ENGINE NOTES (per CLAUDE.md):
+#   - enemy actors don't honour spawn_point — both NE and SE enemy
+#     fact place regardless of which agent spawn group fires; this
+#     is exactly what we want (the two enemy targets are symmetric
+#     and always present; what flips per seed is the agent base
+#     latitude → which front is the "near" vs "far" of the split).
+#   - `enemy_key_buildings_destroyed_in_region` requires the
+#     destroy event RECORD to match (type, x, y, radius); we pass
+#     `radius: 8` (the predicate uses `radius`, not `r`).
+#   - tick/turn: max tick = 93 + 90·(max_turns-1). For
+#     max_turns: 80 → max tick 7203 ≥ within_ticks 7200 ✓.
+#
+# Validate:
+#   cd /Users/berta/Projects/OpenRA-Bench && \
+#   python3 -m openra_bench.scenarios.validate \
+#     openra_bench/scenarios/packs/lh-build-army-coordinate-multifront-attack.yaml
+
+meta:
+  id: lh-build-army-coordinate-multifront-attack
+  title: 'Build Army → Coordinate Multi-Front Attack — Mass-Then-Split'
+  capability: reasoning
+  real_world_meaning: >
+    Late-game two-phase operational plan: first ASSEMBLE a real
+    fighting force (≥N medium tanks built from the pre-placed war
+    factory), then COMMIT that force to a simultaneous TWO-FRONT
+    assault on two separated enemy headquarters (NE and SE corners).
+    The `then:` composite enforces the assemble-before-attack ordering
+    and the 120-cell NE↔SE separation enforces the SPLIT — a single
+    mass cannot raze both corners in sequence inside the clock; only
+    build-then-split wins. Sending only the 2 starter units to each
+    front fails (insufficient firepower per prong); stalling fails on
+    the clock; one-front-only fails on the second destruction clause.
+  robotics_analogue: >
+    Theater-wide operational sequencing: a force must be brought to
+    minimum operational strength BEFORE being committed, and once
+    committed must be split across two simultaneous objectives in
+    different theatres under a single shared deadline. A serialized
+    "clear theatre A then redeploy to B" plan blows the time budget;
+    a "commit understrength to both" plan loses both engagements.
+  benchmark_anchor:
+    - "SC2 macro-then-multi-prong-attack"
+    - "military operational planning (force build then theater assault)"
+    - "PERT theater-wide ops sequencing"
+    - "industrial product launch: build inventory then multi-region rollout"
+  author: openra-bench
+
+base_map: rush-hour-arena
+
+base:
+  agent:
+    faction: allies
+  enemy:
+    faction: soviet
+    bot_type: ''
+  tools:
+    - observe
+    - build
+    - place_building
+    - move_units
+    - attack_unit
+    - attack_move
+    - stop
+  planning: true
+  termination:
+    max_ticks: 40000
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Loose-bar rehearsal: 4-tank army threshold, no enemy pressure
+  # (bot disabled, no defenders), generous clock. The chain still
+  # bites: build to ≥4 tanks BEFORE either destruction clause counts,
+  # and BOTH NE+SE fact must be razed (not just one).
+  easy:
+    description: >
+      Pre-placed at the west base: fact + tent + powr + weap + fix +
+      two starter medium tanks (2tnk). Two enemy construction yards
+      sit at the eastern corners — NE at (130,15) and SE at (130,45),
+      120 cells apart. Two passive defenders (no bot, no aggression)
+      guard each. Build a real army first (≥4 medium tanks total),
+      THEN raze BOTH enemy fact in their corners — the NE corner AND
+      the SE corner — before tick 7200. The phases must happen IN
+      ORDER (army clause must latch FIRST). Stalling loses on the
+      clock; sending only the two starter tanks to a single corner
+      loses on the second destruction clause (the other corner stands).
+    starting_cash: 2000
+    overrides:
+      base_map: {generator: arena, width: 160, height: 60, cordon: 4}
+      actors:
+        # Agent base — fact + tent + powr + weap + fix at west. weap
+        # is PRE-PLACED so the agent only needs to BUILD tanks (no
+        # tech race; the long-horizon test is force-buildup + split-
+        # commit, not tech). `fix` is the 2tnk tech-prereq.
+        - {type: fact, owner: agent, position: [10, 30]}
+        - {type: tent, owner: agent, position: [10, 33]}
+        - {type: powr, owner: agent, position: [13, 30]}
+        - {type: weap, owner: agent, position: [13, 33]}
+        - {type: fix,  owner: agent, position: [16, 33]}
+        # Two starter tanks so the agent has SOMETHING to split with
+        # if it prematurely commits (so the "send 2 each front" lazy
+        # play is observable and LOSES on insufficient firepower).
+        - {type: 2tnk, owner: agent, position: [16, 28]}
+        - {type: 2tnk, owner: agent, position: [16, 30]}
+        # Ore patches so a built proc (if the agent chooses) has
+        # somewhere to harvest — but the starting_cash:2000 + free
+        # tents + free weap is enough to build the 4-tank threshold
+        # without econ.
+        - {type: mine, owner: neutral, position: [22, 30]}
+        - {type: mine, owner: neutral, position: [22, 33]}
+        # ── NE enemy base (fact + two passive defenders) ──
+        - {type: fact, owner: enemy, position: [130, 15]}
+        - {type: e1,   owner: enemy, position: [127, 15], stance: 2}
+        - {type: e1,   owner: enemy, position: [127, 17], stance: 2}
+        # ── SE enemy base (fact + two passive defenders) ──
+        - {type: fact, owner: enemy, position: [130, 45]}
+        - {type: e1,   owner: enemy, position: [127, 45], stance: 2}
+        - {type: e1,   owner: enemy, position: [127, 43], stance: 2}
+        # Persistent unarmed enemy MARKER at the far SE corner of the
+        # 160×60 arena — keeps the episode alive past any auto-`done`
+        # if both objective fact fall (the engine sets done when all
+        # enemy MustBeDestroyed buildings are gone). Without this, a
+        # one-or-two-tank policy that incidentally razes both fact
+        # auto-ends the episode at neither win nor loss → DRAW (the
+        # CLAUDE.md auto-done footgun). Placed deep enough that no
+        # intended-play tank ever finds it (won't be attacked).
+        - {type: fact, owner: enemy, position: [155, 55]}
+    win_condition:
+      all_of:
+        - then:
+            id: army-then-multifront-easy
+            clauses:
+              - {unit_type_count_gte: {type: 2tnk, n: 4}}            # P1: army
+              - enemy_key_buildings_destroyed_in_region:              # P2: NE razed
+                  {x: 130, y: 15, radius: 8, types: [fact]}
+              - enemy_key_buildings_destroyed_in_region:              # P3: SE razed
+                  {x: 130, y: 45, radius: 8, types: [fact]}
+        - within_ticks: 7200
+    fail_condition:
+      any_of:
+        - {after_ticks: 7201}
+        - {not: {building_count_gte: {type: fact, n: 1}}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 80
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # Spec'd middle: 6-tank army threshold, same dual NE+SE objective,
+  # same clock. A 4-tank "easy" play now under-resources the split.
+  # Defenders bump slightly to ensure 1-2 units per front cannot win.
+  medium:
+    description: >
+      Pre-placed at the west base: fact + tent + powr + weap + fix +
+      two starter medium tanks (2tnk). Two enemy construction yards
+      sit at the eastern corners — NE at (130,15) and SE at (130,45),
+      120 cells apart, each guarded by a small infantry picket. Build
+      a real army first (≥6 medium tanks total), THEN raze BOTH enemy
+      fact in their corners — the NE corner AND the SE corner — before
+      tick 7200. The phases must happen IN ORDER (`then:`): the army
+      clause must latch FIRST, then the two destruction clauses can
+      count. Stalling loses on the clock; one-front-only loses on the
+      second destruction clause; sending only 2-3 tanks per front
+      bounces off the picket and burns the clock without razing.
+    # 6 tanks × 850 = $5100; 2 starter tanks free ⇒ need to fund 4
+    # tanks = $3400. Starting cash $3500 fits with no income required
+    # (the test is force-buildup + split, not also force-econ).
+    starting_cash: 3500
+    overrides:
+      base_map: {generator: arena, width: 160, height: 60, cordon: 4}
+      actors:
+        - {type: fact, owner: agent, position: [10, 30]}
+        - {type: tent, owner: agent, position: [10, 33]}
+        - {type: powr, owner: agent, position: [13, 30]}
+        - {type: weap, owner: agent, position: [13, 33]}
+        - {type: fix,  owner: agent, position: [16, 33]}
+        - {type: 2tnk, owner: agent, position: [16, 28]}
+        - {type: 2tnk, owner: agent, position: [16, 30]}
+        - {type: mine, owner: neutral, position: [22, 30]}
+        - {type: mine, owner: neutral, position: [22, 33]}
+        # NE enemy base — fact + 3-unit picket (1 e3 anti-vehicle +
+        # 2 e1 riflemen) tuned so 2-3 tanks bounce / 4-6 tanks raze.
+        - {type: fact, owner: enemy, position: [130, 15]}
+        - {type: e3,   owner: enemy, position: [127, 15], stance: 2}
+        - {type: e1,   owner: enemy, position: [127, 17], stance: 2}
+        - {type: e1,   owner: enemy, position: [128, 17], stance: 2}
+        # SE enemy base — symmetric picket.
+        - {type: fact, owner: enemy, position: [130, 45]}
+        - {type: e3,   owner: enemy, position: [127, 45], stance: 2}
+        - {type: e1,   owner: enemy, position: [127, 43], stance: 2}
+        - {type: e1,   owner: enemy, position: [128, 43], stance: 2}
+        # Persistent unarmed enemy MARKER at the far SE corner —
+        # keeps the episode alive past auto-`done` if both objective
+        # fact fall (CLAUDE.md auto-done footgun).
+        - {type: fact, owner: enemy, position: [155, 55]}
+    win_condition:
+      all_of:
+        - then:
+            id: army-then-multifront-medium
+            clauses:
+              - {unit_type_count_gte: {type: 2tnk, n: 6}}
+              - enemy_key_buildings_destroyed_in_region:
+                  {x: 130, y: 15, radius: 8, types: [fact]}
+              - enemy_key_buildings_destroyed_in_region:
+                  {x: 130, y: 45, radius: 8, types: [fact]}
+        - within_ticks: 7200
+    fail_condition:
+      any_of:
+        - {after_ticks: 7201}
+        - {not: {building_count_gte: {type: fact, n: 1}}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 80
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 axis: 8-tank army threshold + TWO agent spawn_point groups.
+  # The agent base latitude round-robins between NORTH (y=18) and
+  # SOUTH (y=42) per seed; both objectives (NE 130,15 + SE 130,45)
+  # are always present, so the "near" vs "far" front flips per seed
+  # but the split-and-raze-both task is invariant. A memorised
+  # "north-prong heavy" or "always commit south first" opening
+  # cannot generalise across seeds.
+  hard:
+    description: >
+      Pre-placed at the west base (latitude round-robined between
+      NORTH y=18 and SOUTH y=42 per seed): fact + tent + powr + weap
+      + fix + two starter medium tanks (2tnk). Two enemy construction
+      yards sit at the eastern corners — NE at (130,15) and SE at
+      (130,45), 120 cells apart, each guarded by a small infantry
+      picket. Build a real army first (≥8 medium tanks total), THEN
+      raze BOTH enemy fact in their corners — the NE corner AND the
+      SE corner — before tick 7200. The phases must happen IN ORDER
+      (`then:`). Stalling, one-front-only, or sending 2-3 tanks per
+      front all LOSE. The seed-varied base latitude means a single
+      memorised opening cannot generalise across seeds (the "near"
+      front flips between NE and SE).
+    # 8 tanks × 850 = $6800; 2 starter tanks free ⇒ need $5100 for
+    # 6 more. Starting cash $5500 fits with no income required.
+    starting_cash: 5500
+    overrides:
+      base_map: {generator: arena, width: 160, height: 60, cordon: 4}
+      actors:
+        # NORTH base spawn (spawn_point 0) — y=18; NE (130,15) is
+        # the "near" front, SE (130,45) is the "far" one.
+        - {type: fact, owner: agent, position: [10, 18], spawn_point: 0}
+        - {type: tent, owner: agent, position: [10, 21], spawn_point: 0}
+        - {type: powr, owner: agent, position: [13, 18], spawn_point: 0}
+        - {type: weap, owner: agent, position: [13, 21], spawn_point: 0}
+        - {type: fix,  owner: agent, position: [16, 21], spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [16, 16], spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [16, 18], spawn_point: 0}
+        # SOUTH base spawn (spawn_point 1) — y=42; SE is "near", NE
+        # is "far". Geometry flips so the per-prong assignment must
+        # be re-computed per seed.
+        - {type: fact, owner: agent, position: [10, 42], spawn_point: 1}
+        - {type: tent, owner: agent, position: [10, 39], spawn_point: 1}
+        - {type: powr, owner: agent, position: [13, 42], spawn_point: 1}
+        - {type: weap, owner: agent, position: [13, 39], spawn_point: 1}
+        - {type: fix,  owner: agent, position: [16, 39], spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [16, 44], spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [16, 42], spawn_point: 1}
+        # Shared mid-map ore patches (no spawn_point → place for both).
+        # NOTE engine: enemy actors ignore spawn_point so the two
+        # enemy bases below ALWAYS place regardless of agent spawn.
+        - {type: mine, owner: neutral, position: [22, 30]}
+        - {type: mine, owner: neutral, position: [22, 33]}
+        # NE enemy base — fact + picket.
+        - {type: fact, owner: enemy, position: [130, 15]}
+        - {type: e3,   owner: enemy, position: [127, 15], stance: 2}
+        - {type: e1,   owner: enemy, position: [127, 17], stance: 2}
+        - {type: e1,   owner: enemy, position: [128, 17], stance: 2}
+        # SE enemy base — symmetric picket.
+        - {type: fact, owner: enemy, position: [130, 45]}
+        - {type: e3,   owner: enemy, position: [127, 45], stance: 2}
+        - {type: e1,   owner: enemy, position: [127, 43], stance: 2}
+        - {type: e1,   owner: enemy, position: [128, 43], stance: 2}
+        # Persistent unarmed enemy MARKER at the far SE corner —
+        # keeps the episode alive past auto-`done` if both objective
+        # fact fall (CLAUDE.md auto-done footgun).
+        - {type: fact, owner: enemy, position: [155, 55]}
+    win_condition:
+      all_of:
+        - then:
+            id: army-then-multifront-hard
+            clauses:
+              - {unit_type_count_gte: {type: 2tnk, n: 8}}
+              - enemy_key_buildings_destroyed_in_region:
+                  {x: 130, y: 15, radius: 8, types: [fact]}
+              - enemy_key_buildings_destroyed_in_region:
+                  {x: 130, y: 45, radius: 8, types: [fact]}
+        - within_ticks: 7200
+    fail_condition:
+      any_of:
+        - {after_ticks: 7201}
+        - {not: {building_count_gte: {type: fact, n: 1}}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 80

openra_bench/scenarios/packs/lh-defense-tech-second-base.yaml

@@ -0,0 +1,370 @@
+# lh-defense-tech-second-base.yaml
+#
+# REASONING capability — Group G long-horizon "secure-expand-with-tech"
+# 3-phase chain. The agent must (1) harden base #1 with pillboxes,
+# (2) tech up to a war factory, then (3) drive the spare MCV east and
+# deploy it as a second Construction Yard inside the briefed target
+# region.
+#
+# Uses the Wave-2 `then:` happened-before composite to ENFORCE STRICT
+# ORDER:
+#   PHASE 1: building_count_gte:{type:pbox, n:3}        # defend
+#   PHASE 2: has_building: weap                          # tech
+#   PHASE 3: building_in_region:{x:130,y:30,r:8,
+#            type:fact,count:1}                          # 2nd base
+# Per the `then` semantics each clause must be observed-true IN
+# SEQUENCE — pre-expanding before tech, or pre-teching before defence,
+# cannot satisfy the chain.
+#
+# A `patrol` scripted bot drips light, predictable harassment on
+# base #1 throughout the run — pure-expand (skip defences) loses the
+# base to the patrol; pure-defence (no MCV move + no weap) leaves the
+# chain stuck at phase 1 or 2; only the intended secure-expand-with-
+# tech sequence WINS.
+#
+# Sister packs:
+#   - `lh-opening-to-tech-to-army` (Wave-4 macro chain, 4 phases —
+#     proc → weap → ≥N 2tnk → attack enemy fact)
+#   - `tech-turtle-defensive-tech` (defence-then-tech with hunt-bot
+#     pressure)
+# This pack is the secure-expand-with-tech analogue: the terminal
+# clause is a SECOND BASE in a far region (multi-site ramp-up), not
+# a destroy clause.
+#
+# Real-world anchors (`meta.benchmark_anchor`):
+#   - SC2 secure-expand-with-tech (multi-base macro): harden home
+#     base, tech up, expand to a second base.
+#   - PlanBench multi-stage credit assignment.
+#   - Product roadmap: harden (perimeter/SLO) → R&D (tech upgrade)
+#     → new geography (second region).
+#   - Industrial: secure plant → R&D → build second plant.
+#
+# DISCRIMINATIONS (CLAUDE.md bar — no defect, no cheat):
+#   - stall (observe only): LOSS — clock + patrol razes fact.
+#   - pure-expand-skip-defence (move MCV east + deploy, skip pbox /
+#     weap): LOSS — chain stuck at phase 1 (pbox never built); the
+#     patrol also chews the base.
+#   - pure-defence-no-expand (build pbox+weap, never move MCV): LOSS —
+#     chain stuck at phase 3 (no 2nd fact in east region); clock
+#     expires.
+#   - intended secure-expand-with-tech (pbox×3, weap, then move MCV
+#     east + deploy): WIN.
+#
+# Engine facts used (CLAUDE.md / SCENARIO_QUALITY.md):
+#   - `pbox` cost 600, prereq `tent` (allied barracks pre-placed),
+#     defence queue.
+#   - `weap` cost ~2000, prereq `proc` (allied refinery — pre-placed
+#     so the queue accepts weap from turn 1 once cash is available).
+#   - MCV deploy: `Command.deploy([mcv_id])` removes the MCV and
+#     spawns an agent `fact` at (mcv_x-1, mcv_y-1). To land the new
+#     fact at e.g. (130,30) — the centre of the east target region —
+#     the MCV must reach (131,31) before deploying.
+#   - `patrol` scripted bot: hunts outward in alternating patrol
+#     legs from its spawn; light, predictable home-base pressure
+#     (per `openra-sim/src/scripted_bot.rs`).
+#   - Inert enemy `fact` marker far east prevents engine auto-DRAW
+#     on enemy-elim (CLAUDE.md auto-done footgun).
+#   - `then:` greedy advance: once a prior clause latches, any
+#     currently-true later clauses latch in the same evaluation.
+#
+# Validate (no model / no network):
+#   python3 -m pytest tests/test_lh_defense_tech_second_base.py -q
+
+meta:
+  id: lh-defense-tech-second-base
+  title: 'Secure → Tech → Second Base — 3-Phase Long-Horizon Chain'
+  capability: reasoning
+  real_world_meaning: >
+    A long single-episode macro plan whose final win depends on each
+    intermediate phase being observed-true in order: harden the home
+    base with static defences (pillboxes) under live patrol pressure,
+    unlock the tech tree (war factory), then commit the spare MCV
+    eastward to stand up a second Construction Yard inside the
+    briefed expansion region. The Wave-2 `then:` composite enforces
+    strict happened-before — a policy that expands before tech, or
+    teches before defences, cannot satisfy the chain.
+  robotics_analogue: >
+    Multi-site ramp-up of a long-horizon mission with strict stage
+    gating: harden the home site against active adversarial pressure,
+    bring the upgraded production capability online, then deploy a
+    base-builder platform to the designated expansion sector and
+    convert it into a second operational site — all within one
+    budget. Out-of-order completion (expand before hardening, or
+    expand before the upgraded capability is online) forfeits the
+    chain.
+  benchmark_anchor:
+    - "SC2 secure-expand-with-tech (multi-base macro)"
+    - "PlanBench multi-stage credit assignment"
+    - "product roadmap: harden → R&D → new market"
+    - "industrial: secure plant → R&D → second plant"
+  author: openra-bench
+
+# Pack-level base_map is the `rush-hour-arena` sentinel so the loader
+# can map-resolve before per-level overrides materialise the actual
+# 160x60 generator-spec arena .oramap (same pattern as
+# mfb-base-1-defend-base-2-build, expansion-balanced-2-base-defended).
+base_map: rush-hour-arena
+
+starting_cash: 3000
+
+base:
+  agent:
+    faction: allies
+  enemy:
+    faction: soviet
+    bot_type: patrol
+  tools:
+    - observe
+    - build
+    - place_building
+    - deploy
+    - harvest
+    - move_units
+    - attack_unit
+    - attack_move
+    - stop
+  planning: true
+  termination:
+    max_ticks: 40000
+  # Each level supplies its own actor list via overrides — keeps the
+  # per-tier patrol density / spawn variation audit-explicit.
+  actors: []
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Bare-skill rehearsal: looser bar (pbox≥2 instead of ≥3), a single
+  # light patrol band, generous clock. The chain still bites
+  # (pbox-first, weap-then, 2nd-base-finally) — pure-expand, pure-
+  # defence, stall all LOSE; intended secure-expand-with-tech WINS.
+  # max_turns 90 → reachable tick 93 + 90·89 = 8103 > 8000 ✓.
+  easy:
+    description: >
+      You hold base #1 in the WEST — a Construction Yard (fact),
+      barracks (tent), power plants (powr ×2), refinery (proc), a
+      harvester pre-kicked on the local ore patch, and 3 rifleman
+      defenders on AttackAnything. A spare MCV is staged east of
+      base #1 (~(40,30)) for your eventual expansion. A light Soviet
+      `patrol` band drips harassment on base #1. The mission is a
+      strict 3-phase chain (you must complete them IN THIS ORDER):
+      (1) build at least 2 pillboxes (pbox) at the home base,
+      (2) build a war factory (weap), (3) drive the spare MCV east
+      to the target region centred at (130,30) (radius 8) and
+      DEPLOY it there to stand up the SECOND Construction Yard.
+      Win = the 3-phase chain completed AND base #1 still standing
+      (fact present) before tick 8000. Stalling, skipping defences,
+      and never expanding all LOSE.
+    starting_cash: 3500
+    overrides:
+      base_map:
+        generator: arena
+        name: lh-defense-tech-second-base-arena
+        width: 160
+        height: 60
+        cordon: 4
+      actors:
+        # Agent base #1 (WEST). fact / tent / powr per spec, PLUS
+        # proc + harv + mine so income flows from turn 1 (the chain
+        # needs ~3800 cash on top of the cushion). Without harv
+        # income the bare starting_cash cannot reliably fund the
+        # pbox×2 + weap + MCV-fuel chain in budget.
+        - {type: fact, owner: agent, position: [10, 30]}
+        - {type: tent, owner: agent, position: [8,  28]}
+        - {type: powr, owner: agent, position: [6,  30]}
+        # Second powr — 2 pbox (-40) + weap (-30) drains ~70 power;
+        # one powr (+100 default) just covers it, but a second powr
+        # protects against the patrol shaving the first one (CLAUDE.md
+        # underpowered-queue footgun).
+        - {type: powr, owner: agent, position: [6,  32]}
+        - {type: proc, owner: agent, position: [6,  26]}
+        - {type: harv, owner: agent, position: [8,  32]}
+        - {type: mine, owner: neutral, position: [2,  30]}
+        # 3 rifleman defenders on AttackAnything at the EAST lane
+        # mouth to blunt the patrol's leading edge while pbox stand
+        # up.
+        - {type: e1, owner: agent, position: [16, 30], stance: 3, count: 3}
+        # Spare MCV staged ~30 cells east of base #1. To win, the
+        # agent must drive it ~90 cells further east and deploy at
+        # (131,31) → fact lands at (130,30) — exactly the target
+        # region centre.
+        - {type: mcv, owner: agent, position: [40, 30]}
+        # Light Soviet patrol band — easy: 2× e1 starting mid-map
+        # so the patrol bot drips harassment on base #1 (`patrol`
+        # bot alternates patrol legs outward from spawn; the
+        # nearest agent unit / structure attracts pressure).
+        - {type: e1, owner: enemy, position: [80, 30], stance: 3, count: 2}
+        # Persistent unarmed enemy `fact` marker far east — outside
+        # both the target region (radius 8 around (130,30)) and the
+        # patrol band, so it doesn't satisfy any agent predicate
+        # and doesn't perturb the patrol behaviour. Prevents engine
+        # auto-DRAW on enemy-elim (the patrol band could otherwise
+        # be killed and end the episode prematurely).
+        - {type: fact, owner: enemy, position: [154, 4]}
+    win_condition:
+      all_of:
+        - then:
+            id: defense-tech-second-base-easy
+            clauses:
+              - {building_count_gte: {type: pbox, n: 2}}
+              - {has_building: weap}
+              - {building_in_region:
+                   {x: 130, y: 30, radius: 8, type: fact, count: 1}}
+        - {has_building: fact}
+        - {within_ticks: 8000}
+    fail_condition:
+      any_of:
+        - {after_ticks: 8001}
+        - {not: {has_building: fact}}
+    max_turns: 90
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # Full 3-phase chain at the spec bar (pbox≥3) under a slightly
+  # heavier patrol band (3× e1 + 1× e3) on a tighter clock.
+  # max_turns 80 → reachable tick 93 + 90·79 = 7203 > 7200 ✓.
+  medium:
+    description: >
+      Same secure-expand-with-tech setup, tighter clock and heavier
+      patrol pressure. You hold base #1 in the WEST (fact, tent,
+      proc, harv, 2× powr, 3 defenders). A spare MCV is staged east
+      of base #1. A Soviet `patrol` band — 3 rifle infantry + 1
+      rocket soldier (e3) — drips pressure on base #1. The mission
+      is a strict 3-phase chain (IN THIS ORDER):
+      (1) at least 3 pillboxes (pbox) at base #1,
+      (2) a war factory (weap),
+      (3) the spare MCV deployed inside the eastern target region
+      centred at (130,30), radius 8 — the new fact lands at
+      (mcv_x-1, mcv_y-1), so drive the MCV to ~(131,31) and deploy.
+      Win = the chain completed AND base #1 still standing before
+      tick 7200. Stall, pure-expand-skip-defences, and pure-defence-
+      no-expand all LOSE.
+    starting_cash: 3000
+    overrides:
+      base_map:
+        generator: arena
+        name: lh-defense-tech-second-base-arena
+        width: 160
+        height: 60
+        cordon: 4
+      actors:
+        - {type: fact, owner: agent, position: [10, 30]}
+        - {type: tent, owner: agent, position: [8,  28]}
+        - {type: powr, owner: agent, position: [6,  30]}
+        - {type: powr, owner: agent, position: [6,  32]}
+        - {type: proc, owner: agent, position: [6,  26]}
+        - {type: harv, owner: agent, position: [8,  32]}
+        - {type: mine, owner: neutral, position: [2,  30]}
+        - {type: e1, owner: agent, position: [16, 30], stance: 3, count: 3}
+        - {type: mcv, owner: agent, position: [40, 30]}
+        # Heavier patrol band — 3 e1 + 1 e3 (rocket soldier adds
+        # anti-armour pressure if the MCV is exposed en route).
+        - {type: e1, owner: enemy, position: [80, 30], stance: 3, count: 3}
+        - {type: e3, owner: enemy, position: [82, 30], stance: 3, count: 1}
+        # Persistent unarmed enemy `fact` marker far east (anti-DRAW).
+        - {type: fact, owner: enemy, position: [154, 4]}
+    win_condition:
+      all_of:
+        - then:
+            id: defense-tech-second-base-medium
+            clauses:
+              - {building_count_gte: {type: pbox, n: 3}}
+              - {has_building: weap}
+              - {building_in_region:
+                   {x: 130, y: 30, radius: 8, type: fact, count: 1}}
+        - {has_building: fact}
+        - {within_ticks: 7200}
+    fail_condition:
+      any_of:
+        - {after_ticks: 7201}
+        - {not: {has_building: fact}}
+    max_turns: 80
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 axis vs medium: a FOURTH phase (rebuild the proc — the
+  # secure-expand-with-tech chain extended to a "harden → tech →
+  # expand → re-secure income" sequence) AND TWO patrol bands hitting
+  # from TWO latitudes (north + south), AND ≥2 spawn_point groups so
+  # the agent base latitude varies by seed.
+  #
+  # The fourth chain clause is `building_count_gte: {type: proc, n: 2}`
+  # — the agent must build a SECOND refinery at the new eastern base
+  # to stabilise income on the expansion (a real "second plant comes
+  # online" semantic, not just a re-place of the home refinery).
+  #
+  # max_turns 80 → reachable tick 93 + 90·79 = 7203 > 7200 ✓.
+  hard:
+    description: >
+      Same secure-expand-with-tech mission under richer pressure and
+      with a fourth phase tacked on. Your base #1 stages from a
+      seed-chosen latitude (NORTH y=22 or SOUTH y=38) so a single
+      memorised pillbox placement cannot generalise. Two Soviet
+      `patrol` bands hit from two different latitudes (north and
+      south). The mission is a strict 4-phase chain (IN THIS ORDER):
+      (1) at least 3 pillboxes (pbox) at base #1,
+      (2) a war factory (weap),
+      (3) the spare MCV deployed inside the eastern target region
+      centred at (130,30), radius 8,
+      (4) at least 2 refineries (proc) own — i.e. a SECOND refinery
+      online to stabilise income on the new expansion.
+      Win = the chain completed AND base #1 still standing before
+      tick 7200. Stall, pure-expand, pure-defence, and skip-proc-2
+      all LOSE.
+    starting_cash: 3500
+    overrides:
+      base_map:
+        generator: arena
+        name: lh-defense-tech-second-base-arena
+        width: 160
+        height: 60
+        cordon: 4
+      actors:
+        # NORTH base spawn (spawn_point 0). Layout mirrors easy/
+        # medium at y=22.
+        - {type: fact, owner: agent, position: [10, 22], spawn_point: 0}
+        - {type: tent, owner: agent, position: [8,  20], spawn_point: 0}
+        - {type: powr, owner: agent, position: [6,  22], spawn_point: 0}
+        - {type: powr, owner: agent, position: [6,  24], spawn_point: 0}
+        - {type: proc, owner: agent, position: [6,  18], spawn_point: 0}
+        - {type: harv, owner: agent, position: [8,  24], spawn_point: 0}
+        - {type: e1,   owner: agent, position: [16, 22], stance: 3, count: 3, spawn_point: 0}
+        - {type: mcv,  owner: agent, position: [40, 22], spawn_point: 0}
+        # SOUTH base spawn (spawn_point 1). Symmetric at y=38.
+        - {type: fact, owner: agent, position: [10, 38], spawn_point: 1}
+        - {type: tent, owner: agent, position: [8,  40], spawn_point: 1}
+        - {type: powr, owner: agent, position: [6,  38], spawn_point: 1}
+        - {type: powr, owner: agent, position: [6,  36], spawn_point: 1}
+        - {type: proc, owner: agent, position: [6,  42], spawn_point: 1}
+        - {type: harv, owner: agent, position: [8,  36], spawn_point: 1}
+        - {type: e1,   owner: agent, position: [16, 38], stance: 3, count: 3, spawn_point: 1}
+        - {type: mcv,  owner: agent, position: [40, 38], spawn_point: 1}
+        # Two ore patches — one per spawn cluster — placed west of
+        # each base so the harv loop doesn't cross the patrol lane.
+        # (Neutral actors are not filtered by spawn_point — both
+        # always place, per CLAUDE.md.)
+        - {type: mine, owner: neutral, position: [2,  22]}
+        - {type: mine, owner: neutral, position: [2,  38]}
+        # Two patrol bands at distinct latitudes (both ALWAYS placed
+        # — enemy actors with no spawn_point are not filtered, per
+        # CLAUDE.md). Whichever lane the agent's base occupies is
+        # hit; the OTHER band wanders the off-axis half of the map.
+        - {type: e1, owner: enemy, position: [80, 22], stance: 3, count: 2}
+        - {type: e3, owner: enemy, position: [82, 22], stance: 3, count: 1}
+        - {type: e1, owner: enemy, position: [80, 38], stance: 3, count: 2}
+        - {type: e3, owner: enemy, position: [82, 38], stance: 3, count: 1}
+        # Persistent unarmed enemy `fact` marker far east (anti-DRAW).
+        - {type: fact, owner: enemy, position: [154, 4]}
+    win_condition:
+      all_of:
+        - then:
+            id: defense-tech-second-base-hard
+            clauses:
+              - {building_count_gte: {type: pbox, n: 3}}
+              - {has_building: weap}
+              - {building_in_region:
+                   {x: 130, y: 30, radius: 8, type: fact, count: 1}}
+              - {building_count_gte: {type: proc, n: 2}}
+        - {has_building: fact}
+        - {within_ticks: 7200}
+    fail_condition:
+      any_of:
+        - {after_ticks: 7201}
+        - {not: {has_building: fact}}
+    max_turns: 80

openra_bench/scenarios/packs/lh-multi-checkpoint-5-plus.yaml

@@ -0,0 +1,324 @@
+# lh-multi-checkpoint-5-plus.yaml
+#
+# ACTION capability — Group G long-horizon. The Late-tier sibling of
+# `lh-opening-to-tech-to-army` (4-phase chain) that goes one further:
+# a Wave-2 `then:` happened-before chain of FIVE+ ordered checkpoints
+# in a single episode. This is the PERT critical-path / PlanBench
+# long-sequencing anchor — a "5+ ordered checkpoints" test that the
+# 4-phase pack cannot express on its own.
+#
+# The chain genuinely needs order because it MIXES checkpoint kinds:
+#   - building states (has_building: proc, weap)
+#   - quantitative production (unit_type_count_gte: 2tnk)
+#   - episode-aggregate combat (units_killed_gte: 3)
+#   - terminal destruction (enemy_key_buildings_destroyed: fact)
+# A policy that scores kills BEFORE the army exists cannot satisfy
+# clause-4 BEFORE clause-3; the `then:` latch advances index-by-index
+# only, so out-of-order completion stalls forever.
+#
+# Sister pack to `lh-opening-to-tech-to-army` (4-phase econ→tech→army→
+# engage) — this pack tightens the same idiom by stretching it to
+# 5 (medium) / 6 (hard) checkpoints, which is the regime that
+# discriminates models on long ordered SOP execution / PERT critical
+# path planning. Easy reverts to 3 phases (the baseline) so the
+# difficulty axis is "phase count" rather than "phase kind".
+#
+# Real-world anchors:
+#   - PERT/CPM project management (each milestone gates the next)
+#   - PlanBench long-sequencing (5+ step ordered plans)
+#   - long SOP execution (5+ phase ordered procedures)
+#   - military operation: phase lines (PL ALPHA → ... → PL FOXTROT)
+#
+# ENGINE NOTES (per CLAUDE.md):
+#   - `then:` advances clause-by-clause; a satisfied earlier clause
+#     stays latched even if its predicate later becomes false (e.g.,
+#     proc gets destroyed) — only the order matters.
+#   - The agent has 4 pre-placed combat units; phase-4 (3 kills) is
+#     satisfied by attacking the static defenders next to the enemy
+#     fact. The defenders are HOLD-FIRE (stance:0) so a "rush the
+#     fact and kill 3" play CAN score kills early — but the `then:`
+#     latch will not credit those kills towards clause-4 until clauses
+#     1-3 (proc → weap → 2 tanks) have latched in order.
+#   - `bot_type: ''` (no scripted bot) — the enemy is static so the
+#     anti-stall pressure comes purely from the `within_ticks: 7200`
+#     clock, not from incoming raiders.
+#   - `harvest` is intentionally omitted from tools; the auto-harvester
+#     spawned by `proc` near the ore patch covers income without the
+#     agent needing to micro-manage it. This keeps the tool surface
+#     focused on the action / sequencing axis.
+#
+# Validate:
+#   cd /Users/berta/Projects/OpenRA-Bench && \
+#   python3 -m openra_bench.scenarios.validate \
+#     openra_bench/scenarios/packs/lh-multi-checkpoint-5-plus.yaml
+
+meta:
+  id: lh-multi-checkpoint-5-plus
+  title: 'Multi-Checkpoint 5+ — Strict Long-Sequencing Chain (PERT / PlanBench)'
+  capability: action
+  real_world_meaning: >
+    A long single-episode operation whose final win depends on FIVE or
+    more intermediate checkpoints being observed-true in order: stand
+    up the economy (refinery), unlock the tech (war factory), produce
+    a real fighting force (≥2 medium tanks), engage and accumulate
+    kills (≥3), then commit to the terminal objective (raze the enemy
+    headquarters). The Wave-2 `then:` composite enforces strict
+    happened-before — an out-of-order completion (kills before the
+    army, attack before the tech) cannot advance the chain past the
+    skipped clause and forfeits the episode on the clock.
+  robotics_analogue: >
+    Long sequenced operation with strict checkpoint gating: a mission
+    that runs through 5+ phases that must complete in order (sensor
+    coverage → infrastructure → fleet provisioning → contact →
+    objective), inside a single budget window. Credit at episode end
+    requires every phase to have happened in sequence — out-of-order
+    completion forfeits the whole chain. Standard PERT / CPM critical-
+    path execution where a downstream task cannot start (and cannot
+    earn credit) until its upstream predecessor has finished.
+  benchmark_anchor:
+    - "PlanBench long-sequencing"
+    - "PERT critical path"
+    - "PERT/CPM project management"
+    - "long SOP execution"
+  author: openra-bench
+
+base_map: rush-hour-arena
+
+base:
+  agent:
+    faction: allies
+  enemy:
+    faction: soviet
+    bot_type: ''
+  tools:
+    - observe
+    - build
+    - place_building
+    - move_units
+    - attack_unit
+    - attack_move
+    - stop
+  planning: true
+  termination:
+    max_ticks: 40000
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Loose-bar rehearsal: 3-phase chain (proc → weap → engage). Cash
+  # is loose, the static enemy fact has no defenders, and the chain
+  # is short enough that a competent build-order + attack wins. The
+  # `then:` idiom is taught here so the medium tier (5 phases) and
+  # hard tier (6 phases) are pure phase-count escalations.
+  easy:
+    description: >
+      Pre-placed: agent fact + tent + powr + fix at the west base,
+      plus 4 medium tanks (2tnk) for the engagement. An enemy fact
+      sits undefended at the far east (your terminal target). The
+      three checkpoints (`then:` chain) are: build a refinery (proc),
+      then a war factory (weap), then destroy the enemy fact. Phases
+      MUST happen IN THIS ORDER — stalling or skipping any phase
+      loses (the chain never advances), and any non-win on the clock
+      is a real LOSS. All within 7200 ticks.
+    starting_cash: 4000
+    overrides:
+      actors:
+        # Agent base — fact, tent, powr, fix (the 2tnk tech-prereq,
+        # pre-placed because the easy tier doesn't include a tank-
+        # production checkpoint; keeping `fix` matches the medium
+        # tier's geometry so cash budgeting transfers cleanly).
+        - {type: fact, owner: agent, position: [10, 18]}
+        - {type: tent, owner: agent, position: [10, 22]}
+        - {type: powr, owner: agent, position: [14, 18]}
+        - {type: fix,  owner: agent, position: [14, 22]}
+        # 4 pre-placed medium tanks — the strike force for the
+        # engagement checkpoint. Positioned just east of the base
+        # so they have a clear corridor to the enemy fact.
+        - {type: 2tnk, owner: agent, position: [18, 18]}
+        - {type: 2tnk, owner: agent, position: [18, 20]}
+        - {type: 2tnk, owner: agent, position: [18, 22]}
+        - {type: 2tnk, owner: agent, position: [20, 20]}
+        # Near ore patch so a built proc auto-spawns a harv with
+        # somewhere to harvest from (income for weap).
+        - {type: mine, owner: neutral, position: [22, 18]}
+        - {type: mine, owner: neutral, position: [22, 22]}
+        # Enemy: fact at far east (terminal target). No defenders on
+        # easy — the engage clause is geometric only (drive tanks
+        # east, raze fact). A SENTINEL fact at the far north-east
+        # corner persists past the terminal fact-kill so the engine
+        # does NOT auto-`done` on enemy-elimination before the
+        # `then:` chain (and the within_ticks predicate) gets a turn
+        # to evaluate — see CLAUDE.md auto-terminate footgun.
+        - {type: fact, owner: enemy, position: [115, 30]}
+        - {type: fact, owner: enemy, position: [125, 4]}
+    win_condition:
+      all_of:
+        - then:
+            id: multi-check-easy
+            clauses:
+              - {has_building: proc}                               # P1: econ
+              - {has_building: weap}                               # P2: tech
+              - {enemy_key_buildings_destroyed: {types: [fact]}}   # P3: engage
+        - within_ticks: 7200
+    fail_condition:
+      any_of:
+        - {after_ticks: 7201}
+        - {not: {building_count_gte: {type: fact, n: 1}}}
+    max_turns: 85
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # 5-phase chain (the headline cell): proc → weap → 2× 2tnk → ≥3
+  # kills → enemy fact. The chain MIXES checkpoint kinds (buildings +
+  # quantitative production + combat-aggregate + terminal destruction)
+  # so the ordering is genuinely load-bearing — a "kill 3 then build
+  # then attack" play cannot satisfy clause-4 BEFORE clause-3 (the
+  # `then:` latch only advances when each clause is observed-true in
+  # order). Cash is tight (2500) so the chain must be executed
+  # efficiently; the 4 pre-placed tanks cover the kill+engage clauses,
+  # the auto-harvester from the built proc funds weap + the 2 new
+  # tanks for clause 3.
+  medium:
+    description: >
+      Pre-placed: agent fact + tent + powr + fix at the west base,
+      plus 4 medium tanks (2tnk) for the engagement. An enemy fact
+      sits at the far east defended by a handful of HOLD-FIRE rifle/
+      rocket soldiers (your kill targets). The five checkpoints
+      (`then:` chain) are: build a refinery (proc), then a war
+      factory (weap), then have ≥2 medium tanks (2tnk) standing,
+      then accumulate ≥3 unit kills, then destroy the enemy fact.
+      Phases MUST happen IN THIS ORDER — `then:` enforces strict
+      happened-before. A "rush the fact and kill on the way" play
+      scores kills early but the latch will not credit them until
+      proc + weap + 2tnk have latched in order; skipping any clause
+      stalls the chain. All within 7200 ticks.
+    starting_cash: 2500
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 18]}
+        - {type: tent, owner: agent, position: [10, 22]}
+        - {type: powr, owner: agent, position: [14, 18]}
+        # `fix` (Service Depot) is the 2tnk tech-prereq; pre-placed
+        # so the chain's PHASE 2 only needs the agent to build the
+        # war factory (weap) — not a Service Depot too.
+        - {type: fix,  owner: agent, position: [14, 22]}
+        # 4 pre-placed medium tanks — the strike force for the
+        # kills + engagement checkpoints. Two start tanks already
+        # SATISFY the unit_type_count_gte:{2tnk,n:2} clause at t=0,
+        # so the agent does NOT need to build more for clause 3 —
+        # but the `then:` latch only advances to clause-3 once the
+        # earlier proc + weap clauses have latched.
+        - {type: 2tnk, owner: agent, position: [18, 18]}
+        - {type: 2tnk, owner: agent, position: [18, 20]}
+        - {type: 2tnk, owner: agent, position: [18, 22]}
+        - {type: 2tnk, owner: agent, position: [20, 20]}
+        # Ore patch — auto-harv from the built proc funds weap.
+        - {type: mine, owner: neutral, position: [22, 18]}
+        - {type: mine, owner: neutral, position: [22, 22]}
+        # Enemy: fact at far east + 4 HOLD-FIRE defenders (kills for
+        # phase 4). HoldFire (stance:0) means the defenders won't
+        # path-find west — the agent must come to them. Defender
+        # count = 4 so the ≥3 kills clause is generously satisfiable.
+        - {type: fact, owner: enemy, position: [115, 30]}
+        - {type: e1,   owner: enemy, position: [110, 28], stance: 0}
+        - {type: e1,   owner: enemy, position: [110, 30], stance: 0}
+        - {type: e1,   owner: enemy, position: [110, 32], stance: 0}
+        - {type: e3,   owner: enemy, position: [112, 30], stance: 0}
+        # Sentinel: a far isolated enemy fact so razing the assault
+        # target doesn't auto-`done` the engine before the win
+        # predicate evaluates (CLAUDE.md auto-terminate footgun).
+        - {type: fact, owner: enemy, position: [125, 4]}
+    win_condition:
+      all_of:
+        - then:
+            id: multi-check-medium
+            clauses:
+              - {has_building: proc}                               # P1: econ
+              - {has_building: weap}                               # P2: tech
+              - {unit_type_count_gte: {type: 2tnk, n: 2}}          # P3: army
+              - {units_killed_gte: 3}                              # P4: engage
+              - {enemy_key_buildings_destroyed: {types: [fact]}}   # P5: finish
+        - within_ticks: 7200
+    fail_condition:
+      any_of:
+        - {after_ticks: 7201}
+        - {not: {building_count_gte: {type: fact, n: 1}}}
+    max_turns: 85
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # 6-phase chain + 2 spawn_point groups. One extra checkpoint
+  # (≥4 tanks AFTER the kills) makes the chain genuinely longer than
+  # medium's 5 (the chain demands MORE tanks be produced even after
+  # the first kills land — a tank-count regression check that the
+  # army was rebuilt after attrition). The agent spawns NORTH (y=14)
+  # or SOUTH (y=26) by seed; the per-seed base latitude flips so a
+  # memorised opening cannot generalise.
+  hard:
+    description: >
+      Pre-placed: agent base (fact + tent + powr + fix) at the west,
+      round-robined between a NORTH base and a SOUTH base by seed,
+      plus 4 medium tanks (2tnk). An enemy fact at the far east is
+      defended by HOLD-FIRE defenders (your kill targets). The six
+      checkpoints (`then:` chain) are: build a refinery (proc), then
+      a war factory (weap), then have ≥2 medium tanks (2tnk), then
+      accumulate ≥3 unit kills, then have ≥4 medium tanks (rebuild
+      after attrition), then destroy the enemy fact. Phases MUST
+      happen IN STRICT ORDER (`then:` composite). Pre-build / out-of-
+      order / skip-tech / kill-without-army all stall the chain.
+      The seed-varied spawn means a memorised opening cannot
+      generalise. All within 7200 ticks.
+    starting_cash: 3000
+    overrides:
+      actors:
+        # NORTH base spawn (spawn_point 0)
+        - {type: fact, owner: agent, position: [10, 14], spawn_point: 0}
+        - {type: tent, owner: agent, position: [10, 18], spawn_point: 0}
+        - {type: powr, owner: agent, position: [14, 14], spawn_point: 0}
+        - {type: fix,  owner: agent, position: [14, 18], spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [18, 14], spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [18, 16], spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [18, 18], spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [20, 16], spawn_point: 0}
+        # SOUTH base spawn (spawn_point 1)
+        - {type: fact, owner: agent, position: [10, 26], spawn_point: 1}
+        - {type: tent, owner: agent, position: [10, 22], spawn_point: 1}
+        - {type: powr, owner: agent, position: [14, 26], spawn_point: 1}
+        - {type: fix,  owner: agent, position: [14, 22], spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [18, 26], spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [18, 24], spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [18, 22], spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [20, 24], spawn_point: 1}
+        # Shared ore geography — two patches between the two bases
+        # so harv income is symmetric whichever spawn is chosen.
+        - {type: mine, owner: neutral, position: [22, 18]}
+        - {type: mine, owner: neutral, position: [22, 22]}
+        # Enemy: fact at far east + HOLD-FIRE defenders for the kill
+        # clause. 5 defenders so the ≥3 kills clause is generously
+        # satisfiable on either spawn. Placed near the enemy fact so
+        # a stall loses on the clock, not on the agent base getting
+        # overrun first (no bot, so this is structural anyway).
+        - {type: fact, owner: enemy, position: [115, 20]}
+        - {type: e1,   owner: enemy, position: [110, 18], stance: 0}
+        - {type: e1,   owner: enemy, position: [110, 20], stance: 0}
+        - {type: e1,   owner: enemy, position: [110, 22], stance: 0}
+        - {type: e3,   owner: enemy, position: [112, 19], stance: 0}
+        - {type: e3,   owner: enemy, position: [112, 21], stance: 0}
+        # Sentinel: a far isolated enemy fact so razing the assault
+        # target doesn't auto-`done` the engine before the win
+        # predicate evaluates (CLAUDE.md auto-terminate footgun).
+        - {type: fact, owner: enemy, position: [125, 4]}
+    win_condition:
+      all_of:
+        - then:
+            id: multi-check-hard
+            clauses:
+              - {has_building: proc}                               # P1: econ
+              - {has_building: weap}                               # P2: tech
+              - {unit_type_count_gte: {type: 2tnk, n: 2}}          # P3: army
+              - {units_killed_gte: 3}                              # P4: engage
+              - {unit_type_count_gte: {type: 2tnk, n: 4}}          # P5: rebuild
+              - {enemy_key_buildings_destroyed: {types: [fact]}}   # P6: finish
+        - within_ticks: 7200
+    fail_condition:
+      any_of:
+        - {after_ticks: 7201}
+        - {not: {building_count_gte: {type: fact, n: 1}}}
+    max_turns: 85

openra_bench/scenarios/packs/lh-scout-react-counter.yaml

@@ -0,0 +1,368 @@
+# lh-scout-react-counter.yaml
+#
+# REASONING capability — observation-driven 3-phase chain:
+# SCOUT (discover ≥2 enemy buildings) → REACT (engage and kill ≥3
+# enemy units) → COUNTER (raze the enemy construction yard).
+# The agent starts late-game with a small force (1× jeep scout +
+# 3× medium tanks) and a starter fact at the west edge; cash 1500
+# is too lean to fund a meaningful new production line, so the
+# capability under test is the REACTIVE INFORMATION-ACTION LOOP on
+# the existing force — not build-out, not tech-pivot. The model
+# must observe what the enemy actually has, engage it, then
+# commit to razing the construction yard inside the deadline.
+#
+# Distinct from sibling Wave-4 `lh-tech-pivot-attack`:
+#   - lh-tech-pivot-attack: tech is already standing; the pivot
+#     is BUILD-the-correct-counter then attack. The middle phase
+#     is a PRODUCTION decision.
+#   - lh-scout-react-counter (this pack): tech is NOT standing;
+#     the army is pre-deployed; the middle phase is a TACTICAL
+#     ENGAGEMENT decision (which enemy cluster to engage, in what
+#     order). Cash is intentionally too lean to fund building
+#     more of the army — the capability is the observation-driven
+#     three-phase chain on a FIXED FORCE.
+# Distinct from sibling Wave-2 `mid-tech-switch-on-scout`:
+#   - mid-tech-switch-on-scout: scout-then-counter (2-phase) with
+#     either counter satisfying the win via units_killed_gte:3.
+#   - lh-scout-react-counter (this pack): EXPLICIT 3-phase chain
+#     where SCOUTING (≥2 buildings, not ≥1) is the load-bearing
+#     first phase, REACT is killing units mid-chain, and COUNTER
+#     is razing the FACT (not just hitting the kill bar).
+#
+# Real-world anchors: SC2 reactive macro (scout enemy strategy
+# mid-game, pivot composition, counter-attack); CICERO
+# information-action loop (gather state, update belief, commit to
+# action); PlanBench replanning (mid-plan observation forces
+# re-plan); threat-intel-driven defence (a SOC analyst confirms
+# the indicator-of-compromise from telemetry, takes containment
+# action, then patches the upstream attack vector).
+#
+# ENGINE NOTES (per CLAUDE.md):
+#   - Enemy actors with spawn_point are NOT reliably filtered per
+#     seed (openra-data/src/oramap.rs::expand_scenario_actors); we
+#     vary the AGENT spawn instead (medium/hard) to flip which
+#     enemy composition is the "near" reachable one.
+#   - The enemy `fact` is MustBeDestroyed → razing it satisfies
+#     enemy_key_buildings_destroyed but would auto-`done` the
+#     engine if it were the LAST enemy building standing. A
+#     second isolated enemy `fact` at the FAR corner persists as
+#     an anti-auto-`done` anchor (unreachable inside the clock).
+#   - `then:` is the Wave-2 happened-before composite: clauses
+#     latch IN ORDER, so a SKIP-SCOUT-ATTACK-BLIND play that
+#     razes the fact (auto-discovering 1 building en route) does
+#     NOT satisfy the first clause (≥2 buildings discovered) —
+#     keeping scouting load-bearing.
+#   - `unit_killed_gte:3` is the REACT phase: it requires the
+#     agent's force to actually engage; a scout-only-no-attack
+#     play stalls at clause 2.
+#   - Tools omit `harvest` / `train` deliberately: this pack does
+#     not test the economic loop. `build`/`place_building` are
+#     kept so an opportunistic emergency defence (e.g. a pbox /
+#     gun) is buildable from the starter fact + powr if the model
+#     elects to spend the lean cash that way.
+#
+# Validate:
+#   cd /Users/berta/Projects/OpenRA-Bench && \
+#   python3 -m openra_bench.scenarios.validate \
+#     openra_bench/scenarios/packs/lh-scout-react-counter.yaml
+
+meta:
+  id: lh-scout-react-counter
+  title: 'Scout, React, Counter — Observation-Driven 3-Phase Chain'
+  capability: reasoning
+  real_world_meaning: >
+    Reactive macro on a fixed force: the agent must drive the
+    observation-action-counter loop end-to-end inside one budget.
+    Phase 1 (scout) is mandatory — the deeper enemy posture
+    (≥2 buildings worth of structure) must be observed before any
+    commit is informed; phase 2 (react) requires the army to
+    actually engage the cluster, not merely walk past; phase 3
+    (counter) is the production-yard kill that ends the threat at
+    its source. Pre-committing to attack the construction yard
+    without scouting cannot satisfy the chain — the scout latch
+    is the load-bearing first link.
+  robotics_analogue: >
+    Threat-intel-driven incident response: SOC analyst confirms
+    multiple indicators of compromise from telemetry (scout),
+    contains the active attacker on the network (react / engage),
+    then patches the upstream attack vector / takes down the
+    command-and-control host (counter). Skipping the confirmation
+    step and going straight to take-down acts on stale belief and
+    misses the root cause; scouting forever bleeds the response
+    window.
+  benchmark_anchor:
+    - "SC2 reactive macro (scout-pivot-counter)"
+    - "CICERO information-action loop"
+    - "PlanBench replanning"
+    - "threat-intel-driven defense"
+  author: "openra-bench"
+
+base_map: rush-hour-arena
+
+base:
+  agent:
+    faction: allies
+  enemy:
+    faction: soviet
+    bot_type: ''
+  tools:
+    - observe
+    - build
+    - place_building
+    - move_units
+    - attack_unit
+    - attack_move
+    - stop
+  planning: true
+  termination:
+    max_ticks: 40000
+
+levels:
+  # ── EASY ────────────────────────────────────────────────────────
+  # Plan-and-execute rehearsal: ONE fixed enemy composition (the
+  # construction yard + an attached barracks defended by a passive
+  # rifle/rocket cluster) at the far east. The brief explicitly
+  # names the composition so the model can pre-plan; the
+  # then-chain still enforces scout (≥2 buildings) before react
+  # (≥3 kills) before counter (raze fact) to teach the idiom.
+  # Stalling loses on the clock; a skip-scout-attack-blind play
+  # races at the fact with the starter tanks but the cluster
+  # blunts it — and even on success the discovery clause needs
+  # ≥2 buildings, which a single fact-rush only registers 1.
+  easy:
+    description: >
+      Your starter force sits at the west edge: a scout jeep and
+      three medium tanks (2tnk). A single enemy construction yard
+      (fact) sits at the far east on the central y-band, defended
+      by a passive rifle cluster (four e1). A SEPARATE enemy
+      barracks (tent) sits as a forward outpost in the south
+      mid-section, OFF the main assault axis. Drive the jeep
+      FIRST through the southern outpost to register the tent,
+      then on to the far east to register the fact (≥2 buildings
+      discovered), then commit your tanks to destroy ≥3 enemy
+      units, then RAZE the enemy construction yard. All within
+      6300 ticks. Rushing the tanks straight at the fact only
+      registers the fact under attack (the outpost is well off
+      the assault axis — out of tank sight) — the discovery
+      latch stalls at 1 and the chain never completes; stalling
+      at spawn loses on the clock.
+    starting_cash: 1500
+    overrides:
+      actors:
+        # Agent: starter fact + powr at the west (the powr lets a
+        # building like pbox/gun be placed if the model elects;
+        # not load-bearing for the intended play).
+        - {type: fact, owner: agent, position: [10, 18]}
+        - {type: powr, owner: agent, position: [14, 18]}
+        # 1× scout jeep + 3× medium tanks at the west edge,
+        # stance:1 (ReturnFire) so they don't path-find east on
+        # their own and so the engagement is the agent's choice.
+        - {type: jeep, owner: agent, position: [20, 16], stance: 1}
+        - {type: 2tnk, owner: agent, position: [20, 18], stance: 1}
+        - {type: 2tnk, owner: agent, position: [20, 19], stance: 1}
+        - {type: 2tnk, owner: agent, position: [20, 20], stance: 1}
+        # Enemy main: construction yard at the far east on the
+        # central y-band, plus a passive rifle cluster (e1) at
+        # stance:0 (HoldFire) guarding it. The cluster does NOT
+        # path-find west; the agent must come to them.
+        - {type: fact, owner: enemy, position: [122, 18]}
+        - {type: e1,   owner: enemy, position: [118, 18], stance: 0, count: 4}
+        # Enemy forward outpost: an isolated barracks (tent) FAR
+        # off the main assault axis (mid-x, far south). A blind
+        # tank rush at the fact (path y≈18) never approaches
+        # (60, 36) — tank sight ~6 cells, distance from any rush
+        # waypoint is >>15. The jeep, however, can deliberately
+        # detour through (60, 36) before continuing east to see
+        # the main fact. This makes the ≥2-buildings discovery
+        # latch genuinely require a scout phase: the second
+        # building is geographically unreachable on the assault
+        # path.
+        - {type: tent, owner: enemy, position: [60, 36]}
+        # Sentinel: a second isolated enemy fact at the far north,
+        # unreachable inside the clock budget, so razing the near
+        # fact does NOT auto-`done` the engine before the win
+        # predicate evaluates (defence-in-depth per CLAUDE.md
+        # auto-terminate footgun).
+        - {type: fact, owner: enemy, position: [124, 4]}
+    win_condition:
+      all_of:
+        - then:
+            id: scout-react-counter-easy
+            clauses:
+              - {buildings_discovered_gte: 2}
+              - {units_killed_gte: 3}
+              - {enemy_key_buildings_destroyed: {types: [fact]}}
+        - {within_ticks: 6300}
+    fail_condition:
+      any_of:
+        - {after_ticks: 6301}
+        - {not: {own_units_gte: 1}}
+        - {not: {has_building: fact}}
+    max_turns: 75
+
+  # ── MEDIUM ──────────────────────────────────────────────────────
+  # +1 controlled variable: HIDDEN COMPOSITION (the near enemy
+  # posture varies by seed). Two enemy fact+tent+defender clusters
+  # sit at the NE and SE corners; the agent's start latitude
+  # round-robins between a NORTH spawn (y=10) and a SOUTH spawn
+  # (y=30) so the natural "near" composition flips per seed. The
+  # scout phase now requires actually driving the jeep into the
+  # near corner (not just guessing) to register ≥2 buildings; a
+  # blind rush at the FAR corner overruns the clock; a
+  # scout-then-no-attack stalls at the react clause.
+  medium:
+    description: >
+      Your starter force sits at the west edge: a scout jeep and
+      three medium tanks (2tnk). Two enemy construction yards
+      (fact) sit hidden at the far NE and SE corners, each
+      defended by a passive infantry cluster. A SEPARATE enemy
+      barracks (tent) sits as a forward outpost at mid-x mid-y,
+      off the assault axis from either spawn. Drive the jeep
+      FIRST through the mid outpost to register the tent, then
+      east to the near corner to register the fact (≥2 buildings
+      discovered), then commit your tanks to destroy ≥3 enemy
+      units, then RAZE the near construction yard. All within
+      6300 ticks. Pre-rushing tanks at the fact only registers
+      the fact (1 building); scouting forever bleeds the clock;
+      stalling at spawn never advances the chain.
+    starting_cash: 1500
+    overrides:
+      actors:
+        # North-base spawn (spawn_point 0).
+        - {type: fact, owner: agent, position: [10, 10], spawn_point: 0}
+        - {type: powr, owner: agent, position: [14, 10], spawn_point: 0}
+        - {type: jeep, owner: agent, position: [20, 8],  stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [20, 10], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [20, 11], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [20, 12], stance: 1, spawn_point: 0}
+        # South-base spawn (spawn_point 1).
+        - {type: fact, owner: agent, position: [10, 30], spawn_point: 1}
+        - {type: powr, owner: agent, position: [14, 30], spawn_point: 1}
+        - {type: jeep, owner: agent, position: [20, 28], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [20, 30], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [20, 31], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [20, 32], stance: 1, spawn_point: 1}
+        # NE enemy base: fact + defending e1 cluster.
+        - {type: fact, owner: enemy, position: [122, 5]}
+        - {type: e1,   owner: enemy, position: [118, 5], stance: 0, count: 4}
+        # SE enemy base: fact + defending e3 cluster (anti-
+        # vehicle, stance:0 HoldFire — equivalent posture to NE
+        # so the seed-rotated near base presents an equivalent
+        # scout/react/counter task).
+        - {type: fact, owner: enemy, position: [122, 38]}
+        - {type: e3,   owner: enemy, position: [118, 38], stance: 0, count: 4}
+        # Shared FORWARD OUTPOST: a lone enemy barracks (tent) at
+        # mid-x, mid-y. From EITHER spawn, the tank rush path
+        # stays inside its own y-band (N: y≈5..12, S: y≈30..38)
+        # and never approaches (60, 20) within tank sight ~6
+        # (closest the rush gets is ~8 cells, still out of
+        # sight). The jeep must deliberately detour through
+        # (60, 20) to register the tent, then continue east to
+        # register the near fact — making ≥2 buildings discovered
+        # require an EXPLICIT scout phase.
+        - {type: tent, owner: enemy, position: [60, 20]}
+    win_condition:
+      all_of:
+        - then:
+            id: scout-react-counter-medium
+            clauses:
+              - {buildings_discovered_gte: 2}
+              - {units_killed_gte: 3}
+              - {enemy_key_buildings_destroyed: {types: [fact]}}
+        - {within_ticks: 6300}
+    fail_condition:
+      any_of:
+        - {after_ticks: 6301}
+        - {not: {own_units_gte: 1}}
+        - {not: {has_building: fact}}
+    max_turns: 75
+
+  # ── HARD ────────────────────────────────────────────────────────
+  # +1 controlled variable: an ATTRITION CAP (units_lost_lte:3,
+  # so the agent cannot trade tanks freely). The map adds a
+  # MIDDLE pocket (a third fact+tent cluster at mid-latitude) so
+  # the scout phase has THREE candidate posture readings, not two
+  # — even on a fixed spawn the jeep must actually identify the
+  # nearest reachable cluster before committing. 2 spawn_point
+  # groups satisfy `tests/test_hard_tier.py::UPGRADED`. Blind
+  # rush busts the discovery latch AND the attrition cap; a
+  # scout-then-trade-everything play busts the attrition cap; an
+  # over-scout that runs the jeep to all three pockets bleeds
+  # the clock.
+  hard:
+    description: >
+      Your starter force at the west edge — a scout jeep and
+      three medium tanks (2tnk) — round-robined between a NORTH
+      base and a SOUTH base by seed. Three enemy construction
+      yards (fact) sit hidden at the far east (NE, MID, SE),
+      each with a passive defending cluster. A SEPARATE enemy
+      barracks (tent) sits as a forward outpost at mid-x mid-y,
+      off the assault axis from either spawn. Drive the jeep
+      through the mid outpost to register the tent and then to
+      the NEAREST corner (compass-only briefing, no coordinates)
+      to register the fact (≥2 buildings discovered), then
+      engage with the tanks to destroy ≥3 enemy units, and RAZE
+      the near construction yard — all while losing no more
+      than three of your own. All within 6300 ticks. Blind
+      rushing fails the discovery latch; reckless engagements
+      bust the attrition cap; an over-scout that touches all
+      three corners AND the outpost bleeds the clock.
+    starting_cash: 1500
+    objective_coords: relative
+    overrides:
+      actors:
+        # North-base spawn (spawn_point 0).
+        - {type: fact, owner: agent, position: [10, 10], spawn_point: 0}
+        - {type: powr, owner: agent, position: [14, 10], spawn_point: 0}
+        - {type: jeep, owner: agent, position: [20, 8],  stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [20, 10], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [20, 11], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [20, 12], stance: 1, spawn_point: 0}
+        # South-base spawn (spawn_point 1).
+        - {type: fact, owner: agent, position: [10, 30], spawn_point: 1}
+        - {type: powr, owner: agent, position: [14, 30], spawn_point: 1}
+        - {type: jeep, owner: agent, position: [20, 28], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [20, 30], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [20, 31], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [20, 32], stance: 1, spawn_point: 1}
+        # NE enemy base: fact + e1 cluster.
+        - {type: fact, owner: enemy, position: [122, 5]}
+        - {type: e1,   owner: enemy, position: [118, 5], stance: 0, count: 4}
+        # SE enemy base: fact + e3 cluster.
+        - {type: fact, owner: enemy, position: [122, 38]}
+        - {type: e3,   owner: enemy, position: [118, 38], stance: 0, count: 4}
+        # MID enemy base — the third compositional reading on the
+        # tighter attrition tier. fact + cluster at mid-latitude;
+        # unreachable as the "near" base from either NORTH (y=10)
+        # or SOUTH (y=30) spawn inside the tighter attrition
+        # budget (units_lost_lte:3) — the over-scout penalty is
+        # precisely the diversion to the mid pocket.
+        - {type: fact, owner: enemy, position: [122, 22]}
+        - {type: e1,   owner: enemy, position: [118, 22], stance: 0, count: 4}
+        # Shared FORWARD OUTPOST: lone enemy tent at mid-x AND
+        # mid-y. The rush axis from either spawn stays inside
+        # its own y-band and never approaches (60, 20) within
+        # tank sight ~6; the jeep must detour through (60, 20)
+        # for the second building. Sits 5 cells north of the
+        # MID base fact (122, 22) so it cannot be confused with
+        # the MID base — the jeep at (60, 20) sees the outpost
+        # but the MID fact at distance √(62²+2²)≈62 is far out
+        # of jeep sight.
+        - {type: tent, owner: enemy, position: [60, 20]}
+    win_condition:
+      all_of:
+        - then:
+            id: scout-react-counter-hard
+            clauses:
+              - {buildings_discovered_gte: 2}
+              - {units_killed_gte: 3}
+              - {enemy_key_buildings_destroyed: {types: [fact]}}
+        - {within_ticks: 6300}
+        - {units_lost_lte: 3}
+    fail_condition:
+      any_of:
+        - {after_ticks: 6301}
+        - {not: {own_units_gte: 1}}
+        - {not: {has_building: fact}}
+        - {not: {units_lost_lte: 3}}
+    max_turns: 75

tests/test_coord_converge_on_target.py

@@ -0,0 +1,378 @@
+"""coord-converge-on-target — triple-prong convergent attack.
+
+The bar: intended THREE-PRONG converge (all three squads driven onto
+the objective fact at ~100,20 simultaneously) WINS on every level and
+every hard seed (1..4). STALL (only observe), SINGLE-SQUAD-N (only the
+north squad attacks while the other two stand still), and TWO-SQUADS
+(north + south only — the west / east third squad stands still) all
+LOSE on every level and every hard seed. Non-win is a real reachable
+timeout LOSS via the `after_ticks` fail clause (force-wipe also fails).
+
+Validation is scripted (no model / network).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import compile_level
+from openra_bench.scenarios.win_conditions import WinContext, evaluate
+
+PACKS = Path(__file__).parent.parent / "openra_bench" / "scenarios" / "packs"
+PACK_PATH = PACKS / "coord-converge-on-target.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 == "coord-converge-on-target"
+    assert pack.meta.capability == "action"
+    assert pack.meta.real_world_meaning, "real_world_meaning required"
+    assert pack.meta.robotics_analogue, "robotics_analogue required"
+    anchors = pack.meta.benchmark_anchor
+    assert isinstance(anchors, list) and len(anchors) >= 3, (
+        f"benchmark_anchor must list ≥3 anchors, got {anchors!r}"
+    )
+    joined = " ".join(anchors).lower()
+    for needle in ("sc2", "convergent", "envelopment"):
+        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", 100, 20)] if fact_destroyed else []
+        ),
+    )
+    return WinContext(
+        signals=sig,
+        render_state={"units_summary": list(units)},
+    )
+
+
+def _tanks_at(cx, cy, n, base_id=1000):
+    return [
+        {"cell_x": cx, "cell_y": cy, "type": "2tnk", "id": str(base_id + i)}
+        for i in range(n)
+    ]
+
+
+def test_predicates_easy_medium_hard():
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        # WIN: ≥6 tanks inside (100,20,r=8) AND fact destroyed AND in budget.
+        win_units = _tanks_at(100, 20, 6) + _tanks_at(10, 20, 3, base_id=2000)
+        assert evaluate(
+            c.win_condition,
+            _ctx(units=win_units, tick=4000, fact_destroyed=True),
+        ), f"{lvl}: 6-in-region + fact destroyed must WIN"
+
+        # Fact NOT destroyed → not a win even with tanks in region.
+        assert not evaluate(
+            c.win_condition,
+            _ctx(units=win_units, tick=4000, fact_destroyed=False),
+        )
+
+        # Only 5 tanks in region (one short of n=6) → not a win.
+        five_in = _tanks_at(100, 20, 5) + _tanks_at(10, 20, 4, base_id=2000)
+        assert not evaluate(
+            c.win_condition,
+            _ctx(units=five_in, tick=4000, fact_destroyed=True),
+        ), f"{lvl}: 5-in-region must not WIN (n=6 threshold)"
+
+        # Past deadline → not a win.
+        assert not evaluate(
+            c.win_condition,
+            _ctx(units=win_units, tick=4501, fact_destroyed=True),
+        )
+
+        # Timeout with bar unmet → fail (after_ticks 4501).
+        assert evaluate(
+            c.fail_condition,
+            _ctx(units=win_units, tick=4600, fact_destroyed=False),
+        )
+
+        # Force-wipe → fail (not own_units_gte:1).
+        assert evaluate(
+            c.fail_condition,
+            _ctx(units=[], tick=3000, fact_destroyed=False),
+        )
+
+
+def test_timeout_reachable_inside_max_turns():
+    """No draw degeneracy: after_ticks 4501 ≤ 93 + 90·(max_turns-1)."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        max_tick = 93 + 90 * (c.max_turns - 1)
+        assert 4501 <= max_tick, (
+            f"{lvl}: after_ticks 4501 > max reachable tick {max_tick} "
+            f"(max_turns={c.max_turns}); deadline never bites"
+        )
+        assert 4500 <= max_tick, (
+            f"{lvl}: within_ticks 4500 > 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 geometry (N/W/S vs N/E/S). Engine
+    round-trip 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) —
+    these together make any single squad's frontal commit costly,
+    so a 3-prong convergence is required to win the trade."""
+    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 (~100,20) and one
+    far sentinel fact keeping the episode alive past objective-fact
+    destruction so within_ticks evaluates on the terminal frame (the
+    CLAUDE.md MustBeDestroyed auto-terminate footgun)."""
+    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}"
+        )
+        obj = [p for p in facts if 92 <= p[0] <= 108 and 14 <= p[1] <= 26]
+        far = [p for p in facts if not (92 <= p[0] <= 108 and 14 <= p[1] <= 26)]
+        assert len(obj) == 1 and len(far) == 1, (
+            f"{lvl}: expected 1 objective fact near (100,20) + 1 sentinel "
+            f"far, got obj={obj} far={far}"
+        )
+
+
+def test_guard_count_per_level():
+    """Difficulty axis: easy 3 guards (distributed), medium 4 (one
+    per cardinal face), hard 4 + seed-driven agent spawn variation.
+    The discrimination on medium / hard is tighter than on easy: a
+    single squad alone is destroyed in every tier; a two-squad
+    converge destroys the fact but trades the strike force out on
+    medium / hard (cardinal cover); only the three-prong meets the
+    n=6 region threshold."""
+    pack = load_pack(PACK_PATH)
+    expected = {"easy": 3, "medium": 4, "hard": 4}
+    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}"
+
+
+def test_three_agent_squads_per_spawn():
+    """Every spawn group must place 3 squads of 3× 2tnk each (9 tanks
+    total) so the n=6 region clause requires a true 3-prong converge
+    (a 2-prong with full attrition cannot reach 6 inside the region)."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        # group spawn -> total agent tank count
+        by_grp: dict = {}
+        for a in c.scenario.actors:
+            if a.owner == "agent" and a.type == "2tnk":
+                key = a.spawn_point if a.spawn_point is not None else 0
+                by_grp[key] = by_grp.get(key, 0) + (a.count or 1)
+        for k, n in by_grp.items():
+            assert n == 9, (
+                f"{lvl}: spawn group {k} must have 9× 2tnk (3 squads × 3), "
+                f"got {n}"
+            )
+
+
+# ── engine-driven scripted policies ─────────────────────────────────
+
+
+def _of_type(rs, want_types):
+    return [
+        u for u in (rs.get("units_summary", []) or [])
+        if u.get("type") in want_types
+    ]
+
+
+def _stall(rs, Command):
+    """Pure observe — no tank ever moves; objective fact untouched and
+    the deadline expires → LOSS."""
+    return [Command.observe()]
+
+
+def _by_squad(rs):
+    """Bucket agent tanks by their starting hemisphere so a partial
+    policy can drive only some squads. Squads start at:
+      NORTH y≈6   (any tank with cell_y ≤ 12)
+      SOUTH y≈34  (any tank with cell_y ≥ 28)
+      WEST  x≈10  (any tank with cell_x ≤ 20 and 12 < cell_y < 28)
+      EAST  x≈120 (any tank with cell_x ≥ 110 and 12 < cell_y < 28)
+    Per-seed the hard tier flips W↔E for the third squad; the bucket
+    label is "flank" for whichever lateral squad is present.
+    """
+    north, south, flank = [], [], []
+    for t in _of_type(rs, {"2tnk"}):
+        x, y = t["cell_x"], t["cell_y"]
+        if y <= 12:
+            north.append(t)
+        elif y >= 28:
+            south.append(t)
+        else:
+            flank.append(t)
+    return north, south, flank
+
+
+def _single_squad_n(rs, Command):
+    """Only the NORTH squad attack-moves onto the objective; the other
+    two squads stand still. Three tanks vs the guard cluster (3 / 6 /
+    8 by tier) lose the trade — fact never falls and/or the attacking
+    squad is wiped (≤3 of 9 in region < n=6). LOSS."""
+    north, _south, _flank = _by_squad(rs)
+    cmds = []
+    for t in north:
+        cmds.append(Command.attack_move([str(t["id"])], 100, 20))
+    return cmds or [Command.observe()]
+
+
+def _two_squads(rs, Command):
+    """NORTH + SOUTH squads attack-move onto the objective; the
+    lateral (WEST or EAST) squad stands still. 6 tanks vs the cluster
+    are still defeated under heavier defender density (medium 6
+    guards, hard 8) and the surviving in-region count drops below
+    n=6. LOSS."""
+    north, south, _flank = _by_squad(rs)
+    cmds = []
+    for t in north + south:
+        cmds.append(Command.attack_move([str(t["id"])], 100, 20))
+    return cmds or [Command.observe()]
+
+
+def _intended_three_prong(rs, Command):
+    """All three squads attack-move directly onto the objective fact at
+    (100,20). 9 tanks converging on the guard cluster (3 / 6 / 8 e3
+    defenders) overwhelm by mass: at least 6 of the 9 tanks survive
+    inside the (100,20,r=8) region while the cluster + fact fall.
+    WIN on every tier and every seed."""
+    cmds = []
+    for t in _of_type(rs, {"2tnk"}):
+        cmds.append(Command.attack_move([str(t["id"])], 100, 20))
+    return cmds or [Command.observe()]
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_intended_three_prong_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_three_prong, seed=seed)
+    assert r.outcome == "win", (
+        f"{level} seed={seed}: intended 3-prong converge should WIN, "
+        f"got {r.outcome} after {r.turns} turns "
+        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_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", ["medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_single_squad_north_loses(level, seed):
+    """Single north squad alone vs the guard cluster must LOSE on
+    medium (6 guards) and hard (8 guards). Easy with only 3 guards
+    may occasionally let a single squad squeak through; the
+    discrimination tier is medium+."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _single_squad_n, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: single-squad north must LOSE "
+        f"(3 tanks vs guard cluster), got {r.outcome} "
+        f"(lost={r.signals.units_lost}, "
+        f"bldgs={r.signals.enemy_buildings_destroyed_types})"
+    )
+
+
+@pytest.mark.parametrize("level", ["medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_two_squads_loses(level, seed):
+    """Two squads (north + south) without the third must LOSE on
+    medium (6 guards) and hard (8 guards) — 6 tanks vs the cluster
+    trade out and the surviving in-region count drops below n=6 (or
+    the fact never falls)."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _two_squads, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: two-squad converge must LOSE on "
+        f"medium/hard (defender density overwhelms 6 tanks), "
+        f"got {r.outcome} (lost={r.signals.units_lost}, "
+        f"bldgs={r.signals.enemy_buildings_destroyed_types})"
+    )

tests/test_coord_cover_and_move.py

@@ -0,0 +1,395 @@
+"""coord-cover-and-move — bounding-overwatch across a centre fire zone.
+
+The bar (binding):
+- intended bound-and-cover policy WINS on every level + every hard
+  seed (1..4);
+- stall / both-charge-together / single-squad-only LOSE on every level
+  + every hard seed (with one documented exception: easy uses e1 rifle
+  infantry which does limited damage to 2tnk armour, so both-charge
+  and single-squad may squeak through — bare-skill tier; matches the
+  pack design comment and SCENARIO_REVIEW_CHECKLIST.md note that
+  "inert anti-cheat teeth are acceptable on easy");
+- non-win is a real reachable timeout LOSS via the `after_ticks`
+  fail clause (no DRAW degeneracy: 4501 ≤ 93 + 90·(max_turns − 1));
+- hard ships ≥2 `spawn_point` groups (seed-driven start variation).
+
+Validation is scripted (no model / network).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import compile_level
+from openra_bench.scenarios.win_conditions import WinContext, evaluate
+
+PACKS = Path(__file__).parent.parent / "openra_bench" / "scenarios" / "packs"
+PACK_PATH = PACKS / "coord-cover-and-move.yaml"
+
+
+# ── declarative / schema invariants (no engine needed) ─────────────
+
+
+def test_pack_compiles_and_meta_fields_populated():
+    pack = load_pack(PACK_PATH)
+    assert pack.meta.id == "coord-cover-and-move"
+    assert pack.meta.capability == "action"
+    assert pack.meta.real_world_meaning, "real_world_meaning required"
+    assert pack.meta.robotics_analogue, "robotics_analogue required"
+    anchors = pack.meta.benchmark_anchor
+    assert isinstance(anchors, list) and len(anchors) == 4, (
+        f"benchmark_anchor must list all 4 anchors, got {anchors!r}"
+    )
+    joined = " ".join(anchors).lower()
+    # Spec-mandated anchors: military bounding overwatch + fire-and-
+    # maneuver + SC2 tank movement + SMAC danger-zone cross.
+    for needle in ("bounding overwatch", "fire-and-maneuver",
+                   "sc2", "smac"):
+        assert needle in joined, f"missing anchor keyword: {needle}"
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        assert c.map_supported
+        assert c.win_condition is not None
+        assert c.fail_condition is not None
+
+
+def _ctx(*, units=(), tick=1000, kills=0, lost=0):
+    """Synthesize a WinContext for predicate-level checks."""
+    import types
+
+    sig = types.SimpleNamespace(
+        game_tick=tick,
+        units_killed=kills,
+        units_lost=lost,
+        cash=0,
+        resources=0,
+        own_buildings=[],
+        own_building_types=set(),
+        enemies_seen_ids=set(),
+        enemy_buildings_seen_ids=set(),
+    )
+    return WinContext(
+        signals=sig,
+        render_state={"units_summary": list(units)},
+    )
+
+
+def _tanks_at(n, x=100, y=20):
+    return [
+        {"cell_x": x, "cell_y": y, "type": "2tnk", "id": str(2000 + i)}
+        for i in range(n)
+    ]
+
+
+@pytest.mark.parametrize("lvl", ["easy", "medium", "hard"])
+def test_win_requires_four_units_in_east_region(lvl):
+    c = compile_level(load_pack(PACK_PATH), lvl)
+    # 4 tanks in win region, 0 lost, in time → WIN
+    cap = 0 if lvl == "hard" else 1
+    assert evaluate(c.win_condition,
+                    _ctx(units=_tanks_at(4), tick=2000, lost=0))
+    # Only 3 in region → not a win
+    assert not evaluate(c.win_condition,
+                        _ctx(units=_tanks_at(3), tick=2000, lost=0))
+    # 4 in region but attrition cap busted → not a win
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=_tanks_at(4), tick=2000, lost=cap + 1),
+    )
+    # 4 in region but past the deadline → not a win
+    assert not evaluate(c.win_condition,
+                        _ctx(units=_tanks_at(4), tick=4600, lost=0))
+
+
+@pytest.mark.parametrize("lvl", ["easy", "medium", "hard"])
+def test_fail_clauses_are_reachable_losses(lvl):
+    c = compile_level(load_pack(PACK_PATH), lvl)
+    cap = 0 if lvl == "hard" else 1
+    # Past deadline → fail
+    assert evaluate(c.fail_condition,
+                    _ctx(units=_tanks_at(6, x=10), tick=4600, lost=0))
+    # Attrition cap busted → fail
+    assert evaluate(c.fail_condition,
+                    _ctx(units=_tanks_at(5), tick=2000, lost=cap + 1))
+    # Force wipe → fail
+    assert evaluate(c.fail_condition,
+                    _ctx(units=[], tick=2000, lost=6))
+
+
+def test_timeout_reachable_inside_max_turns():
+    """No draw degeneracy: after_ticks 4501 ≤ 93 + 90·(max_turns-1)."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        max_tick = 93 + 90 * (c.max_turns - 1)
+        assert 4501 <= max_tick, (
+            f"{lvl}: after_ticks 4501 > max reachable tick {max_tick} "
+            f"(max_turns={c.max_turns}); deadline never bites"
+        )
+        assert 4500 <= max_tick, (
+            f"{lvl}: within_ticks 4500 > max reachable tick {max_tick}"
+        )
+
+
+def test_hard_has_two_spawn_point_groups():
+    """Hard curation: ≥2 distinct agent spawn_point groups so the
+    seed round-robins the staging corner (NW / SW). Engine-roundtrip
+    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_two_squads_six_tanks_each_level():
+    """Two squads (3+3 = 6 tanks total per spawn) is the load-bearing
+    geometry — fewer tanks and the cover/bound roles cannot afford
+    losses; more and the cap is meaningless. Hard places the same 6
+    per spawn_point group across two groups."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium"):
+        c = compile_level(pack, lvl)
+        tanks = [a for a in c.scenario.actors
+                 if a.owner == "agent" and a.type == "2tnk"]
+        assert len(tanks) == 6, f"{lvl}: expected 6 tanks, got {len(tanks)}"
+    c = compile_level(pack, "hard")
+    per_group = {}
+    for a in c.scenario.actors:
+        if a.owner != "agent" or a.type != "2tnk":
+            continue
+        sp = a.spawn_point if a.spawn_point is not None else 0
+        per_group[sp] = per_group.get(sp, 0) + 1
+    assert all(n == 6 for n in per_group.values()), (
+        f"hard: each spawn_point group should have 6 tanks, got {per_group}"
+    )
+
+
+def test_fire_zone_uses_anti_tank_rocket_on_medium_and_hard():
+    """The fire zone's lethality is the load-bearing property —
+    medium / hard must use e3 (anti-tank rocket soldier, dps12 vs
+    armour) at the centre cluster. Easy may use e1 (forgiving)."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("medium", "hard"):
+        c = compile_level(pack, lvl)
+        types = [a.type for a in c.scenario.actors if a.owner == "enemy"]
+        assert types.count("e3") >= 4, (
+            f"{lvl}: need ≥4 e3 (anti-tank rocket) for fire zone; got {types}"
+        )
+        # Persistent far enemy marker (engine auto-done mitigation).
+        assert "fact" in types, f"{lvl}: needs persistent enemy fact"
+
+
+# ── engine-driven scripted policies ────────────────────────────────
+
+
+def _own_units(rs):
+    return rs.get("units_summary", []) or []
+
+
+def _own_ids(rs):
+    return [str(u["id"]) for u in _own_units(rs)]
+
+
+def _stall(rs, Command):
+    """Pure observe — no squad crosses, win region stays empty,
+    after_ticks LOSS."""
+    return [Command.observe()]
+
+
+def _both_charge_together(rs, Command):
+    """Both squads sprint east through the centre on the same y-band.
+    Engine spreads fire across the dense column → on medium/hard the
+    4× e3 anti-tank dps stacks enough to bust units_lost_lte:1 → LOSS."""
+    units = _own_units(rs)
+    if not units:
+        return [Command.observe()]
+    cmds = []
+    for u in units:
+        # Everyone barrels east toward the win region (100,20).
+        cmds.append(Command.move_units([str(u["id"])], 100, 20))
+    return cmds
+
+
+def _single_squad_only(rs, Command):
+    """Only the NORTHERN squad (y < 20 at spawn) crosses; the southern
+    squad is idle. The lone column absorbs ALL the centre cluster's
+    fire and busts the attrition cap → LOSS on medium/hard."""
+    units = _own_units(rs)
+    if not units:
+        return [Command.observe()]
+    cmds = []
+    for u in units:
+        if u["cell_y"] < 20:
+            cmds.append(Command.move_units([str(u["id"])], 100, 20))
+        else:
+            cmds.append(Command.stop([str(u["id"])]))
+    return cmds
+
+
+def _intended_bound_and_cover(rs, Command):
+    """Bounding overwatch:
+
+      Phase 1 — cover squad (northern at spawn, by y) advances to its
+        overwatch post at (~45, ~spawn_y) at the EDGE of the e3 range
+        (tank rng 4.75 vs e3 rng 4 — tanks fire from dist ~5);
+        bounding squad (southern) takes the FAR-NORTH wide-flank route
+        outside the fire envelope: detour to (~50, ~6 or ~34) then
+        east toward (~100, ~20).
+      Phase 2 — bounding squad pushed past the cluster onto the east
+        side; switch — original cover squad now relocates to the far
+        wide-flank route, then east.
+
+    The policy doesn't need ticks-aware role-flipping: it routes the
+    SOUTH squad through y≈6 (or y≈34 if south spawn) — the wide flank
+    — and the NORTH squad through y≈6 as well after a stagger. The
+    cover team's fire SUPPRESSES the cluster while the bounding team
+    is in transit. A simple implementation:
+      - sort own units by y; northern half = COVER, southern half = MOVE
+      - for the NORTH spawn (median y < 20): MOVE goes via y=8 then
+        east; COVER drives to (45, 15) and attack_moves on cluster.
+      - for the SOUTH spawn (median y > 20): mirror — MOVE goes via
+        y=32 then east; COVER drives to (45, 25) and attack_moves.
+      - once MOVE has cleared the fire zone (cell_x > 70), COVER also
+        starts the wide-flank route through the same outside-sight
+        band and follows east.
+    """
+    units = _own_units(rs)
+    if not units:
+        return [Command.observe()]
+
+    # Identify spawn geometry by current median y. Squads start with
+    # y ∈ {11..17} (NORTH spawn) or {23..29} (SOUTH spawn) in hard.
+    # Easy/medium always use y ∈ {14..16, 24..26}.
+    ys = sorted(u["cell_y"] for u in units)
+    median_y = ys[len(ys) // 2]
+
+    if median_y < 20:
+        # NORTH spawn: COVER on the south-of-spawn flank near the
+        # cluster's NORTH edge; MOVE detours through y ≈ 6..8.
+        flank_y = 8
+        cover_y = 15
+    else:
+        # SOUTH spawn (hard only): mirror across y=20.
+        flank_y = 32
+        cover_y = 25
+
+    # Split units: the half closer to the cluster's y axis (i.e.
+    # closer to y=20) becomes COVER; the half farther from y=20
+    # becomes MOVE (these are the ones we'll route via the wide flank).
+    units_sorted = sorted(units, key=lambda u: abs(u["cell_y"] - 20))
+    half = len(units_sorted) // 2
+    cover_team = units_sorted[:half]
+    move_team = units_sorted[half:]
+
+    cmds = []
+    # Check whether MOVE team has cleared the fire zone (any move-team
+    # tank with x ≥ 75). When cleared, COVER also begins its bound.
+    move_cleared = any(u["cell_x"] >= 75 for u in move_team)
+
+    # COVER team: drive to overwatch post and attack_move onto the
+    # cluster centre (the engine auto-targets nearest hostile in
+    # range; with cover at (45, cover_y) and cluster at (50, 20), the
+    # e3s are the visible targets and tanks fire dps22 each).
+    for u in cover_team:
+        if not move_cleared:
+            if u["cell_x"] < 45:
+                # Still approaching the overwatch post — drive into
+                # firing range of the cluster.
+                cmds.append(Command.attack_move([str(u["id"])], 45, cover_y))
+            else:
+                # Posted: keep firing. attack_move onto cluster cell.
+                cmds.append(Command.attack_move([str(u["id"])], 50, 20))
+        else:
+            # MOVE team has crossed; COVER bounds through the wide
+            # flank too (same y-band the MOVE team used).
+            if u["cell_x"] < 60:
+                # Detour north/south away from the cluster first.
+                cmds.append(Command.move_units([str(u["id"])], 50, flank_y))
+            else:
+                cmds.append(Command.move_units([str(u["id"])], 100, 20))
+
+    # MOVE team: wide-flank route. Stage 1 detour to (50, flank_y) so
+    # the column stays outside the cluster's sight envelope; stage 2
+    # east toward the win region.
+    for u in move_team:
+        if u["cell_x"] < 60:
+            cmds.append(Command.move_units([str(u["id"])], 50, flank_y))
+        elif u["cell_x"] < 90:
+            cmds.append(Command.move_units([str(u["id"])], 90, 20))
+        else:
+            cmds.append(Command.move_units([str(u["id"])], 100, 20))
+    return cmds
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_intended_bound_and_cover_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_bound_and_cover, seed=seed)
+    assert r.outcome == "win", (
+        f"{level} seed={seed}: bound-and-cover should WIN, got "
+        f"{r.outcome} after {r.turns} turns "
+        f"(losses={r.signals.units_lost})"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_stall_loses(level, seed):
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _stall, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: stall must be a real timeout LOSS "
+        f"(no squad crosses → win region empty → after_ticks fires), "
+        f"got {r.outcome}"
+    )
+
+
+@pytest.mark.parametrize("level", ["medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_both_charge_together_loses(level, seed):
+    """Both squads sprint together → fire stacks on dense column →
+    busts units_lost_lte cap on medium and hard. Easy excluded
+    (e1 rifle does limited damage to armour; forgiving bare-skill
+    tier; matches SCENARIO_REVIEW_CHECKLIST.md note that "inert
+    anti-cheat teeth are acceptable on easy")."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _both_charge_together, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: both-charge must LOSE (stacked e3 fire "
+        f"busts attrition cap), got {r.outcome} "
+        f"(losses={r.signals.units_lost})"
+    )
+
+
+@pytest.mark.parametrize("level", ["medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_single_squad_only_loses(level, seed):
+    """Only one squad crosses → lone column absorbs ALL cluster fire
+    → busts attrition cap on medium/hard. Easy excluded (same
+    forgiving-bare-skill reasoning as both-charge above)."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _single_squad_only, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: single-squad must LOSE (lone column "
+        f"absorbs full cluster fire), got {r.outcome} "
+        f"(losses={r.signals.units_lost})"
+    )

tests/test_coord_diversionary_attack.py

@@ -0,0 +1,572 @@
+"""coord-diversionary-attack — diversionary / split-attack assault.
+
+The bar: intended diversionary-attack (Squad A jeeps drag the
+heavier enemy garrison off the real target by attacking the decoy /
+centre cluster; Squad B tanks raze the REAL fact while the south
+defenders are committed in pursuit) WINS on every level and every
+hard seed (1..4). STALL (only observe), BRUTE-FRONTAL (every unit
+attack-moves onto the centre / decoy), LAZY NEAREST (jeeps onto the
+near-looking fact, tanks onto the near-looking powr), and BAIT-ONLY
+(jeeps slash south but tanks stand still) 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 (lazy/brute trades the strike force).
+
+Validation is scripted (no model / network).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import compile_level
+from openra_bench.scenarios.win_conditions import WinContext, evaluate
+
+PACKS = Path(__file__).parent.parent / "openra_bench" / "scenarios" / "packs"
+PACK_PATH = PACKS / "coord-diversionary-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 == "coord-diversionary-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 ≥3 anchors, got {anchors!r}"
+    )
+    joined = " ".join(anchors).lower()
+    for needle in ("sc2", "diversion", "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, destroyed_records=()):
+    """Synthesize a WinContext for predicate-level checks."""
+    import types
+
+    types_count: dict[str, int] = {}
+    for t, _x, _y in destroyed_records:
+        types_count[t] = types_count.get(t, 0) + 1
+    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=len(destroyed_records),
+        enemy_buildings_destroyed_types=types_count,
+        enemy_buildings_destroyed_records=list(destroyed_records),
+    )
+    return WinContext(
+        signals=sig,
+        render_state={"units_summary": list(units)},
+    )
+
+
+def _alive(n, kind="2tnk"):
+    return [
+        {"cell_x": 50, "cell_y": 20, "type": kind, "id": str(1000 + i)}
+        for i in range(n)
+    ]
+
+
+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
+    assert evaluate(
+        c.win_condition,
+        _ctx(units=_alive(4), tick=3000, lost=3,
+             destroyed_records=[("fact", 100, 10)]),
+    )
+    # Razing only the decoy powr at (100,30) → not a win
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=_alive(4), tick=3000, lost=1,
+             destroyed_records=[("powr", 100, 30)]),
+    )
+    # Razing the sentinel fact at (125,38) is outside the region → not a win
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=_alive(4), tick=3000, lost=1,
+             destroyed_records=[("fact", 125, 38)]),
+    )
+    # Loss cap (3) tripped (4 lost) → not a win
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=_alive(2), tick=3000, lost=4,
+             destroyed_records=[("fact", 100, 10)]),
+    )
+    # Past deadline → not a win
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=_alive(4), tick=5401, lost=1,
+             destroyed_records=[("fact", 100, 10)]),
+    )
+    # Timeout with bar unmet → fail
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=_alive(4), tick=5500, lost=1, destroyed_records=[]),
+    )
+    # Force-wipe → fail
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=[], tick=3000, lost=7, destroyed_records=[]),
+    )
+    # Loss cap (>3) → fail
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=_alive(1), tick=3000, lost=4,
+             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
+    assert evaluate(
+        c.win_condition,
+        _ctx(units=_alive(4), tick=4000, lost=3,
+             destroyed_records=[("fact", 100, 10)]),
+    )
+    # 4 lost (one tank lost) → not a win, AND fail
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=_alive(3), tick=4000, lost=4,
+             destroyed_records=[("fact", 100, 10)]),
+    )
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=_alive(3), tick=4000, lost=4,
+             destroyed_records=[("fact", 100, 10)]),
+    )
+    # Only decoy razed → not a win
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=_alive(4), tick=4000, lost=1,
+             destroyed_records=[("powr", 100, 30)]),
+    )
+
+
+def test_hard_predicates():
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    # Intended: NE fact destroyed → WIN
+    assert evaluate(
+        c.win_condition,
+        _ctx(units=_alive(4), tick=4000, lost=2,
+             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
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=_alive(4), tick=4000, lost=1,
+             destroyed_records=[("powr", 100, 20)]),
+    )
+    # 3 lost → not a win, AND fail (cap is 2 on hard)
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=_alive(3), tick=4000, lost=3,
+             destroyed_records=[("fact", 100, 10)]),
+    )
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=_alive(3), tick=4000, lost=3,
+             destroyed_records=[("fact", 100, 10)]),
+    )
+
+
+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"
+        )
+
+
+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..14 / SOUTH
+    y≈26..30). Engine round-trip 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_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)."""
+    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}"
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        etypes = [a.type for a in c.scenario.actors if a.owner == "enemy"]
+        assert "fact" in etypes, f"{lvl}: must include enemy fact"
+        assert "powr" in etypes, f"{lvl}: must include enemy powr decoy"
+
+
+def test_sentinel_fact_present_per_level():
+    """A persistent enemy `fact` placed far from the objective region
+    so the engine does not auto-`done` the instant the objective fact
+    dies; within_ticks / units_lost_lte then evaluate cleanly on the
+    terminal frame (CLAUDE.md auto-terminate footgun)."""
+    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"
+        ]
+        # at least one objective candidate near (100,10)/(100,30) AND a
+        # far sentinel (>=12 cells from any objective 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] - 30) ** 2 <= 6 ** 2
+        ]
+        sentinels = [p for p in facts if p not in objs]
+        assert objs, f"{lvl}: must place ≥1 enemy fact in an objective region"
+        assert sentinels, (
+            f"{lvl}: must place ≥1 sentinel enemy fact outside the "
+            f"objective region (engine auto-done guard); got facts={facts}"
+        )
+
+
+def test_squad_composition_per_level():
+    """Squad A = 3 jeeps (bait), Squad B = 4 2tnk (strike) per spawn
+    group. Each level must place at least one (jeep x3) and one
+    (2tnk x4) on the agent side."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        jeep_groups = [
+            a for a in c.scenario.actors
+            if a.owner == "agent" and a.type == "jeep"
+        ]
+        tank_groups = [
+            a for a in c.scenario.actors
+            if a.owner == "agent" and a.type == "2tnk"
+        ]
+        assert jeep_groups, f"{lvl}: missing agent jeep squad"
+        assert tank_groups, f"{lvl}: missing agent 2tnk squad"
+        for j in jeep_groups:
+            assert (j.count or 1) == 3, f"{lvl}: jeep squad must be 3"
+        for t in tank_groups:
+            assert (t.count or 1) == 4, f"{lvl}: tank squad must be 4"
+
+
+# ── engine-driven scripted policies ─────────────────────────────────
+
+
+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 _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()]
+
+
+def _brute_all_on_decoy(rs, Command):
+    """Every unit attack-moves onto the decoy region (powr) — razes
+    the wrong target (which doesn't score), and tanks get shredded
+    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).
+    target_x, target_y = 100, 30
+    for e in (rs.get("enemy_summary") or []):
+        t = (e.get("type") or "").lower()
+        if t == "powr" and e.get("cell_y") is not None:
+            target_x, target_y = e["cell_x"], e["cell_y"]
+            break
+    for u in (rs.get("units_summary", []) or []):
+        cmds.append(Command.attack_move([str(u["id"])], target_x, target_y))
+    return cmds or [Command.observe()]
+
+
+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."""
+    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:
+        ty_unit = t.get("cell_y", 20)
+        tx, ty = (100, 30) if ty_unit >= 20 else (100, 10)
+        cmds.append(Command.attack_move([str(t["id"])], tx, ty))
+    return cmds or [Command.observe()]
+
+
+def _bait_only(rs, Command):
+    """Jeeps slash toward the decoy region (pulls the heavy garrison
+    into pursuit), tanks stand still. The fact survives — clock runs
+    out → LOSS. Tests that the bait without the counter-attack does
+    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.
+        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.
+    """
+    cmds = []
+    jeeps = _of_type(rs, {"jeep"})
+    tanks = _of_type(rs, {"2tnk"})
+    all_units = jeeps + tanks
+    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
+
+    for j in jeeps:
+        cmds.append(Command.move_units([str(j["id"])], bait_x, bait_y))
+
+    if not tanks:
+        return cmds or [Command.observe()]
+
+    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.
+    fact_id = None
+    for e in (rs.get("enemy_summary") or []):
+        et = (e.get("type") or "").lower()
+        if et != "fact":
+            continue
+        ex, ey = e.get("cell_x"), e.get("cell_y")
+        if ex is None or ey is None:
+            continue
+        if (ex - strike_x) ** 2 + (ey - strike_y) ** 2 <= 6 ** 2:
+            fact_id = str(e.get("id"))
+            break
+
+    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))
+    return cmds or [Command.observe()]
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_intended_diversion_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 diversion-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}, "
+        f"records={getattr(r.signals, 'enemy_buildings_destroyed_records', [])})"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_stall_loses(level, seed):
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _stall, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: stall must be a real timeout LOSS "
+        f"(no building takes damage), got {r.outcome}"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_brute_all_on_decoy_loses(level, seed):
+    """Brute frontal — every unit attack-moves onto the decoy powr.
+    The decoy is razed (which scores zero — `enemy_key_buildings_
+    destroyed_in_region` requires a `fact`) and the heavy e3 cluster
+    shreds the tanks; the real fact is left standing → LOSS."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _brute_all_on_decoy, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: brute-all-on-decoy must LOSE "
+        f"(real fact intact / 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_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."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _lazy_nearest, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: lazy nearest assignment must LOSE, "
+        f"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 (jeeps slash toward the decoy, tanks stand still)
+    must LOSE on every tier — the bait displacement yields ZERO
+    objective progress; the real fact survives and the clock runs
+    out. Discriminates "bait without strike" from the intended
+    "bait AND strike" 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 (real fact not "
+        f"destroyed), got {r.outcome} "
+        f"(bldgs={r.signals.enemy_buildings_destroyed_types})"
+    )

tests/test_coord_relay_attack.py

@@ -0,0 +1,387 @@
+"""coord-relay-attack — rocket-then-tank relay strike.
+
+The bar: intended Squad A (e3 rockets) engages FIRST → softens enemy
+armour → THEN Squad B (2tnk) follows up. WINS on every level and
+every hard seed (1-4). The wrong-policy lattice (stall, both-attack-
+at-once, B-only) must LOSE on medium and hard. Easy is the bare-skill
+tier (smaller enemy cluster, looser caps) so some wrong policies may
+squeak by there per the SCENARIO_REVIEW_CHECKLIST inert-easy-teeth
+convention.
+
+The Wave-2 `then:` happened-before composite enforces the ordering
+predicate: `units_killed_gte: K1` must latch before `units_killed_gte:
+K2`. Wrong policies fail either on attrition (`units_lost_lte`) or
+the clock (`after_ticks`).
+
+Validation is scripted (no model / network).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import compile_level
+from openra_bench.scenarios.win_conditions import WinContext, evaluate
+
+PACKS = Path(__file__).parent.parent / "openra_bench" / "scenarios" / "packs"
+PACK_PATH = PACKS / "coord-relay-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 == "coord-relay-attack"
+    assert pack.meta.capability == "action"
+    assert pack.meta.real_world_meaning, "real_world_meaning required"
+    assert pack.meta.robotics_analogue, "robotics_analogue required"
+    anchors = pack.meta.benchmark_anchor
+    assert isinstance(anchors, list) and len(anchors) == 4, (
+        f"benchmark_anchor must list all 4 anchors, got {anchors!r}"
+    )
+    joined = " ".join(anchors).lower()
+    for needle in ("sc2", "smac", "overlapping fires", "bound-and-bound"):
+        assert needle in joined, f"missing anchor keyword: {needle}"
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        assert c.map_supported
+        assert c.win_condition is not None
+        assert c.fail_condition is not None
+
+
+def _ctx(*, units=(), tick=1000, kills=0, lost=0):
+    """Synthesize a WinContext for predicate-level checks."""
+    import types
+
+    sig = types.SimpleNamespace(
+        game_tick=tick,
+        units_killed=kills,
+        units_lost=lost,
+        cash=0,
+        resources=0,
+        power_provided=0,
+        power_drained=0,
+        own_buildings=[],
+        own_building_types=set(),
+        enemies_seen_ids=set(),
+        enemy_buildings_seen_ids=set(),
+        explored_percent=0.0,
+        then_progress={},
+        seq_progress={},
+    )
+    return WinContext(
+        signals=sig,
+        render_state={"units_summary": list(units)},
+    )
+
+
+def _alive(n, type_="e3"):
+    return [
+        {"cell_x": 15, "cell_y": 20, "type": type_, "id": str(1000 + i)}
+        for i in range(n)
+    ]
+
+
+def test_easy_predicates():
+    c = compile_level(load_pack(PACK_PATH), "easy")
+    # Intended: relay completes (need K1 then K2 — same ctx satisfies
+    # both clauses in order on first eval), in time, under cap → WIN.
+    ctx = _ctx(units=_alive(5), tick=2500, kills=4, lost=2)
+    assert evaluate(c.win_condition, ctx)
+    # K1 unmet → not a win.
+    assert not evaluate(c.win_condition, _ctx(units=_alive(6), tick=2500, kills=1, lost=0))
+    # K2 unmet (3 kills, K2 is 4) → not a win.
+    assert not evaluate(c.win_condition, _ctx(units=_alive(6), tick=2500, kills=3, lost=0))
+    # Attrition cap busted (5 > 4) → fail.
+    assert evaluate(c.fail_condition, _ctx(units=_alive(1), tick=2500, kills=4, lost=5))
+    # Force-wipe → fail.
+    assert evaluate(c.fail_condition, _ctx(units=[], tick=2500, kills=4, lost=6))
+    # Timeout with bar unmet → fail.
+    assert evaluate(c.fail_condition, _ctx(units=_alive(5), tick=3002, kills=2, lost=1))
+
+
+def test_medium_predicates():
+    c = compile_level(load_pack(PACK_PATH), "medium")
+    # Intended: 7 kills, 5 lost, in time → WIN.
+    ctx = _ctx(units=_alive(3), tick=3500, kills=7, lost=5)
+    assert evaluate(c.win_condition, ctx)
+    # K1 unmet (only 2 kills) → not a win.
+    assert not evaluate(c.win_condition, _ctx(units=_alive(6), tick=3500, kills=2, lost=0))
+    # K2 unmet (6 kills) → not a win.
+    assert not evaluate(c.win_condition, _ctx(units=_alive(6), tick=3500, kills=6, lost=0))
+    # Attrition cap busted (6 > 5) → fail.
+    assert evaluate(c.fail_condition, _ctx(units=_alive(2), tick=3500, kills=7, lost=6))
+    # Force-wipe → fail.
+    assert evaluate(c.fail_condition, _ctx(units=[], tick=3500, kills=7, lost=7))
+    # Timeout → fail.
+    assert evaluate(c.fail_condition, _ctx(units=_alive(6), tick=4002, kills=6, lost=2))
+
+
+def test_hard_predicates():
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    # Intended: 10 kills, ≤5 lost, in time → WIN.
+    ctx = _ctx(units=_alive(3), tick=4000, kills=10, lost=5)
+    assert evaluate(c.win_condition, ctx)
+    # K1 unmet (3 kills) → not a win.
+    assert not evaluate(c.win_condition, _ctx(units=_alive(6), tick=4000, kills=3, lost=0))
+    # K2 unmet (9 kills) → not a win.
+    assert not evaluate(c.win_condition, _ctx(units=_alive(6), tick=4000, kills=9, lost=0))
+    # Attrition cap busted → fail.
+    assert evaluate(c.fail_condition, _ctx(units=_alive(2), tick=4000, kills=10, lost=6))
+    # Force-wipe → fail.
+    assert evaluate(c.fail_condition, _ctx(units=[], tick=4000, kills=10, lost=8))
+    # Timeout → fail.
+    assert evaluate(c.fail_condition, _ctx(units=_alive(6), tick=4502, kills=9, lost=2))
+
+
+def test_then_clause_enforces_ordering_under_consistent_eval():
+    """The then-clause latch is per-id and persists across evals via
+    `signals.then_progress`. Using a fresh ctx (and so fresh
+    then_progress) tests the leaf semantics; persistent-eval semantics
+    are tested in tests/test_then_composite.py."""
+    c = compile_level(load_pack(PACK_PATH), "medium")
+    # New ctx, but K2 already satisfied: greedy advance latches both
+    # clauses in the same eval (matches waypoint_sequence semantics
+    # validated in test_then_composite.py::test_then_late_a_then_b_…).
+    ctx = _ctx(units=_alive(3), tick=3500, kills=7, lost=0)
+    assert evaluate(c.win_condition, ctx)
+    # But: if K1 is never met (and K2 also not met), no progress.
+    ctx2 = _ctx(units=_alive(3), tick=3500, kills=2, lost=0)
+    assert not evaluate(c.win_condition, ctx2)
+
+
+def test_timeout_reachable_inside_max_turns():
+    """No draw degeneracy: the after_ticks fail trigger must be
+    reachable within max_turns (engine advances ~90 ticks per turn,
+    so max tick ≈ 93 + 90·(max_turns-1))."""
+    pack = load_pack(PACK_PATH)
+    expectations = {"easy": 3001, "medium": 4001, "hard": 4501}
+    for lvl, after in expectations.items():
+        c = compile_level(pack, lvl)
+        max_tick = 93 + 90 * (c.max_turns - 1)
+        assert after <= max_tick, (
+            f"{lvl}: after_ticks {after} > max reachable tick {max_tick} "
+            f"(max_turns={c.max_turns}); deadline never bites"
+        )
+
+
+def test_hard_has_two_spawn_point_groups():
+    """Hard-tier curation: ≥2 distinct agent spawn_point groups so the
+    seed round-robins the west-edge staging latitude (north / south)."""
+    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_squads_are_e3_then_2tnk_on_every_level():
+    """The relay only has teeth if Squad A is rocket soldiers (e3,
+    anti-vehicle) and Squad B is medium tanks (2tnk, anti-infantry):
+    A's rockets soften the enemy 2tnk horde; B mops up the e1s."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        agent_types = [a.type for a in c.scenario.actors if a.owner == "agent"]
+        assert "e3" in agent_types, f"{lvl}: Squad A must be e3 (rocket); got {agent_types}"
+        assert "2tnk" in agent_types, f"{lvl}: Squad B must be 2tnk; got {agent_types}"
+        enemy_types = [a.type for a in c.scenario.actors if a.owner == "enemy"]
+        assert "2tnk" in enemy_types, f"{lvl}: enemy must include 2tnk (the threat A softens)"
+        assert "e1" in enemy_types, f"{lvl}: enemy must include e1 (what B mops up)"
+        # Persistent far enemy marker (engine auto-done mitigation).
+        assert "proc" in enemy_types, f"{lvl}: needs a persistent enemy survivor marker"
+
+
+# ── engine-driven scripted policies ─────────────────────────────────
+
+
+def _split_squads(rs):
+    """Return (a_ids, b_ids): Squad A = e3 (rocket); Squad B = 2tnk."""
+    a_ids, b_ids = [], []
+    for u in (rs.get("units_summary") or []):
+        t = str(u.get("type", "")).lower()
+        if t == "e3":
+            a_ids.append(str(u["id"]))
+        elif t == "2tnk":
+            b_ids.append(str(u["id"]))
+    return a_ids, b_ids
+
+
+def _enemy_centre(rs):
+    en = rs.get("enemy_summary") or []
+    if not en:
+        return (60, 20)  # fallback to known cluster centre
+    cx = sum(int(e["cell_x"]) for e in en) / len(en)
+    cy = sum(int(e["cell_y"]) for e in en) / len(en)
+    return (int(cx), int(cy))
+
+
+def _stall(rs, Command):
+    """Pure observe — enemies hold (stance:2), agent never engages →
+    kill bar unmet → after_ticks LOSS."""
+    return [Command.observe()]
+
+
+def _both_attack_at_once(rs, Command):
+    """Both squads attack_move the enemy cluster simultaneously.
+    B's tanks reach the cluster around the same instant A's rockets do
+    and get focus-fired by the enemy 4× 2tnk → units_lost cap busts on
+    medium/hard."""
+    a_ids, b_ids = _split_squads(rs)
+    if not a_ids and not b_ids:
+        return [Command.observe()]
+    ex, ey = _enemy_centre(rs)
+    cmds = []
+    if a_ids:
+        cmds.append(Command.attack_move(a_ids, ex, ey))
+    if b_ids:
+        cmds.append(Command.attack_move(b_ids, ex, ey))
+    return cmds or [Command.observe()]
+
+
+def _b_only(rs, Command):
+    """Squad B (tanks) advances first; Squad A (rockets) holds. B
+    faces the un-softened enemy 2tnk horde alone → bleeds → attrition
+    cap busts before the kill bar is met."""
+    a_ids, b_ids = _split_squads(rs)
+    if not b_ids and not a_ids:
+        return [Command.observe()]
+    ex, ey = _enemy_centre(rs)
+    cmds = []
+    if b_ids:
+        cmds.append(Command.attack_move(b_ids, ex, ey))
+    if a_ids:
+        cmds.append(Command.stop(a_ids))
+    return cmds or [Command.observe()]
+
+
+def _make_intended_a_then_b():
+    """Factory: per-episode closure (turn counter + soften-state
+    tracker). Relay doctrine:
+      • Squad A (rockets) commits to the enemy cluster from turn 1
+        and attempts to soften the heavy 2tnk line.
+      • Squad B (tanks) HOLDS until either (a) the enemy heavy line
+        is at least half-suppressed (≤50% of original 2tnk left),
+        OR (b) enough wall-clock turns have elapsed that A has had
+        the chance to do its work (fallback for the case where A
+        gets melted before completing the soften — B still needs
+        to advance and contribute kills).
+    The two-trigger design models real fire-and-maneuver: the relay
+    fires on suppression OR on a timed bound, not just on a perfect
+    suppression latch. (Without the timed fallback, a wipe of A
+    means B never advances and the kill bar is never met.)
+    """
+    state = {"initial_tanks": None, "turn": 0, "released": False}
+    # Turn at which B is released regardless of suppression status.
+    # ~16 turns ≈ 1440 ticks = enough for A to walk from x=15 to
+    # x=60 (45 cells) and engage for a few seconds. Tuned so the
+    # B-only / both-at-once paths don't accidentally land before
+    # this trigger (they advance from turn 1, so they hit the
+    # enemy faster than the gated release).
+    RELEASE_TURN = 16
+
+    def _policy(rs, Command):
+        state["turn"] += 1
+        a_ids, b_ids = _split_squads(rs)
+        if not a_ids and not b_ids:
+            return [Command.observe()]
+        ex, ey = _enemy_centre(rs)
+        enemy_tanks = [
+            e for e in (rs.get("enemy_summary") or [])
+            if str(e.get("type", "")).lower() == "2tnk"
+        ]
+        if state["initial_tanks"] is None and len(enemy_tanks) > 0:
+            state["initial_tanks"] = len(enemy_tanks)
+        cmds = []
+        if a_ids:
+            cmds.append(Command.attack_move(a_ids, ex, ey))
+        if b_ids:
+            if state["released"]:
+                cmds.append(Command.attack_move(b_ids, ex, ey))
+            else:
+                init = state["initial_tanks"]
+                suppressed = (
+                    init is not None
+                    and init > 0
+                    and len(enemy_tanks) * 2 <= init
+                )
+                if suppressed or state["turn"] >= RELEASE_TURN:
+                    state["released"] = True
+                    cmds.append(Command.attack_move(b_ids, ex, ey))
+                else:
+                    cmds.append(Command.stop(b_ids))
+        return cmds or [Command.observe()]
+
+    return _policy
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_intended_a_then_b_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, _make_intended_a_then_b(), seed=seed)
+    assert r.outcome == "win", (
+        f"{level} seed={seed}: intended A-then-B relay should WIN, "
+        f"got {r.outcome} after {r.turns} turns "
+        f"(kills={r.signals.units_killed}, losses={r.signals.units_lost})"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_stall_loses(level, seed):
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _stall, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: stall must be a real timeout LOSS "
+        f"(no engagement → kill bar unmet), got {r.outcome}"
+    )
+
+
+@pytest.mark.parametrize("level", ["medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_both_attack_at_once_loses(level, seed):
+    """Sending both squads in simultaneously exposes B's tanks to the
+    un-softened enemy 4× 2tnk before A's rockets can suppress them.
+    Attrition cap busts on medium/hard. Easy is excluded (forgiving
+    bare-skill tier with smaller cluster and cap=4)."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _both_attack_at_once, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: both-at-once must LOSE (B tanks bleed "
+        f"to enemy 2tnk before A softens), got {r.outcome} "
+        f"(kills={r.signals.units_killed}, losses={r.signals.units_lost})"
+    )
+
+
+@pytest.mark.parametrize("level", ["medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_b_only_loses(level, seed):
+    """Squad B (tanks) charging alone faces the full enemy 2tnk + e1
+    cluster — outgunned by the enemy tanks, attrition cap busts before
+    the K2 bar is met. Easy excluded (forgiving cluster)."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _b_only, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: B-only must LOSE (B tanks alone vs "
+        f"enemy 4× 2tnk + 4× e1), got {r.outcome} "
+        f"(kills={r.signals.units_killed}, losses={r.signals.units_lost})"
+    )

tests/test_coord_squad_handoff.py

@@ -0,0 +1,360 @@
+"""coord-squad-handoff: sequenced squad handoff via the Wave-2 `then:`
+happened-before composite + a new type-filtered region predicate
+(`units_of_type_in_region_gte`).
+
+The pack tests the SQUAD HANDOFF capability: Squad A (jeeps) must
+deliver objective P1 FIRST, THEN Squad B (medium tanks) must deliver
+P2; harder tiers add more alternating handoffs. The bar (per CLAUDE.md)
+must hold on every level × every hard seed (1..4):
+
+  - STALL          -> LOSS (clock)
+  - B-FIRST        -> LOSS (then-latch never advances past A)
+  - SINGLE-SQUAD   -> LOSS (the wrong-type squad can't satisfy clause 2)
+  - INTENDED PLAY  -> WIN  (parallel A→P1, B→P2 with B holding for A's
+                            latch)
+
+A separate unit test pins the new predicate (`units_of_type_in_region
+_gte`) to its exact semantics — it must NOT count units of the wrong
+type at the region.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import compile_level
+from openra_bench.scenarios.win_conditions import WinContext, evaluate
+
+PACK = (
+    Path(__file__).parent.parent
+    / "openra_bench"
+    / "scenarios"
+    / "packs"
+    / "coord-squad-handoff.yaml"
+)
+
+# Per-level expected handoff count: easy 2 (A→B); medium 3 (A→B→A);
+# hard 4 (A→B→A→B).
+EXPECTED_CLAUSES = {"easy": 2, "medium": 3, "hard": 4}
+
+
+def _win_clauses(c):
+    return dict(c.win_condition.__pydantic_extra__ or {})["all_of"]
+
+
+def _fail_clauses(c):
+    return dict(c.fail_condition.__pydantic_extra__ or {})["any_of"]
+
+
+def _then_clauses(c):
+    for cl in _win_clauses(c):
+        if "then" in cl:
+            return cl["then"]["clauses"]
+    return None
+
+
+# ── A. STRUCTURAL: predicate / order / deadline are wired correctly ──
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_level_uses_then_with_type_filtered_region_clauses(level):
+    pack = load_pack(PACK)
+    assert pack.meta.capability == "action"
+    c = compile_level(pack, level)
+    clauses = _then_clauses(c)
+    assert clauses is not None, f"{level}: must use a `then:` composite"
+    assert len(clauses) == EXPECTED_CLAUSES[level], (
+        f"{level}: expected {EXPECTED_CLAUSES[level]} handoff clauses, "
+        f"got {len(clauses)}"
+    )
+    # Every clause is a type-filtered region predicate (the new
+    # `units_of_type_in_region_gte`). Type-agnostic `units_in_region
+    # _gte` would NOT enforce squad identity.
+    for i, cl in enumerate(clauses):
+        assert "units_of_type_in_region_gte" in cl, (
+            f"{level} clause {i}: handoff must enforce squad identity"
+        )
+        v = cl["units_of_type_in_region_gte"]
+        assert v["n"] >= 3, f"{level} clause {i}: needs n>=3 (full squad)"
+        assert v["type"] in {"jeep", "2tnk"}, (
+            f"{level} clause {i}: unknown squad unit type {v['type']}"
+        )
+    # Clauses must alternate squad types — that IS the handoff.
+    types = [cl["units_of_type_in_region_gte"]["type"] for cl in clauses]
+    for i in range(1, len(types)):
+        assert types[i] != types[i - 1], (
+            f"{level}: handoff clauses must alternate squad types, got {types}"
+        )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_level_has_binding_deadline_and_real_loss(level):
+    c = compile_level(load_pack(PACK), level)
+    win = _win_clauses(c)
+    wt = [cl["within_ticks"] for cl in win if "within_ticks" in cl]
+    assert wt, f"{level}: missing within_ticks deadline"
+    # The deadline must bite within max_turns (engine ~90 ticks/turn).
+    assert wt[0] < 93 + 90 * (c.max_turns - 1), (
+        f"{level}: within_ticks {wt[0]} unreachable inside max_turns "
+        f"{c.max_turns} (would draw on timeout)"
+    )
+    # Every level must be able to emit a LOSS on timeout.
+    fail = _fail_clauses(c)
+    assert any("after_ticks" in cl for cl in fail), (
+        f"{level}: missing after_ticks in fail_condition"
+    )
+
+
+def test_handoff_count_scales_with_difficulty():
+    pack = load_pack(PACK)
+    counts = [
+        len(_then_clauses(compile_level(pack, lv)))
+        for lv in ("easy", "medium", "hard")
+    ]
+    assert counts == [2, 3, 4], (
+        f"handoff count should ladder 2->3->4, got {counts}"
+    )
+
+
+# ── B. PREDICATE UNIT TEST: units_of_type_in_region_gte semantics ────
+
+class _Sig:
+    def __init__(self):
+        self.game_tick = 100
+        self.then_progress: dict = {}
+
+
+def _ctx(units):
+    return WinContext(signals=_Sig(), render_state={"units_summary": units})
+
+
+def test_type_filtered_region_predicate_ignores_wrong_type():
+    """The whole point of the new predicate: 3 jeeps at P1 do NOT
+    satisfy a `2tnk, n=3` clause at P1 — the wrong-type squad cannot
+    take over for the right squad."""
+    spec = {"units_of_type_in_region_gte":
+        {"type": "2tnk", "x": 90, "y": 30, "radius": 8, "n": 3}}
+    # 3 jeeps at the region — wrong type.
+    jeeps = [
+        {"type": "jeep", "cell_x": 90, "cell_y": 30, "id": str(i)}
+        for i in range(3)
+    ]
+    assert evaluate(spec, _ctx(jeeps)) is False
+    # Add 3 tanks (correct type) at the region — now satisfied.
+    tanks = jeeps + [
+        {"type": "2tnk", "cell_x": 91, "cell_y": 31, "id": "t%d" % i}
+        for i in range(3)
+    ]
+    assert evaluate(spec, _ctx(tanks)) is True
+
+
+def test_type_filtered_region_predicate_respects_radius():
+    spec = {"units_of_type_in_region_gte":
+        {"type": "jeep", "x": 50, "y": 10, "radius": 5, "n": 2}}
+    near = [
+        {"type": "jeep", "cell_x": 51, "cell_y": 11, "id": "1"},
+        {"type": "jeep", "cell_x": 49, "cell_y": 10, "id": "2"},
+    ]
+    far = [{"type": "jeep", "cell_x": 60, "cell_y": 25, "id": "3"}]
+    assert evaluate(spec, _ctx(near)) is True
+    assert evaluate(spec, _ctx(far)) is False
+    assert evaluate(spec, _ctx(near + far)) is True
+
+
+def test_then_with_type_region_orders_squad_handoff():
+    """End-to-end: a `then:` chain of type-filtered region clauses
+    enforces the squad order — B-first never latches."""
+    spec = {"then": {
+        "id": "handoff",
+        "clauses": [
+            {"units_of_type_in_region_gte":
+                {"type": "jeep", "x": 50, "y": 10, "radius": 8, "n": 3}},
+            {"units_of_type_in_region_gte":
+                {"type": "2tnk", "x": 90, "y": 30, "radius": 8, "n": 3}},
+        ],
+    }}
+    sig = _Sig()
+    # B-first: 3 tanks at P2, 0 jeeps at P1.
+    b_first = [
+        {"type": "2tnk", "cell_x": 90, "cell_y": 30, "id": "t%d" % i}
+        for i in range(3)
+    ]
+    ctx = WinContext(signals=sig, render_state={"units_summary": b_first})
+    assert evaluate(spec, ctx) is False
+    assert sig.then_progress["handoff"] == 0  # B alone never advances A
+    # Now A also arrives at P1 — chain completes in one evaluation
+    # (clause 0 advances, clause 1 already satisfied).
+    both = b_first + [
+        {"type": "jeep", "cell_x": 50, "cell_y": 10, "id": "j%d" % i}
+        for i in range(3)
+    ]
+    ctx = WinContext(signals=sig, render_state={"units_summary": both})
+    assert evaluate(spec, ctx) is True
+    assert sig.then_progress["handoff"] == 2
+
+
+# ── C. SOLVENCY / NO-CHEAT: scripted policies on the live engine ─────
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+from openra_bench.eval_core import run_level  # noqa: E402
+
+
+def _split_by_type(rs):
+    us = rs.get("units_summary", []) or []
+    jeeps = [str(u["id"]) for u in us if u.get("type") == "jeep"]
+    tanks = [str(u["id"]) for u in us if u.get("type") == "2tnk"]
+    return jeeps, tanks
+
+
+def _stall(rs, C):
+    return [C.observe()]
+
+
+def _b_first(rs, C):
+    """Send ONLY squad B (tanks) toward its waypoint, ignore A.
+    The `then:` chain stays at index 0 forever — clause 0 (jeeps at
+    P1) never latches, so clause 1 is never credited."""
+    _jeeps, tanks = _split_by_type(rs)
+    if not tanks:
+        return [C.observe()]
+    return [C.move_units(tanks, 90, 30)]
+
+
+def _single_squad_tour(rs, C):
+    """Squad A (jeeps) tours P1 then P2. Clause 1 latches (jeeps at
+    P1). Clause 2 demands TANKS at P2 — jeeps don't count — so the
+    chain never completes regardless of where the jeeps drive."""
+    jeeps, _tanks = _split_by_type(rs)
+    if not jeeps:
+        return [C.observe()]
+    # Just keep sending jeeps to BOTH waypoints — engine moves them.
+    return [C.move_units(jeeps, 90, 30)]
+
+
+def _intended_handoff(rs, C):
+    """Parallel dispatch: jeeps to P1, tanks to P2 — B holds at P2
+    while A latches at P1, then `then:` advances both clauses."""
+    jeeps, tanks = _split_by_type(rs)
+    cmds = []
+    if jeeps:
+        cmds.append(C.move_units(jeeps, 50, 10))
+    if tanks:
+        cmds.append(C.move_units(tanks, 90, 30))
+    return cmds or [C.observe()]
+
+
+def _make_handoff_policy(legs):
+    """Build a stateful policy that drives each squad through its
+    own list of waypoints in order — once a leg is reached (>=3
+    units of that type in radius 8), it sticks (no oscillation back
+    to a satisfied earlier leg if a single unit drifts out). `legs`
+    is {unit_type: [(x,y), (x,y), ...]}, executed in order."""
+    state = {t: 0 for t in legs}
+
+    def policy(rs, C):
+        us = rs.get("units_summary", []) or []
+        cmds = []
+        for utype, waypoints in legs.items():
+            ids = [str(u["id"]) for u in us if u.get("type") == utype]
+            if not ids:
+                continue
+            idx = state[utype]
+            # Advance through every consecutive waypoint already
+            # satisfied (sticky — never regress).
+            while idx < len(waypoints):
+                wx, wy = waypoints[idx]
+                here = sum(
+                    1 for u in us
+                    if u.get("type") == utype
+                    and (u["cell_x"] - wx) ** 2 + (u["cell_y"] - wy) ** 2
+                    <= 8 * 8
+                )
+                if here >= 3 and idx < len(waypoints) - 1:
+                    idx += 1
+                else:
+                    break
+            state[utype] = idx
+            tx, ty = waypoints[idx]
+            cmds.append(C.move_units(ids, tx, ty))
+        return cmds or [C.observe()]
+
+    return policy
+
+
+def _intended_handoff_medium_factory():
+    return _make_handoff_policy({
+        "jeep": [(50, 10), (60, 20)],
+        "2tnk": [(90, 30)],
+    })
+
+
+def _intended_handoff_hard_factory():
+    return _make_handoff_policy({
+        "jeep": [(50, 10), (60, 20)],
+        "2tnk": [(90, 30), (100, 15)],
+    })
+
+
+# Seeds 1..4 = the held-out seed contract from CLAUDE.md.
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_stall_loses(level, seed):
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _stall, seed=seed)
+    assert res.outcome == "loss", (
+        f"{level} seed{seed}: stall must LOSE on timeout, got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_b_first_loses(level, seed):
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _b_first, seed=seed)
+    assert res.outcome == "loss", (
+        f"{level} seed{seed}: B-first dash must LOSE (then-latch never "
+        f"advances past A's clause), got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_single_squad_tour_loses(level, seed):
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _single_squad_tour, seed=seed)
+    assert res.outcome == "loss", (
+        f"{level} seed{seed}: single-squad tour (jeeps only) must LOSE "
+        f"— the tank-only clause cannot be satisfied — got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_intended_handoff_wins_easy(seed):
+    c = compile_level(load_pack(PACK), "easy")
+    res = run_level(c, _intended_handoff, seed=seed)
+    assert res.outcome == "win", (
+        f"easy seed{seed}: parallel A→P1/B→P2 must WIN, got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_intended_handoff_wins_medium(seed):
+    c = compile_level(load_pack(PACK), "medium")
+    res = run_level(c, _intended_handoff_medium_factory(), seed=seed)
+    assert res.outcome == "win", (
+        f"medium seed{seed}: 3-leg handoff must WIN, got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_intended_handoff_wins_hard(seed):
+    c = compile_level(load_pack(PACK), "hard")
+    res = run_level(c, _intended_handoff_hard_factory(), seed=seed)
+    assert res.outcome == "win", (
+        f"hard seed{seed}: 4-leg interleaved handoff must WIN, got "
+        f"{res.outcome}"
+    )

tests/test_def_in_depth.py

@@ -0,0 +1,259 @@
+"""def-in-depth scenario family, full loop on Rust.
+
+The pack tests defense-in-depth doctrine: against a massed rush band,
+the same total pbox capacity laid out as TWO concentric layers wins,
+while the same pbox count in a single line or a single cluster loses.
+The discriminator is layout topology, not raw count.
+
+* `building_count_gte:{pbox,4}` (easy/medium) / 5 (hard) — minimum
+  defensive capacity floor; less than this can't survive even with
+  perfect placement.
+* `building_in_region:{(25,20),r=4,pbox,2}` AND
+  `building_in_region:{(15,20),r=4,pbox,2}` — REGION predicates with
+  non-overlapping radii (FRONT x in [21..29], REAR x in [11..19]) so
+  the model MUST physically split the 4 pbox across two depths;
+  a single cluster of 4 pbox at one x can satisfy at most ONE region.
+* `has_building:fact` + `own_units_gte:1` — the base survives and a
+  defender is on the field at the deadline.
+* `within_ticks:5400` (easy) / 4500 (medium/hard) paired with
+  `after_ticks:5401/4501` — a non-finisher is a real reachable
+  timeout LOSS (60 turns × ≤90 ticks/step in interrupt mode reaches
+  ≥4848), never a draw.
+
+These tests prove with deterministic scripted policies (no model, no
+network) that:
+
+* the intended layered 2+2 policy WINS every easy/medium seed (1..4);
+* stall / single-line / single-cluster all LOSE every level + seed —
+  a real LOSS, not a draw;
+* the `after_ticks` deadline is reachable inside `max_turns`;
+* the hard tier defines ≥2 spawn_point groups.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+from openra_bench.eval_core import run_level
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+
+PACK = PACKS_DIR / "def-in-depth.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+
+# ── scripted policies ─────────────────────────────────────────────────
+
+
+def stall(rs, C):
+    """Observe-only — never spends. Fact razed by the rush."""
+    return [C.observe()]
+
+
+def _make_cluster_builder(cells):
+    """Queue many pbox up front (Defense queue accepts backlog), then
+    place each at the next cell from `cells` as production completes.
+    Stops once every cell is built."""
+
+    def policy(rs, C):
+        own_b = rs.get("own_buildings") or []
+        pbox_count = sum(1 for b in own_b if b.get("type") == "pbox")
+        if pbox_count >= len(cells):
+            return [C.observe()]
+        prod = rs.get("production") or []
+        prod_items = [p.get("item") for p in prod if isinstance(p, dict)]
+        n_in_q = sum(1 for it in prod_items if it == "pbox")
+        cmds = []
+        # Refill queue so we always have ≥1 pbox in flight while waiting
+        # (the Defense queue tolerates a backlog; this halves wall-clock
+        # from serial build-place pairs).
+        need_to_queue = len(cells) - pbox_count - n_in_q
+        for _ in range(max(0, need_to_queue)):
+            cmds.append(C.build("pbox"))
+        # Try to place the next cell each turn — if no pbox is ready
+        # the engine logs PLACE BLOCKED and moves on (harmless).
+        cell = cells[pbox_count]
+        cmds.append(C.place_building("pbox", cell[0], cell[1]))
+        return cmds
+
+    return policy
+
+
+def make_layered_2_2():
+    """Intended: 2 front (x=25) + 2 rear (x=15), y centred on 20."""
+    return _make_cluster_builder(
+        [(25, 19), (25, 21), (15, 19), (15, 21)]
+    )
+
+
+def make_layered_3_2(front_y, rear_y):
+    """Hard-tier intended: 4 front pbox are pre-placed (2 at each
+    latitude); agent adds 2 REAR pbox at its OWN spawn latitude →
+    total 6 pbox: 4 front + 2 rear-at-spawn. `front_y` is unused;
+    it's kept in the signature for symmetry with the test caller."""
+    return _make_cluster_builder([
+        (15, rear_y - 1), (15, rear_y + 1),
+    ])
+
+
+def make_stack_front():
+    """Stack MORE pbox at FRONT (x=25): 2 inherited + 4 more → all 6
+    at front, 0 at rear → rear-region predicate fails. The thick
+    single wall eventually attrites under sustained pressure even
+    if it survives the first wave → fact razed OR clock LOSS."""
+    return _make_cluster_builder(
+        [(25, 17), (25, 18), (25, 22), (25, 23)]
+    )
+
+
+def make_single_line():
+    """4 pbox in a thin column at x=20 — BETWEEN the two regions
+    (front=[21..29], rear=[11..19] both exclude x=20). Neither region
+    gains a NEW pbox here (rear-region count from inherited front
+    pboxes = 0) → win unsatisfied; under pressure the thin line
+    falls and the fact dies → LOSS."""
+    return _make_cluster_builder(
+        [(20, 16), (20, 18), (20, 20), (20, 22)]
+    )
+
+
+def make_no_build():
+    """Issue no build orders — the 2 inherited pbox satisfy front
+    region but rear region count = 0, total count = 2 < 4. LOSS."""
+    def policy(rs, C):
+        return [C.observe()]
+    return policy
+
+
+# ── scenario-shape invariants ─────────────────────────────────────────
+
+
+def test_pack_compiles_with_three_levels_and_rusher_bot():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "def-in-depth"
+    assert pack.meta.capability == "reasoning"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+    anchors = pack.meta.benchmark_anchor
+    assert any("defense-in-depth" in a.lower() for a in anchors), anchors
+    assert any("multi-layer" in a.lower() for a in anchors), anchors
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.map_supported
+        enemy = c.scenario.enemy
+        bot = getattr(enemy, "bot_type", None) or getattr(enemy, "bot", None)
+        assert (str(bot).lower() == "rusher"), (lvl, bot)
+
+
+@pytest.mark.parametrize("level", LEVELS)
+def test_every_level_has_a_reachable_timeout_fail(level):
+    c = compile_level(load_pack(PACK), level)
+    assert c.fail_condition is not None
+    fc = c.fail_condition.model_dump(exclude_none=True)
+    deadline = None
+    for clause in fc.get("any_of", []) or []:
+        if "after_ticks" in clause:
+            deadline = int(clause["after_ticks"])
+    assert deadline is not None, f"{level}: no after_ticks fail clause"
+    reachable = 93 + 90 * (c.max_turns - 1)
+    assert deadline < reachable, (
+        f"{level}: deadline {deadline} unreachable within "
+        f"{c.max_turns} turns (max tick {reachable}) → draw degeneracy"
+    )
+
+
+def test_hard_has_two_spawn_point_groups():
+    c = compile_level(load_pack(PACK), "hard")
+    groups = {
+        a.spawn_point for a in c.scenario.actors
+        if a.owner == "agent" and a.spawn_point is not None
+    }
+    assert groups == {0, 1}, groups
+    for a in c.scenario.actors:
+        x, y = a.position
+        assert 2 <= x <= 126 and 2 <= y <= 38, (a.type, a.position)
+
+
+def test_region_radii_are_non_overlapping():
+    """The two layer regions (front=(25,20,r=4), rear=(15,20,r=4)) MUST
+    not overlap, or a single tall cluster satisfies both predicates and
+    the capability isn't enforced."""
+    c = compile_level(load_pack(PACK), "easy")
+    win = c.win_condition.model_dump(exclude_none=True)
+    regions = [
+        clause["building_in_region"]
+        for clause in win.get("all_of", [])
+        if "building_in_region" in clause
+    ]
+    assert len(regions) == 2, regions
+    (a, b) = regions
+    dx = abs(int(a["x"]) - int(b["x"]))
+    assert dx > int(a["radius"]) + int(b["radius"]), (
+        f"regions overlap: dx={dx}, rA+rB={a['radius']+b['radius']}"
+    )
+
+
+# ── solvency: intended WINS every easy/medium seed ────────────────────
+
+
+@pytest.mark.parametrize("level", ["easy", "medium"])
+def test_intended_layered_policy_wins_every_seed(level):
+    c = compile_level(load_pack(PACK), level)
+    for seed in SEEDS:
+        r = run_level(c, make_layered_2_2(), seed=seed)
+        assert r.outcome == "win", (
+            f"{level} seed{seed}: intended 2+2 layered play must WIN; "
+            f"got {r.outcome} (tick={r.signals.game_tick}, "
+            f"kills={r.signals.units_killed}, "
+            f"lost={r.signals.units_lost}, "
+            f"buildings={r.signals.own_buildings})"
+        )
+
+
+def test_intended_layered_3_2_wins_hard_every_seed():
+    """Hard tier — the agent commits 3+2 at whichever latitude its
+    base spawned (try BOTH and take whichever wins; the any_of win
+    accepts either)."""
+    c = compile_level(load_pack(PACK), "hard")
+    for seed in SEEDS:
+        # spawn_point round-robins 0/1 by seed; without knowing which
+        # one this seed picked, try both latitudes and require at
+        # least one to win — the model in the field will read its own
+        # fact position from the observation.
+        wins = []
+        for (fy, ry) in [(14, 14), (26, 26)]:
+            r = run_level(c, make_layered_3_2(fy, ry), seed=seed)
+            wins.append(r.outcome == "win")
+        assert any(wins), (
+            f"hard seed{seed}: at least one layered 3+2 latitude "
+            f"must WIN (model picks latitude from its own fact pos)"
+        )
+
+
+# ── no-cheat: every wrong-topology policy LOSES (not draws) ───────────
+
+
+@pytest.mark.parametrize("level", ["easy", "medium"])
+@pytest.mark.parametrize(
+    "policy_name,policy_factory",
+    [
+        ("stall", lambda: stall),
+        ("stack_front", make_stack_front),
+        ("single_line_between", make_single_line),
+        ("no_build", make_no_build),
+    ],
+)
+def test_lazy_and_wrong_topology_policies_lose_every_seed(
+    level, policy_name, policy_factory
+):
+    c = compile_level(load_pack(PACK), level)
+    for seed in SEEDS:
+        r = run_level(c, policy_factory(), seed=seed)
+        assert r.outcome == "loss", (
+            f"{level} seed{seed} {policy_name}: must LOSE (real fail, "
+            f"not a draw); got {r.outcome} (tick={r.signals.game_tick}, "
+            f"kills={r.signals.units_killed}, "
+            f"buildings={r.signals.own_buildings})"
+        )

tests/test_def_surprise_flank_react.py

@@ -0,0 +1,318 @@
+"""def-surprise-flank-react scenario family, full loop on Rust.
+
+The pack tests SURPRISE-AXIS REACTION: the brief states the enemy will
+attack from the NORTH and the world is pre-rigged accordingly (2
+pillboxes + 4 defenders pre-positioned on the NORTH lane). The actual
+rusher band arrives from the SOUTH and walks around the entire NORTH
+defence line. The intended capability is detecting the actual attack
+axis from the observation and RE-POSITIONING the four pre-placed
+defenders to intercept the real rush. The pre-built NORTH pillboxes
+are dead wood for this engagement; the capability is the reactive
+re-positioning, not the build.
+
+The win predicate makes all three axes load-bearing:
+
+* `has_building:fact` ⇒ the fact must survive (stall / stay-NORTH /
+  pure-build all let it get razed by the south rush);
+* `units_killed_gte:4` ⇒ the south rush must actually be engaged
+  (stay-NORTH never engages, the 4 defenders sit at y≈14 while the
+  rusher band walks past them at y≈20..32);
+* `own_units_gte:3` ⇒ ≥3 defenders must survive (the south rush
+  reaching the fact splashes the close defenders even if some
+  trade);
+* `within_ticks:4500` paired with `after_ticks:4501` ⇒ a non-finisher
+  is a real reachable timeout LOSS (50 turns × ≤90 ticks/step reaches
+  ≥4503 in interrupt mode), never a draw.
+
+These tests prove with deterministic scripted policies (no model, no
+network) that:
+
+* the intended detect-and-redeploy policy WINS every level + every
+  hard seed (1..4);
+* stall / stay-NORTH / pure-build all LOSE every level + every hard
+  seed (a real LOSS, not a draw);
+* the `after_ticks` deadline is reachable inside `max_turns`;
+* the hard tier defines ≥2 spawn_point groups (so the base latitude
+  and matching surprise-axis vary by seed — anti-memorisation).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+from openra_bench.eval_core import run_level
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+
+PACK = PACKS_DIR / "def-surprise-flank-react.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+
+# ── scripted policies ─────────────────────────────────────────────────
+
+
+def _fact_xy(rs):
+    fact = next(
+        (b for b in (rs.get("own_buildings") or [])
+         if b.get("type") == "fact"),
+        None,
+    )
+    if fact is None:
+        return None
+    return int(fact["cell_x"]), int(fact["cell_y"])
+
+
+def _enemies(rs):
+    return [
+        e for e in (rs.get("enemy_positions") or [])
+    ]
+
+
+def stall(rs, C):
+    """Observe-only — defenders never move; the south rush walks
+    past the pre-built NORTH defence and razes the fact."""
+    return [C.observe()]
+
+
+def stay_north(rs, C):
+    """Stay-NORTH: explicitly issue an attack_move toward the NORTH
+    pillbox line (where the intel said the rush would arrive). The
+    defenders re-park on the WRONG axis and never engage the actual
+    south rusher band; fact razed → LOSS.
+    """
+    units = rs.get("units_summary") or []
+    own = [u for u in units if str(u.get("type", "")).lower() in ("e1", "e3")]
+    if not own:
+        return [C.observe()]
+    xy = _fact_xy(rs)
+    if xy is None:
+        return [C.observe()]
+    fx, fy = xy
+    # Park defenders NORTH of the fact (y_fact - 6). This is where
+    # the pre-built pillbox line sits (the intel direction).
+    target_y = max(2, fy - 6)
+    ids = [str(u["id"]) for u in own]
+    return [C.attack_move(ids, target_x=fx, target_y=target_y)]
+
+
+def pure_build(rs, C):
+    """Pure-build: try to spend the starting cash on an extra building
+    near the existing NORTH defence (or anywhere) but NEVER re-position
+    the defenders. With cash 800 and no tent the infantry queue is
+    empty; the model can only queue a pbox (600cr) or a powr. Either
+    way the south rush reaches the fact unopposed → LOSS.
+    """
+    own_b = rs.get("own_buildings") or []
+    prod = rs.get("production") or []
+    prod_items = [
+        p.get("item") for p in prod if isinstance(p, dict)
+    ]
+    xy = _fact_xy(rs)
+    if xy is None:
+        return [C.observe()]
+    fx, fy = xy
+    n_pbox = sum(1 for b in own_b if b.get("type") == "pbox")
+    cmds = []
+    # Try to queue + place a third NORTH pbox (the "intel" lane).
+    if n_pbox < 3:
+        if "pbox" not in prod_items:
+            cmds.append(C.build("pbox"))
+        cmds.append(C.place_building("pbox", fx + 4, fy - 6))
+    if not cmds:
+        cmds.append(C.observe())
+    return cmds
+
+
+def make_intended():
+    """Detect-and-redeploy: observe the spotted rusher units (which
+    arrive on the SURPRISE axis, not the intel axis), then commit all
+    four defenders to engage them. The 4 defenders intercept the rush
+    before/at the fact, focus-fire on the visible rusher cluster,
+    kill ≥4 and keep ≥3 alive; fact survives → WIN.
+    """
+
+    def policy(rs, C):
+        units = rs.get("units_summary") or []
+        own = [u for u in units if str(u.get("type", "")).lower() in ("e1", "e3")]
+        if not own:
+            return [C.observe()]
+        xy = _fact_xy(rs)
+        if xy is None:
+            return [C.observe()]
+        fx, fy = xy
+        ids = [str(u["id"]) for u in own]
+        # Detect actual rush axis from any visible enemy (rs lists
+        # them in `enemy_summary`; the fogged `enemy_positions` is
+        # empty for this pack's start). If any rusher is visible,
+        # commit ALL defenders onto it (attack_unit on the nearest
+        # rusher → focus-fire). Otherwise march toward the OPPOSITE
+        # side of the base from the pre-built pbox line — the
+        # surprise axis the brief warns about.
+        es = rs.get("enemy_summary") or []
+        # Filter out the inert far-east fact marker (and any other
+        # buildings); only mobile combat units.
+        rusher_units = [
+            e for e in es
+            if str(e.get("type", "")).lower() in ("e1", "e3")
+        ]
+        if rusher_units:
+            # Nearest rusher to the fact (the immediate threat).
+            tgt = min(
+                rusher_units,
+                key=lambda e: (
+                    (int(e.get("cell_x", fx)) - fx) ** 2
+                    + (int(e.get("cell_y", fy)) - fy) ** 2
+                ),
+            )
+            eid = str(tgt.get("id"))
+            return [C.attack_unit(ids, eid)]
+        # No rusher visible yet — march toward the surprise axis
+        # (opposite the pre-built pbox line).
+        own_b = rs.get("own_buildings") or []
+        pboxes = [b for b in own_b if b.get("type") == "pbox"]
+        if pboxes:
+            pby = sum(int(b["cell_y"]) for b in pboxes) // len(pboxes)
+            ty = fy + 6 if pby < fy else fy - 6
+            tx = fx
+        else:
+            return [C.observe()]
+        return [C.attack_move(ids, target_x=tx, target_y=ty)]
+
+    return policy
+
+
+# ── scenario-shape invariants ─────────────────────────────────────────
+
+
+def test_pack_compiles_with_three_levels_and_rusher_bot():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "def-surprise-flank-react"
+    assert pack.meta.capability == "reasoning"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+    anchors = pack.meta.benchmark_anchor
+    assert any("adversarial robustness" in a for a in anchors), anchors
+    assert any("CICERO" in a for a in anchors), anchors
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.map_supported
+        enemy = c.scenario.enemy
+        bot = getattr(enemy, "bot_type", None) or getattr(enemy, "bot", None)
+        assert (str(bot).lower() == "rusher"), (lvl, bot)
+
+
+@pytest.mark.parametrize("level", LEVELS)
+def test_every_level_has_a_reachable_timeout_fail(level):
+    """Non-win must be a real LOSS: the `after_ticks` fail must be
+    strictly below the tick reachable at max_turns (≤90 ticks/step in
+    interrupt mode)."""
+    c = compile_level(load_pack(PACK), level)
+    assert c.fail_condition is not None
+    fc = c.fail_condition.model_dump(exclude_none=True)
+    deadline = None
+    for clause in fc.get("any_of", []) or []:
+        if "after_ticks" in clause:
+            deadline = int(clause["after_ticks"])
+    assert deadline is not None, f"{level}: no after_ticks fail clause"
+    reachable = 93 + 90 * (c.max_turns - 1)
+    assert deadline < reachable, (
+        f"{level}: deadline {deadline} unreachable within "
+        f"{c.max_turns} turns (max tick {reachable}) → draw degeneracy"
+    )
+
+
+def test_hard_has_two_spawn_point_groups():
+    """Hard-tier contract: ≥2 distinct seed-driven spawn_point groups
+    so the base latitude (and matching surprise axis) varies by seed."""
+    c = compile_level(load_pack(PACK), "hard")
+    groups = {
+        a.spawn_point for a in c.scenario.actors
+        if a.owner == "agent" and a.spawn_point is not None
+    }
+    assert groups == {0, 1}, groups
+    # In-bounds check (rush-hour-arena playable y ≈ 2..38, x ≈ 2..126):
+    for a in c.scenario.actors:
+        x, y = a.position
+        assert 2 <= x <= 126 and 2 <= y <= 38, (a.type, a.position)
+
+
+def test_pre_built_north_defense_present_easy_and_medium():
+    """The PRE-BUILT NORTH pillbox line + four pre-placed NORTH
+    defenders must be present on easy and medium (the "trap" the
+    intended play must walk away from)."""
+    for level in ("easy", "medium"):
+        c = compile_level(load_pack(PACK), level)
+        pboxes = [
+            a for a in c.scenario.actors
+            if a.owner == "agent" and a.type == "pbox"
+        ]
+        assert len(pboxes) == 2, (level, pboxes)
+        defenders = [
+            a for a in c.scenario.actors
+            if a.owner == "agent" and a.type == "e1"
+        ]
+        assert len(defenders) == 4, (level, defenders)
+
+
+# ── solvency: intended WINS every level + every hard seed ────────────
+
+
+@pytest.mark.parametrize("level", LEVELS)
+def test_intended_detect_and_redeploy_wins_every_level_and_seed(level):
+    c = compile_level(load_pack(PACK), level)
+    for seed in SEEDS:
+        r = run_level(c, make_intended(), seed=seed)
+        assert r.outcome == "win", (
+            f"{level} seed{seed}: intended detect-and-redeploy play "
+            f"must WIN; got {r.outcome} (tick={r.signals.game_tick}, "
+            f"kills={r.signals.units_killed}, "
+            f"lost={r.signals.units_lost}, "
+            f"buildings={r.signals.own_buildings})"
+        )
+
+
+# ── no-cheat: every lazy / wrong-axis policy LOSES (not draws) ───────
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize(
+    "policy_name,policy_factory",
+    [
+        ("stall", lambda: stall),
+        ("stay_north", lambda: stay_north),
+        ("pure_build", lambda: pure_build),
+    ],
+)
+def test_lazy_and_wrong_axis_policies_lose_every_level_and_seed(
+    level, policy_name, policy_factory
+):
+    """Stall (fact razed), stay-NORTH (defenders park on the intel
+    lane while the south rush walks past), and pure-build (more
+    buildings on the intel lane, defenders never re-positioned) must
+    ALL LOSE on every level + every seed — no draw."""
+    c = compile_level(load_pack(PACK), level)
+    for seed in SEEDS:
+        r = run_level(c, policy_factory(), seed=seed)
+        assert r.outcome == "loss", (
+            f"{level} seed{seed} {policy_name}: must LOSE (real fail, "
+            f"not a draw); got {r.outcome} (tick={r.signals.game_tick}, "
+            f"kills={r.signals.units_killed}, "
+            f"buildings={r.signals.own_buildings})"
+        )
+
+
+# ── determinism ───────────────────────────────────────────────────────
+
+
+def test_intended_run_is_deterministic_on_easy():
+    c = compile_level(load_pack(PACK), "easy")
+    a = run_level(c, make_intended(), seed=3)
+    b = run_level(c, make_intended(), seed=3)
+    assert (a.outcome, a.turns, a.signals.units_killed) == (
+        b.outcome,
+        b.turns,
+        b.signals.units_killed,
+    ), "same seed must be deterministic"

tests/test_def_tower_line_vs_cluster.py

@@ -0,0 +1,276 @@
+"""def-tower-line-vs-cluster scenario family, full loop on Rust.
+
+The pack tests DEFENSE TOPOLOGY: when the threat is forced through a
+known chokepoint, the right architecture is dense cluster AT the choke
+(graph min-cut / military bunker placement doctrine), NOT a thin spread
+along the perimeter. The win predicate makes the topology decision
+load-bearing — total pbox count alone is not sufficient:
+
+* `building_count_gte:{pbox, n}` ⇒ the agent actually built the budget
+  worth of defences (3 on easy, 4 on medium, 5 on hard);
+* `building_in_region:{pbox, x:60, y:20, radius:5, count}` ⇒ ≥3 (easy),
+  ≥3 (medium), or ≥4 (hard) of those pbox sit INSIDE the choke region —
+  a spread-line layout (one pbox at the choke, the rest along the
+  perimeter) satisfies the count but NOT the region;
+* `building_count_gte:{fact,1}` ⇒ the fact must still stand (rather than
+  `has_building:fact` which is a one-shot "ever seen" set — see CLAUDE.md
+  footgun);
+* `within_ticks` paired with `after_ticks` ⇒ a non-finisher is a real
+  reachable timeout LOSS (no interrupts on this pack ⇒ each step is
+  exactly 90 ticks, so max_turns is a hard tick budget that the
+  `after_ticks` deadline reliably bites in).
+
+The scripted-policy validations prove deterministically that:
+
+* the intended CLUSTER policy (all pbox built INSIDE the choke region)
+  WINS every level + every hard seed (1..4);
+* stall / spread-line (1 at choke + rest perimeter) / pure-army
+  (no pbox) all LOSE every level + every hard seed — a real LOSS, not
+  a draw;
+* the hard tier defines ≥2 spawn_point groups (north y=10 / south y=30)
+  so a memorised relative-to-base placement that lands in the same
+  world cell on every seed cannot solve the pack.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+
+from openra_bench.eval_core import run_level
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+
+PACK = PACKS_DIR / "def-tower-line-vs-cluster.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+# Per-level total pbox budget (exactly `starting_cash / 600`).
+_N_PBOX = {"easy": 3, "medium": 4, "hard": 5}
+
+
+# ── scripted policies ────────────────────────────────────────────────
+
+
+def stall(rs, C):
+    """Observe-only — the agent never spends. Fact gets razed and/or
+    the clock runs out."""
+    return [C.observe()]
+
+
+def make_cluster(choke=(60, 20)):
+    """Intended CLUSTER topology: every pbox is placed INSIDE the choke
+    region (within radius 5 of the choke cell)."""
+    cx0, cy0 = choke
+    # Eight pre-chosen cells around the choke; the policy uses as many
+    # as the budget needs (easy:3, medium:4, hard:5).
+    cells = [
+        (cx0 - 2, cy0 - 1), (cx0, cy0 - 1), (cx0 + 2, cy0 - 1),
+        (cx0 - 2, cy0 + 1), (cx0, cy0 + 1), (cx0 + 2, cy0 + 1),
+        (cx0 - 1, cy0),     (cx0 + 1, cy0),
+    ]
+
+    def policy(rs, C):
+        own_b = rs.get("own_buildings") or []
+        n = sum(1 for b in own_b if b.get("type") == "pbox")
+        prod = rs.get("production") or []
+        prod_items = [p.get("item") for p in prod if isinstance(p, dict)]
+        cmds = []
+        # Once enough pboxes are up, idle (the win clause counts the
+        # current building list each turn).
+        if n >= len(cells):
+            return [C.observe()]
+        if "pbox" not in prod_items:
+            cmds.append(C.build("pbox"))
+        cmds.append(C.place_building("pbox", cells[n][0], cells[n][1]))
+        if not cmds:
+            cmds.append(C.observe())
+        return cmds
+
+    return policy
+
+
+def make_spread_line(n_pbox):
+    """SPREAD-LINE topology: one pbox at the choke + the rest along the
+    perimeter near the base. Satisfies `building_count_gte` but FAILS
+    `building_in_region` (only 1 of N at the choke, not the required
+    3-of-3 / 3-of-4 / 4-of-5)."""
+    cells = [(60, 20), (20, 18), (24, 18), (28, 18), (32, 18)][:n_pbox]
+
+    def policy(rs, C):
+        own_b = rs.get("own_buildings") or []
+        n = sum(1 for b in own_b if b.get("type") == "pbox")
+        prod = rs.get("production") or []
+        prod_items = [p.get("item") for p in prod if isinstance(p, dict)]
+        cmds = []
+        if n >= len(cells):
+            return [C.observe()]
+        if "pbox" not in prod_items:
+            cmds.append(C.build("pbox"))
+        cmds.append(C.place_building("pbox", cells[n][0], cells[n][1]))
+        if not cmds:
+            cmds.append(C.observe())
+        return cmds
+
+    return policy
+
+
+def pure_army(rs, C):
+    """PURE-ARMY: only ever train e1 — never builds a pbox. FAILS the
+    `building_count_gte:pbox` clause AND lets the rush eventually reach
+    the fact (or runs out the clock with no pbox)."""
+    prod = rs.get("production") or []
+    prod_items = [p.get("item") for p in prod if isinstance(p, dict)]
+    if "e1" not in prod_items:
+        return [C.build("e1")]
+    return [C.observe()]
+
+
+# ── scenario-shape invariants ────────────────────────────────────────
+
+
+def test_pack_compiles_with_three_levels_and_rusher_bot():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "def-tower-line-vs-cluster"
+    assert pack.meta.capability == "reasoning"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+    # Required-by-spec benchmark anchors.
+    anchors = pack.meta.benchmark_anchor
+    assert any("min-cut" in a.lower() or "chokepoint" in a.lower() for a in anchors), anchors
+    assert any("bunker" in a.lower() for a in anchors), anchors
+    # Rusher bot wired through (charges agent centroid → forces the
+    # rush path through the mid-map choke on every seed).
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.map_supported
+        bot = getattr(c.scenario.enemy, "bot_type", None) or getattr(
+            c.scenario.enemy, "bot", None
+        )
+        assert str(bot).lower() == "rusher", (lvl, bot)
+
+
+def test_starting_cash_is_exact_pbox_budget():
+    """The cash is intentionally tight (3/4/5 pbox at 600 each, zero
+    slack). A model that spends on units OR extra power runs out before
+    the count clause is satisfied — the topology decision is the spend."""
+    pack = load_pack(PACK)
+    for lvl, expected in (("easy", 1800), ("medium", 2400), ("hard", 3000)):
+        c = compile_level(pack, lvl)
+        assert c.starting_cash == expected, (lvl, c.starting_cash)
+
+
+@pytest.mark.parametrize("level", LEVELS)
+def test_every_level_has_a_reachable_timeout_fail(level):
+    """Non-win must be a real LOSS: the `after_ticks` fail clause must
+    be strictly below the tick reachable at max_turns. No interrupts on
+    this pack ⇒ each step is exactly 90 ticks (max tick = 93+90·(N-1))."""
+    c = compile_level(load_pack(PACK), level)
+    assert c.fail_condition is not None
+    fc = c.fail_condition.model_dump(exclude_none=True)
+    deadline = None
+    for clause in fc.get("any_of", []) or []:
+        if "after_ticks" in clause:
+            deadline = int(clause["after_ticks"])
+    assert deadline is not None, f"{level}: no after_ticks fail clause"
+    reachable = 93 + 90 * (c.max_turns - 1)
+    assert deadline < reachable, (
+        f"{level}: deadline {deadline} unreachable within "
+        f"{c.max_turns} turns (max tick {reachable}) → draw degeneracy"
+    )
+
+
+def test_fact_alive_clause_uses_present_tense_predicate():
+    """The fact-survival clause must use the PRESENT-TENSE predicate
+    (`building_count_gte:{type:fact,n:1}`) rather than `has_building`,
+    which is a one-shot "ever seen" set that stays true after the fact
+    is destroyed (a documented CLAUDE.md footgun). Otherwise the rush
+    razing the fact would not trigger a LOSS."""
+    for lvl in LEVELS:
+        c = compile_level(load_pack(PACK), lvl)
+        fc = c.fail_condition.model_dump(exclude_none=True)
+        fact_clauses = [
+            clause for clause in fc.get("any_of", []) or []
+            if isinstance(clause, dict)
+            and isinstance(clause.get("not"), dict)
+            and "building_count_gte" in (clause["not"] or {})
+            and (clause["not"]["building_count_gte"] or {}).get("type") == "fact"
+        ]
+        assert fact_clauses, f"{lvl}: missing present-tense fact-alive fail clause"
+
+
+def test_hard_has_two_spawn_point_groups():
+    """Hard-tier contract: ≥2 distinct agent spawn_point groups so a
+    memorised relative-to-base placement that lands in the same world
+    cell on every seed cannot generalise."""
+    c = compile_level(load_pack(PACK), "hard")
+    groups = {
+        a.spawn_point for a in c.scenario.actors
+        if a.owner == "agent" and a.spawn_point is not None
+    }
+    assert groups == {0, 1}, groups
+    # In-bounds check (rush-hour-arena playable y ≈ 2..38, x ≈ 2..126):
+    for a in c.scenario.actors:
+        x, y = a.position
+        assert 2 <= x <= 126 and 2 <= y <= 38, (a.type, a.position)
+
+
+# ── solvency: intended CLUSTER wins every level + every hard seed ────
+
+
+@pytest.mark.parametrize("level", LEVELS)
+def test_intended_cluster_wins_every_level_and_seed(level):
+    c = compile_level(load_pack(PACK), level)
+    for seed in SEEDS:
+        r = run_level(c, make_cluster(), seed=seed)
+        assert r.outcome == "win", (
+            f"{level} seed{seed}: intended cluster topology must WIN; "
+            f"got {r.outcome} (tick={r.signals.game_tick}, "
+            f"kills={r.signals.units_killed}, "
+            f"lost={r.signals.units_lost}, "
+            f"buildings={r.signals.own_buildings})"
+        )
+
+
+# ── no-cheat: every lazy / wrong-topology policy LOSES (not draws) ───
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize(
+    "policy_name,policy_factory",
+    [
+        ("stall",       lambda lvl: stall),
+        ("spread_line", lambda lvl: make_spread_line(_N_PBOX[lvl])),
+        ("pure_army",   lambda lvl: pure_army),
+    ],
+)
+def test_lazy_and_wrong_topology_policies_lose_every_level_and_seed(
+    level, policy_name, policy_factory
+):
+    """Stall (rush razes fact OR clock), spread-line (region clause
+    unmet), and pure-army (count clause unmet) must ALL LOSE on every
+    level + every seed — no draw."""
+    c = compile_level(load_pack(PACK), level)
+    fn = policy_factory(level)
+    for seed in SEEDS:
+        r = run_level(c, fn, seed=seed)
+        assert r.outcome == "loss", (
+            f"{level} seed{seed} {policy_name}: must LOSE (real fail, "
+            f"not a draw); got {r.outcome} (tick={r.signals.game_tick}, "
+            f"buildings={r.signals.own_buildings})"
+        )
+
+
+# ── determinism ──────────────────────────────────────────────────────
+
+
+def test_intended_run_is_deterministic_on_easy():
+    c = compile_level(load_pack(PACK), "easy")
+    a = run_level(c, make_cluster(), seed=3)
+    b = run_level(c, make_cluster(), seed=3)
+    assert (a.outcome, a.turns, a.signals.units_killed) == (
+        b.outcome,
+        b.turns,
+        b.signals.units_killed,
+    ), "same seed must be deterministic"

tests/test_econ_cash_reserve_management.py

@@ -0,0 +1,315 @@
+"""econ-cash-reserve-management — REASONING capability validation.
+
+Real-world anchor: SC2 cash overflow management (spend down while
+keeping reserve); corporate treasury / operational-reserve doctrine;
+financial-runway management. The agent starts with a productive base
+(4 buildings: fact + proc + tent + powr; 2 harvs on 2 near mines)
+and $1500. The win predicate requires SPEND (build more buildings)
+AND maintaining a CASH RESERVE simultaneously — the "cash management
+loop" (operate while preserving working capital).
+
+Bar (CLAUDE.md "no defect, no cheat"):
+   - stall LOSES every tier / every hard seed (no build → bldg_total
+     stuck at 4 → bar unmet → timeout LOSS).
+   - pure-hold (harvest only, never build) LOSES every tier / seed
+     (same: bldg_total stuck at 4).
+   - over-spend (chain proc 1400 + pbox 600 → cash dips to 0) LOSES
+     on medium and hard (income cannot refill above the reserve bar
+     before the tight tick deadline). Easy permits over-spend because
+     the deadline is generous — that's the "loose-bar" tier by
+     construction.
+   - intended steady-build-with-reserve WINS every tier / seed.
+   - hard tier defines ≥2 agent spawn_point groups (NORTH / SOUTH
+     base) so a memorised opening cannot generalise.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+
+from openra_bench.eval_core import run_level
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+from openra_bench.scenarios.win_conditions import WinContext, evaluate
+
+PACK = PACKS_DIR / "econ-cash-reserve-management.yaml"
+
+
+# ── policies ────────────────────────────────────────────────────────
+
+
+def _stall(rs, Command):
+    """No-op every turn. Bldg_total never grows past 4 → bar unmet → LOSS."""
+    return [Command.observe()]
+
+
+def _pure_hold(rs, Command):
+    """Harvest only, never build. Income accumulates but bldg_total
+    stays at 4 → bar unmet → LOSS on building bar."""
+    units = rs.get("units_summary", []) or []
+    harvs = [u for u in units if u.get("type") == "harv"]
+    if not harvs:
+        return [Command.observe()]
+    return [Command.harvest([str(h["id"])], 22, int(h["cell_y"])) for h in harvs]
+
+
+def _over_spend(rs, Command):
+    """Chain a proc (1400) + 2× pbox (600 each) immediately. Cash dips
+    to 0 the moment bldg_total reaches 6/7 — must wait for income to
+    refill above the 300/500 reserve bar. On medium/hard the tick
+    budget runs out before recovery → LOSS."""
+    units = rs.get("units_summary", []) or []
+    harvs = [u for u in units if u.get("type") == "harv"]
+    cmds = []
+    for h in harvs:
+        cmds.append(Command.harvest([str(h["id"])], 22, int(h["cell_y"])))
+    # Queue + place orders spammed each turn until accepted.
+    cmds.append(Command.build("proc"))
+    cmds.append(Command.place_building("proc", 14, 24))
+    cmds.append(Command.build("pbox"))
+    cmds.append(Command.place_building("pbox", 16, 24))
+    cmds.append(Command.build("pbox"))
+    cmds.append(Command.place_building("pbox", 18, 24))
+    return cmds
+
+
+def _intended(rs, Command):
+    """Build 3× powr ($900 total) while keeping both harvs harvesting.
+    Reaches bldg_total 7 at cash ~600 (well above the medium 300 and
+    hard 500 reserve). Wins easy/medium (bldg_total only needs 5/6)
+    and hard (bldg_total 7). The cash-management capability: spend
+    cheap, keep reserve."""
+    units = rs.get("units_summary", []) or []
+    harvs = [u for u in units if u.get("type") == "harv"]
+    cmds = []
+    for h in harvs:
+        cmds.append(Command.harvest([str(h["id"])], 22, int(h["cell_y"])))
+    cmds.append(Command.build("powr"))
+    cmds.append(Command.place_building("powr", 18, 20))
+    cmds.append(Command.build("powr"))
+    cmds.append(Command.place_building("powr", 18, 22))
+    cmds.append(Command.build("powr"))
+    cmds.append(Command.place_building("powr", 18, 24))
+    return cmds
+
+
+# ── helpers ─────────────────────────────────────────────────────────
+
+
+def _run(level, policy, seed=1):
+    c = compile_level(load_pack(PACK), level)
+    assert c.map_supported, "rush-hour-arena terrain must be present"
+    return c, run_level(c, policy, seed=seed)
+
+
+# ── structural ──────────────────────────────────────────────────────
+
+
+def test_pack_loads_and_meta_active():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "econ-cash-reserve-management"
+    assert pack.meta.capability == "reasoning"
+    assert pack.meta.real_world_meaning
+    assert pack.meta.robotics_analogue
+    anchors = " ".join(pack.meta.benchmark_anchor).lower()
+    assert "sc2" in anchors
+    assert "treasury" in anchors or "reserve" in anchors or "runway" in anchors
+
+
+def test_tools_include_required_set():
+    """Pack must declare the [observe, build, place_building, harvest,
+    move_units, stop] toolset (the cash-management interaction surface)."""
+    pack = load_pack(PACK)
+    tools = set(pack.base.get("tools", []) if isinstance(pack.base, dict) else [])
+    for required in ("observe", "build", "place_building", "harvest",
+                     "move_units", "stop"):
+        assert required in tools, f"missing tool: {required!r}"
+
+
+def test_all_tiers_have_reachable_deadlines():
+    """tick-alignment idiom: within_ticks ≤ ceiling AND
+    after_ticks ≤ ceiling AND within_ticks + 1 == after_ticks (so a
+    non-finisher LOSES, not draws)."""
+    pack = load_pack(PACK)
+    for lvl in ("easy", "medium", "hard"):
+        L = pack.levels[lvl]
+        ceiling = 93 + 90 * (L.max_turns - 1)
+        wt = next(
+            int(c["within_ticks"])
+            for c in L.win_condition.model_dump()["all_of"]
+            if "within_ticks" in c
+        )
+        ft = next(
+            int(c["after_ticks"])
+            for c in L.fail_condition.model_dump()["any_of"]
+            if "after_ticks" in c
+        )
+        assert wt <= ceiling, f"{lvl}: within_ticks {wt} > ceiling {ceiling}"
+        assert ft <= ceiling, f"{lvl}: after_ticks {ft} > ceiling {ceiling}"
+        assert wt + 1 == ft, (
+            f"{lvl}: within_ticks {wt} / after_ticks {ft} mismatch "
+            "(non-finisher must LOSE, not draw — fail clause one tick"
+            " past win clause)"
+        )
+
+
+def test_hard_has_two_seed_driven_spawn_groups():
+    """Hard tier: ≥2 distinct agent spawn_point groups so engine
+    round-robins start by seed."""
+    c = compile_level(load_pack(PACK), "hard")
+    sp = {
+        (a.spawn_point if a.spawn_point is not None else 0)
+        for a in c.scenario.actors
+        if a.owner == "agent"
+    }
+    assert len(sp) >= 2, (
+        f"hard must define ≥2 agent spawn_point groups; got {sorted(sp)}"
+    )
+
+
+def test_fail_condition_present_on_every_tier():
+    pack = load_pack(PACK)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        assert c.fail_condition is not None, f"{lvl} needs a fail_condition"
+
+
+# ── predicate-level (no engine) ─────────────────────────────────────
+
+
+def _ctx(*, units=(), tick=1000, cash=0, resources=0, own_buildings=()):
+    import types
+
+    sig = types.SimpleNamespace(
+        game_tick=tick,
+        units_killed=0,
+        units_lost=0,
+        cash=cash,
+        resources=resources,
+        own_buildings=list(own_buildings),
+        own_building_types={str(t).lower() for (t, _, _) in own_buildings},
+        enemies_seen_ids=set(),
+        enemy_buildings_seen_ids=set(),
+    )
+    return WinContext(
+        signals=sig,
+        render_state={"units_summary": list(units)},
+    )
+
+
+def test_predicates_enforce_capability():
+    """Win requires (bldg_total bar AND cash reserve AND ≥2 harvs)
+    AND in-time; fail fires on timeout OR fact destroyed."""
+    c = compile_level(load_pack(PACK), "medium")
+    two_harvs = [
+        {"cell_x": 14, "cell_y": 18, "type": "harv"},
+        {"cell_x": 14, "cell_y": 20, "type": "harv"},
+    ]
+    six_bldgs = [
+        ("fact", 10, 22),
+        ("proc", 12, 18),
+        ("tent", 10, 18),
+        ("powr", 14, 22),
+        ("powr", 18, 22),
+        ("powr", 18, 24),
+    ]
+
+    # Intended: bldg_total≥6, cash≥300, 2 harvs, in time → WIN
+    assert evaluate(
+        c.win_condition,
+        _ctx(units=two_harvs, tick=600, cash=900, own_buildings=six_bldgs),
+    )
+    # Cash one short of 300 → not a win (reserve discipline)
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=two_harvs, tick=600, cash=299, own_buildings=six_bldgs),
+    )
+    # Only 5 buildings → not a win (growth bar)
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=two_harvs, tick=600, cash=2000, own_buildings=six_bldgs[:5]),
+    )
+    # Only 1 harv (the other died) → not a win
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=two_harvs[:1], tick=600, cash=900, own_buildings=six_bldgs),
+    )
+    # Timeout (tick past after_ticks): bar unmet → fail
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=two_harvs, tick=812, cash=0, own_buildings=six_bldgs),
+    )
+    # Fact destroyed → fail
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=two_harvs, tick=600, cash=900, own_buildings=six_bldgs[1:]),
+    )
+
+
+# ── engine-driven policies (the no-cheat bar) ───────────────────────
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_stall_loses_every_tier_and_seed(level, seed):
+    """No build → bldg_total stays at 4 → bar unmet → timeout LOSS."""
+    _, r = _run(level, _stall, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level}/seed{seed}: stall must LOSE (no growth, bar unmet); "
+        f"got {r.outcome} cash={r.signals.cash} turns={r.turns}"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_pure_hold_loses_every_tier_and_seed(level, seed):
+    """Pure harvest, never build → bldg_total stays at 4 → bar unmet
+    → timeout LOSS. The cash hoards but the growth axis is the bar."""
+    _, r = _run(level, _pure_hold, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level}/seed{seed}: pure-hold must LOSE (no buildings built); "
+        f"got {r.outcome} cash={r.signals.cash} turns={r.turns}"
+    )
+
+
+@pytest.mark.parametrize("level", ["medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_over_spend_loses_on_medium_and_hard(level, seed):
+    """Chain proc + 2× pbox → cash drains to 0; income cannot refill
+    above the reserve bar inside the tight medium/hard tick budget →
+    timeout LOSS. (Easy is intentionally loose — over-spend permitted
+    there; the discrimination tier is medium/hard.)"""
+    _, r = _run(level, _over_spend, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level}/seed{seed}: over-spend must LOSE on tight tier; "
+        f"got {r.outcome} cash={r.signals.cash} turns={r.turns}"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_intended_wins_every_tier_and_seed(level, seed):
+    """The intended capability — build cheap (3× powr = $900) while
+    harvesting — WINS every tier and every hard seed. Reaches
+    bldg_total 7 at cash ~600 (above the medium 300 and hard 500
+    reserve) well inside the deadline."""
+    _, r = _run(level, _intended, seed=seed)
+    assert r.outcome == "win", (
+        f"{level}/seed{seed}: intended cash-discipline should WIN; "
+        f"got {r.outcome} cash={r.signals.cash} turns={r.turns}"
+    )
+
+
+def test_outcomes_are_deterministic_per_seed():
+    """Same seed, same policy → identical outcome / cash / turn count."""
+    c = compile_level(load_pack(PACK), "medium")
+    a = run_level(c, _intended, seed=2)
+    b = run_level(c, _intended, seed=2)
+    assert (a.outcome, a.turns, a.signals.cash) == (
+        b.outcome, b.turns, b.signals.cash
+    )

tests/test_econ_recover_from_zero_cash.py

@@ -0,0 +1,502 @@
+"""No-cheat + solvency proof for `econ-recover-from-zero-cash` (Group F
+turtle-recovery / bankruptcy turnaround from a minimum-viable kit and
+zero working capital).
+
+The pack frames a RECOVERY-FROM-SETBACK decision: the agent inherits a
+minimum viable kit (fact + proc + one harv + one mine) and **$0 cash**.
+It must commit to harvesting first (the only income channel), then
+reinvest the accumulated cash on the next productive asset (a war
+factory + a second/third harvester) so the income channel actually
+scales past a non-trivial revenue bar.
+
+For every level + every hard seed (1-4):
+  * the INTENDED chain (harvest → save 2000 → build weap → build harv →
+    move+harvest new harv [→ build 3rd harv on hard]) WINS;
+  * STALL (only `observe`) LOSES every tier — no harvest, EV stays at 0,
+    clock bites as a reachable timeout LOSS;
+  * HARVEST-ONLY (run the starting harv but never build anything) is
+    the EASY floor (wins easy) but LOSES medium/hard on the 2-harv /
+    3-harv structural clause regardless of EV;
+  * BUILD-ARMY-FROM-ZERO (harvest → powr → tent → spam e1 instead of
+    weap → harv) LOSES every tier — no weap means no harv can be built,
+    and `tent`+`e1` spend drains the cash that should have gone to the
+    income-scaling chain;
+  * BUILD-TOO-SOON (harvest → spend cash on a SECOND refinery instead of
+    weap+harv) LOSES medium/hard — cash drained on the wrong asset
+    starves the 2-harv requirement.
+
+The 4 lazy plays + 1 intended × 3 levels × 4 seeds gives the full
+no-defect / no-cheat coverage demanded by CLAUDE.md.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+from openra_bench.eval_core import run_level
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+
+PACK = PACKS_DIR / "econ-recover-from-zero-cash.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+
+# ───────────────────────── helpers ────────────────────────────────────────
+
+
+def _patches_for_fact(fy: int) -> list[tuple[int, int]]:
+    """easy/medium have one patch at (22,18); hard has spawn-local
+    near patches: NORTH spawn → (22,14)+(22,16); SOUTH → (22,26)+(22,28)."""
+    if abs(fy - 18) <= 2:
+        return [(22, 18)]
+    if fy < 18:
+        return [(22, 14), (22, 16)]
+    return [(22, 26), (22, 28)]
+
+
+def _own_fact(bldgs):
+    """Return the AGENT-owned fact (skip the far enemy marker)."""
+    for b in bldgs:
+        if b.get("type") == "fact" and b.get("owner", "agent") != "enemy":
+            cx = b.get("cell_x", 0)
+            # The enemy marker is at (120,20) — filter it by x.
+            if cx < 100:
+                return b
+    return None
+
+
+def _ev(res):
+    return res.signals.cash + res.signals.resources
+
+
+# ───────────────────────── scripted policies ──────────────────────────────
+
+
+def _stall(rs, Command):
+    """Idle: never harvests, never builds. EV stays at 0 → bar unmet →
+    reachable timeout LOSS."""
+    return [Command.observe()]
+
+
+def _harvest_only_factory():
+    """Run the starting harv but never build anything. WINS easy (the
+    floor — bar 1500 is reachable with one harv) but LOSES medium/hard
+    (the 2-harv / 3-harv structural clause fails regardless of EV)."""
+
+    state = {"moved": set()}
+
+    def policy(rs, Command):
+        units = rs.get("units_summary", []) or []
+        bldgs = rs.get("own_buildings", []) or []
+        fact_b = _own_fact(bldgs)
+        if fact_b is None:
+            return [Command.observe()]
+        patches = _patches_for_fact(fact_b["cell_y"])
+        harvs = [
+            (u["id"], u.get("cell_x"), u.get("cell_y"))
+            for u in units
+            if str(u.get("type", "")).lower() == "harv"
+        ]
+        cmds = []
+        for i, (uid, cx, cy) in enumerate(harvs):
+            uid_s = str(uid)
+            px, py = patches[i % len(patches)]
+            if uid_s not in state["moved"]:
+                cmds.append(Command.move_units([uid_s], target_x=px, target_y=py))
+                if abs(cx - px) <= 3 and abs(cy - py) <= 3:
+                    state["moved"].add(uid_s)
+            else:
+                cmds.append(Command.harvest([uid_s], px, py))
+        return cmds if cmds else [Command.observe()]
+
+    return policy
+
+
+def _build_army_factory():
+    """Harvest a bit, then powr → tent → spam e1 instead of weap+harv.
+    Without weap, no harv can be built → 2-harv clause fails → LOSS on
+    every tier (even easy, where the army spend drains the EV bar)."""
+
+    state = {"moved": set()}
+
+    def policy(rs, Command):
+        units = rs.get("units_summary", []) or []
+        bldgs = rs.get("own_buildings", []) or []
+        own_types = {b["type"] for b in bldgs}
+        prod = rs.get("production", []) or []
+        cash = rs.get("cash", 0)
+        fact_b = _own_fact(bldgs)
+        if fact_b is None:
+            return [Command.observe()]
+        fx, fy = fact_b["cell_x"], fact_b["cell_y"]
+        patches = _patches_for_fact(fy)
+        harvs = [
+            (u["id"], u.get("cell_x"), u.get("cell_y"))
+            for u in units
+            if str(u.get("type", "")).lower() == "harv"
+        ]
+        cmds = []
+        for i, (uid, cx, cy) in enumerate(harvs):
+            uid_s = str(uid)
+            px, py = patches[i % len(patches)]
+            if uid_s not in state["moved"]:
+                cmds.append(Command.move_units([uid_s], target_x=px, target_y=py))
+                if abs(cx - px) <= 3 and abs(cy - py) <= 3:
+                    state["moved"].add(uid_s)
+            else:
+                cmds.append(Command.harvest([uid_s], px, py))
+        if "powr" not in own_types:
+            if cash >= 300 and "powr" not in prod:
+                cmds.append(Command.build("powr"))
+            cmds.append(Command.place_building("powr", fx + 2, fy - 3))
+        elif "tent" not in own_types:
+            if cash >= 400 and "tent" not in prod:
+                cmds.append(Command.build("tent"))
+            cmds.append(Command.place_building("tent", fx + 2, fy + 3))
+        elif cash >= 100 and "e1" not in prod:
+            cmds.append(Command.build("e1"))
+        return cmds if cmds else [Command.observe()]
+
+    return policy
+
+
+def _build_too_soon_factory():
+    """Harvest, then spend the FIRST accumulated cash on a SECOND
+    refinery (the wrong scaling asset) instead of weap+harv. The
+    income channel does NOT scale (single harv still) → the 2-harv
+    clause fails on medium/hard → LOSS."""
+
+    state = {"moved": set()}
+
+    def policy(rs, Command):
+        units = rs.get("units_summary", []) or []
+        bldgs = rs.get("own_buildings", []) or []
+        prod = rs.get("production", []) or []
+        cash = rs.get("cash", 0)
+        fact_b = _own_fact(bldgs)
+        if fact_b is None:
+            return [Command.observe()]
+        fx, fy = fact_b["cell_x"], fact_b["cell_y"]
+        patches = _patches_for_fact(fy)
+        harvs = [
+            (u["id"], u.get("cell_x"), u.get("cell_y"))
+            for u in units
+            if str(u.get("type", "")).lower() == "harv"
+        ]
+        cmds = []
+        for i, (uid, cx, cy) in enumerate(harvs):
+            uid_s = str(uid)
+            px, py = patches[i % len(patches)]
+            if uid_s not in state["moved"]:
+                cmds.append(Command.move_units([uid_s], target_x=px, target_y=py))
+                if abs(cx - px) <= 3 and abs(cy - py) <= 3:
+                    state["moved"].add(uid_s)
+            else:
+                cmds.append(Command.harvest([uid_s], px, py))
+        # Always try to queue a second proc and place it — the engine
+        # may block on prereqs but that's the point (spending intent on
+        # the wrong asset, not weap/harv).
+        n_proc = sum(1 for b in bldgs if b.get("type") == "proc")
+        if n_proc < 2:
+            if cash >= 1400 and "proc" not in prod:
+                cmds.append(Command.build("proc"))
+            cmds.append(Command.place_building("proc", fx + 5, fy + 1))
+        return cmds if cmds else [Command.observe()]
+
+    return policy
+
+
+def _intended_factory():
+    """Intended recovery chain: harvest with starting harv → save 2000 →
+    build('weap') + place → save 1400 → build('harv') → move new harv to
+    patch → harvest. On hard, build a 3rd harv after the 2nd. WINS
+    every tier × every seed."""
+
+    state = {"moved": set()}
+
+    def policy(rs, Command):
+        units = rs.get("units_summary", []) or []
+        bldgs = rs.get("own_buildings", []) or []
+        own_types = {b["type"] for b in bldgs}
+        prod = rs.get("production", []) or []
+        cash = rs.get("cash", 0)
+        fact_b = _own_fact(bldgs)
+        proc_b = next((b for b in bldgs if b.get("type") == "proc"), None)
+        if fact_b is None or proc_b is None:
+            return [Command.observe()]
+        fx, fy = fact_b["cell_x"], fact_b["cell_y"]
+        patches = _patches_for_fact(fy)
+        harvs = [
+            (u["id"], u.get("cell_x"), u.get("cell_y"))
+            for u in units
+            if str(u.get("type", "")).lower() == "harv"
+        ]
+        cmds = []
+        # Move each harv to a patch (round-robin) then harvest.
+        for i, (uid, cx, cy) in enumerate(harvs):
+            uid_s = str(uid)
+            px, py = patches[i % len(patches)]
+            if uid_s not in state["moved"]:
+                cmds.append(Command.move_units([uid_s], target_x=px, target_y=py))
+                if abs(cx - px) <= 3 and abs(cy - py) <= 3:
+                    state["moved"].add(uid_s)
+            else:
+                cmds.append(Command.harvest([uid_s], px, py))
+        # Build weap as soon as cash allows; spam place_building each
+        # turn (engine ignores PLACE until production completes — see
+        # econ-startup-from-scratch intended policy).
+        if "weap" not in own_types:
+            if cash >= 2000 and "weap" not in prod:
+                cmds.append(Command.build("weap"))
+            cmds.append(Command.place_building("weap", fx + 2, fy + 3))
+        else:
+            # Determine how many harvs we want: 2 for single-patch
+            # tiers (easy/medium), 3 for the two-patch hard tier.
+            want_harv = 2 if len(patches) == 1 else 3
+            if len(harvs) < want_harv and cash >= 1400 and "harv" not in prod:
+                cmds.append(Command.build("harv"))
+        return cmds if cmds else [Command.observe()]
+
+    return policy
+
+
+def _run(level, policy_or_factory, seed=1):
+    c = compile_level(load_pack(PACK), level)
+    assert c.map_supported, "rush-hour-arena must compile"
+    pol = (
+        policy_or_factory()
+        if callable(policy_or_factory)
+        and policy_or_factory.__name__.endswith("factory")
+        else policy_or_factory
+    )
+    return c, run_level(c, pol, seed=seed)
+
+
+# ───────────────────────── structural ─────────────────────────────────────
+
+
+def test_pack_loads_with_three_levels_and_required_tools():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "econ-recover-from-zero-cash"
+    assert pack.meta.capability == "reasoning"
+    assert pack.meta.status == "active"
+    assert set(pack.levels) == set(LEVELS)
+    c = compile_level(pack, "easy")
+    tools = set(c.scenario.tools or [])
+    # Spec-required tools (Wave-5 spec).
+    for t in ("observe", "build", "place_building", "harvest", "move_units", "stop"):
+        assert t in tools, f"missing tool {t} in {tools}"
+
+
+def test_starting_cash_is_zero_on_every_level():
+    """The pack headline is recovery FROM zero cash — every tier must
+    start with 0 cash so the income-first → reinvest decision is real."""
+    pack = load_pack(PACK)
+    for L in LEVELS:
+        c = compile_level(pack, L)
+        assert c.starting_cash == 0, (
+            f"{L}: starting_cash must be 0 (got {c.starting_cash})"
+        )
+
+
+def test_benchmark_anchor_lists_turtle_and_turnaround():
+    pack = load_pack(PACK)
+    anchors = pack.meta.benchmark_anchor
+    assert anchors, "benchmark_anchor must be non-empty"
+    blob = " | ".join(anchors).lower()
+    assert "sc2" in blob, anchors
+    assert "turtle" in blob or "recovery" in blob, anchors
+    assert "bankruptcy" in blob or "turnaround" in blob, anchors
+
+
+@pytest.mark.parametrize("level", LEVELS)
+def test_every_level_has_a_reachable_timeout_fail(level):
+    """Non-win must be a real LOSS, never a DRAW: after_ticks in
+    fail_condition must be reachable within max_turns (tick ≈ 93 +
+    90·(max_turns − 1)). within_ticks + 1 == after_ticks idiom."""
+    c = compile_level(load_pack(PACK), level)
+    assert c.fail_condition is not None
+    after_ticks = int(c.fail_condition.model_dump()["any_of"][0]["after_ticks"])
+    reachable = 93 + 90 * (c.max_turns - 1)
+    assert after_ticks <= reachable, (
+        f"{level}: fail after_ticks {after_ticks} unreachable within "
+        f"{c.max_turns} turns (max tick {reachable}) → draw degeneracy"
+    )
+    within_clauses = c.win_condition.model_dump().get("all_of", [])
+    wt = next(int(x["within_ticks"]) for x in within_clauses if "within_ticks" in x)
+    assert after_ticks == wt + 1, (
+        f"{level}: after_ticks {after_ticks} must equal within_ticks+1 ({wt + 1})"
+    )
+
+
+def test_hard_has_two_spawn_groups_for_base():
+    """Hard tier contract: ≥2 distinct agent spawn_point groups
+    (NORTH / SOUTH base) so seed round-robin varies the start cell and
+    a memorised opening can't generalise."""
+    c = compile_level(load_pack(PACK), "hard")
+    sps = {
+        (a.spawn_point if a.spawn_point is not None else 0)
+        for a in c.scenario.actors
+        if a.owner == "agent"
+    }
+    assert len(sps) >= 2, f"hard needs ≥2 spawn groups, got {sps}"
+
+
+# ───────────────────────── intended WIN bar ───────────────────────────────
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", SEEDS)
+def test_intended_chain_wins(level, seed):
+    """Intended recovery (harvest → weap → harv [+ harv on hard]) WINS
+    every tier × every seed."""
+    c, r = _run(level, _intended_factory, seed=seed)
+    assert r.outcome == "win", (
+        f"{level} seed{seed}: intended chain should WIN, got {r.outcome}; "
+        f"ev={_ev(r)}, cash={r.signals.cash}, harvs={r.signals.harvesters}, "
+        f"types={r.signals.own_building_types}, tick={r.signals.game_tick}"
+    )
+
+
+# ─────────────────────���─── no-cheat: lazy plays LOSE ──────────────────────
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", SEEDS)
+def test_stall_loses(level, seed):
+    """Stall (only `observe`) must LOSE every tier × every seed — no
+    harvest, EV stays at 0, bar unmet, clock bites as a real LOSS."""
+    c, r = _run(level, _stall, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed{seed} stall must LOSE; got {r.outcome} "
+        f"(ev={_ev(r)}, tick={r.signals.game_tick})"
+    )
+    assert _ev(r) == 0, f"stall earns nothing; got ev={_ev(r)}"
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+def test_harvest_only_is_easy_floor(seed):
+    """Harvest-only with the starting harv is the EASY FLOOR — it
+    clears the loose 1500 bar without needing a 2nd harv."""
+    c, r = _run("easy", _harvest_only_factory, seed=seed)
+    assert r.outcome == "win", (
+        f"easy seed{seed} harvest-only should be the FLOOR and WIN; "
+        f"got {r.outcome} (ev={_ev(r)})"
+    )
+
+
+@pytest.mark.parametrize("level", ("medium", "hard"))
+@pytest.mark.parametrize("seed", SEEDS)
+def test_harvest_only_loses_medium_and_hard(level, seed):
+    """Harvest-only LOSES medium/hard — the 2-harv / 3-harv structural
+    clause fails regardless of EV. This is the discriminator that the
+    recovery chain (build weap → build harv) is actually exercised."""
+    c, r = _run(level, _harvest_only_factory, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed{seed} harvest-only must LOSE on the 2/3-harv "
+        f"clause; got {r.outcome} (ev={_ev(r)}, "
+        f"harvs={r.signals.harvesters}, types={r.signals.own_building_types})"
+    )
+    # Harvester count never grew past the pre-placed one.
+    assert r.signals.harvesters <= 1, (
+        f"{level}: harvest-only should not produce more harvs; "
+        f"harvs={r.signals.harvesters}"
+    )
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", SEEDS)
+def test_build_army_loses(level, seed):
+    """Harvest → powr → tent → spam e1 (NEVER builds weap → no harv)
+    must LOSE every tier — easy on the EV bar (army drain), medium/hard
+    on the 2/3-harv clause AND the EV bar."""
+    c, r = _run(level, _build_army_factory, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed{seed} build-army must LOSE; got {r.outcome} "
+        f"(ev={_ev(r)}, types={r.signals.own_building_types})"
+    )
+    # Wrong-path commitment confirmed: tent landed but weap never did.
+    assert "tent" in r.signals.own_building_types, (
+        f"{level}: build-army should commit to tent; "
+        f"types={r.signals.own_building_types}"
+    )
+    assert "weap" not in r.signals.own_building_types, (
+        f"{level}: build-army should NEVER build weap; "
+        f"types={r.signals.own_building_types}"
+    )
+
+
+@pytest.mark.parametrize("level", ("medium", "hard"))
+@pytest.mark.parametrize("seed", SEEDS)
+def test_build_too_soon_loses_medium_and_hard(level, seed):
+    """Build-too-soon = spend cash on a 2nd refinery (the wrong scaling
+    asset) instead of weap+harv. The income channel does NOT scale →
+    the 2/3-harv clause fails on medium/hard → LOSS."""
+    c, r = _run(level, _build_too_soon_factory, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed{seed} build-too-soon must LOSE; got {r.outcome} "
+        f"(ev={_ev(r)}, harvs={r.signals.harvesters}, "
+        f"types={r.signals.own_building_types})"
+    )
+    # No weap (so no harv could be built) — the discriminator.
+    assert "weap" not in r.signals.own_building_types, (
+        f"{level}: build-too-soon must not happen to also build weap; "
+        f"types={r.signals.own_building_types}"
+    )
+    assert r.signals.harvesters <= 1, (
+        f"{level}: build-too-soon should not produce more harvs; "
+        f"harvs={r.signals.harvesters}"
+    )
+
+
+# ───────────────────────── hard spawn round-robin ─────────────────────────
+
+
+def test_hard_seed_round_robin_produces_distinct_starts():
+    """Seeds 1-4 must round-robin between the two declared
+    spawn_point groups (NORTH y=14 / SOUTH y=26) so a memorised opening
+    can't generalise."""
+    from pathlib import Path
+
+    from openra_bench.eval_core import RustEnvPool, _scenario_to_tmp_yaml
+    from openra_bench.rust_adapter import RustObsAdapter
+
+    c = compile_level(load_pack(PACK), "hard")
+    tmp = _scenario_to_tmp_yaml(c)
+    pool = RustEnvPool(size=1, scenario_path=tmp)
+    env = pool.acquire()
+    starts = set()
+    try:
+        for seed in (1, 2, 3, 4):
+            ad = RustObsAdapter()
+            ad.observe(env.reset(seed=seed))
+            u = ad.render_state().get("units_summary", []) or []
+            if u:
+                starts.add(
+                    tuple(sorted((x["cell_x"], x["cell_y"]) for x in u))
+                )
+    finally:
+        pool.release(env)
+        pool.shutdown()
+        Path(tmp).unlink(missing_ok=True)
+    assert len(starts) >= 2, (
+        f"hard seeds 1-4 produced identical starts {starts}; "
+        "spawn_point round-robin not taking effect"
+    )
+
+
+# ───────────────────────── determinism ────────────────────────────────────
+
+
+def test_outcomes_are_deterministic_per_seed():
+    """Same seed, same pack, same policy → identical outcome."""
+    c = compile_level(load_pack(PACK), "medium")
+    a = run_level(c, _intended_factory(), seed=2)
+    b = run_level(c, _intended_factory(), seed=2)
+    assert (a.outcome, a.turns, _ev(a)) == (b.outcome, b.turns, _ev(b)), (
+        f"determinism: {(a.outcome, a.turns, _ev(a))} vs "
+        f"{(b.outcome, b.turns, _ev(b))}"
+    )

tests/test_econ_target_cash_amount_by_deadline.py

@@ -0,0 +1,304 @@
+"""No-cheat + solvency proof for `econ-target-cash-amount-by-deadline`.
+
+The capability: reach an exact SPENDABLE CASH bar (`cash_gte: N`, not
+EV) by a hard tick deadline. The model must reason whether the
+pre-placed pipeline will clear the bar on time and reinvest into
+harvesting capacity if not — without draining cash into army units
+that don't grow income.
+
+For every level (and every hard seed 1-4) the no-cheat bar holds:
+
+  - STALL (only `observe`)              → LOSS  (idles at starting_cash)
+  - ARMY-DRAIN (harvest + spam `e1`)    → LOSS  (income ≈ unit cost)
+  - BASELINE (1 harv, no reinvest)      → LOSS  on medium+hard
+                                          (income too slow; deadline
+                                          bites)            — WIN on easy
+                                          (loose bar; bare commitment
+                                          suffices, by design)
+  - INTENDED (1 harv + build harv)      → WIN   on every level / seed
+
+Plus tick/turn alignment, fail-condition reachability, hard spawn
+contract.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+pytest.importorskip(
+    "openra_rl_training", reason="Rust env wheel not installed"
+)
+
+from openra_bench.eval_core import run_level
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+
+PACK_PATH = PACKS_DIR / "econ-target-cash-amount-by-deadline.yaml"
+
+# All near-patch mine cells across levels — the scripted harvest
+# policy tries each (the engine picks the reachable one per spawn).
+ALL_NEAR_MINES = [
+    (22, 18),
+    (22, 22),  # easy + medium pre-placed
+    (22, 10),
+    (22, 14),  # hard NORTH spawn
+    (22, 28),
+    (22, 32),  # hard SOUTH spawn
+]
+
+
+# ───────────────────────── scripted policies ──────────────────────────────
+
+
+def stall(rs, Command):
+    """Do-nothing — must lose: starting_cash (600) < bar everywhere."""
+    return [Command.observe()]
+
+
+def _harv_only(rs, Command):
+    """Pre-placed harv only, no reinvestment (the BASELINE)."""
+    ids = [
+        str(u["id"])
+        for u in rs.get("units_summary", []) or []
+        if u.get("type") == "harv"
+    ]
+    if not ids:
+        return [Command.observe()]
+    cmds = []
+    for i, uid in enumerate(ids):
+        mx, my = ALL_NEAR_MINES[i % len(ALL_NEAR_MINES)]
+        cmds.append(Command.harvest([uid], mx, my))
+    return cmds
+
+
+def _army_drain(rs, Command):
+    """Harvest with the pre-placed harv AND spam `e1` every turn that
+    cash >= 100. e1 is ~100cr and income from one harv after warmup is
+    ~100cr/turn, so cash treads water near starting_cash and never
+    clears the bar — the "spend on the wrong line item" decoy."""
+    cmds = []
+    ids = [
+        str(u["id"])
+        for u in rs.get("units_summary", []) or []
+        if u.get("type") == "harv"
+    ]
+    for i, uid in enumerate(ids):
+        mx, my = ALL_NEAR_MINES[i % len(ALL_NEAR_MINES)]
+        cmds.append(Command.harvest([uid], mx, my))
+    if rs.get("cash", 0) >= 100:
+        cmds.append(Command.build("e1"))
+    return cmds if cmds else [Command.observe()]
+
+
+def _intended_factory(extra_harv: int):
+    """Reinvestment factory: harvest with all harvs AND queue `extra_harv`
+    additional harvesters (each costs 1100, prereq fact+powr+weap).
+    Closure-local state so each test invocation starts fresh."""
+
+    def make():
+        queued = [0]
+
+        def p(rs, Command):
+            cmds = []
+            ids = [
+                str(u["id"])
+                for u in rs.get("units_summary", []) or []
+                if u.get("type") == "harv"
+            ]
+            for i, uid in enumerate(ids):
+                mx, my = ALL_NEAR_MINES[i % len(ALL_NEAR_MINES)]
+                cmds.append(Command.harvest([uid], mx, my))
+            if queued[0] < extra_harv and rs.get("cash", 0) >= 1100:
+                cmds.append(Command.build("harv"))
+                queued[0] += 1
+            return cmds if cmds else [Command.observe()]
+
+        return p
+
+    return make
+
+
+# ───────────────────────── solvency: intended WINS ────────────────────────
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_easy_intended_wins(seed):
+    """Easy bar (1500 by tick 1800) is reachable just by harvesting —
+    no reinvestment needed. Run the BASELINE; it must WIN."""
+    c = compile_level(load_pack(PACK_PATH), "easy")
+    r = run_level(c, _harv_only, seed=seed)
+    assert r.outcome == "win", (
+        f"easy baseline seed={seed} should WIN, got {r.outcome} "
+        f"(cash={r.signals.cash}, tick={r.signals.game_tick})"
+    )
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_medium_intended_wins(seed):
+    """Medium bar (5500 by tick 4500) needs reinvestment. Run the
+    INTENDED policy (build 1 extra harv); it must WIN."""
+    c = compile_level(load_pack(PACK_PATH), "medium")
+    r = run_level(c, _intended_factory(1)(), seed=seed)
+    assert r.outcome == "win", (
+        f"medium intended (+1 harv) seed={seed} should WIN, got "
+        f"{r.outcome} (cash={r.signals.cash}, tick={r.signals.game_tick})"
+    )
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_hard_intended_wins_every_seed(seed):
+    """Hard bar (6500 by tick 4000) on each of two spawn groups needs
+    reinvestment. Run the INTENDED policy (build 2 extra harvs for
+    safety margin against the tighter clock); it must WIN on every
+    seed."""
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    r = run_level(c, _intended_factory(2)(), seed=seed)
+    assert r.outcome == "win", (
+        f"hard intended (+2 harv) seed={seed} should WIN, got "
+        f"{r.outcome} (cash={r.signals.cash}, tick={r.signals.game_tick})"
+    )
+
+
+# ───────────────────────── no-cheat: lazy plays LOSE ──────────────────────
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_stall_loses_on_every_level(level):
+    """Stall idles at starting_cash (600) < bar (1500/5500/6500). The
+    `after_ticks` deadline must bite as a real LOSS (not a draw)."""
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, stall, seed=1)
+    assert r.outcome == "loss", (
+        f"{level} stall must be a real timeout LOSS, got {r.outcome} "
+        f"(cash={r.signals.cash})"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_army_drain_loses_on_every_level(level):
+    """Spamming `e1` alongside harvest exactly absorbs the harv
+    income (~100cr/turn each). Cash hovers near starting_cash and
+    never clears the bar — LOSS on every level."""
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _army_drain, seed=1)
+    assert r.outcome == "loss", (
+        f"{level} army-drain must LOSE (cash drained by units), got "
+        f"{r.outcome} (cash={r.signals.cash})"
+    )
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_medium_baseline_no_reinvest_loses(seed):
+    """The pre-placed pipeline alone reaches ~5600 cash but only at
+    tick ≥4500 — the deadline bites first. Baseline (no reinvest)
+    LOSES on every seed: this is what makes the medium tier a
+    capex-decision test."""
+    c = compile_level(load_pack(PACK_PATH), "medium")
+    r = run_level(c, _harv_only, seed=seed)
+    assert r.outcome == "loss", (
+        f"medium baseline seed={seed} must LOSE (deadline bites "
+        f"before bar reached), got {r.outcome} "
+        f"(cash={r.signals.cash}, tick={r.signals.game_tick})"
+    )
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_hard_baseline_no_reinvest_loses(seed):
+    """Hard target (6500 in 4000 ticks) is well above what 1 harv
+    can produce in time (~4100 cash by tick 4053). Baseline LOSES
+    on every seed."""
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    r = run_level(c, _harv_only, seed=seed)
+    assert r.outcome == "loss", (
+        f"hard baseline seed={seed} must LOSE, got {r.outcome} "
+        f"(cash={r.signals.cash}, tick={r.signals.game_tick})"
+    )
+
+
+# ───────────────────────── tick/turn alignment ────────────────────────────
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_deadline_reachable_inside_max_turns(level):
+    """`within_ticks` (and the matching `after_ticks` fail) must be
+    reachable inside max_turns — otherwise stall draws instead of
+    losing. Engine advances ~90 ticks per turn (tick ≈ 93+90·(t-1))."""
+    c = compile_level(load_pack(PACK_PATH), level)
+    max_tick = 93 + 90 * (c.max_turns - 1)
+    win_extra = c.win_condition.__pydantic_extra__ or {}
+    fail_extra = (
+        c.fail_condition.__pydantic_extra__ if c.fail_condition else {}
+    ) or {}
+
+    def _find(node, key):
+        if not isinstance(node, dict):
+            return None
+        for k, v in node.items():
+            if k == key:
+                return int(v)
+            if k in ("all_of", "any_of"):
+                for c2 in v:
+                    r = _find(c2, key)
+                    if r is not None:
+                        return r
+        return None
+
+    within = _find(win_extra, "within_ticks")
+    assert within is not None, f"{level} should have within_ticks"
+    assert within <= max_tick, (
+        f"{level} within_ticks={within} > max reachable tick {max_tick} "
+        f"(max_turns={c.max_turns}); deadline never bites"
+    )
+    after = _find(fail_extra, "after_ticks")
+    assert after is not None, f"{level} should have an after_ticks fail"
+    assert after <= max_tick, (
+        f"{level} after_ticks={after} > max reachable tick {max_tick}"
+    )
+
+
+# ───────────────────────── hard spawn contract ────────────────────────────
+
+
+def test_hard_has_two_spawn_point_groups():
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    sp = {
+        (a.spawn_point if a.spawn_point is not None else 0)
+        for a in c.scenario.actors
+        if a.owner == "agent"
+    }
+    assert len(sp) >= 2, (
+        f"hard must define ≥2 agent spawn_point groups, got {sorted(sp)}"
+    )
+
+
+def test_hard_seed_round_robin_produces_distinct_starts():
+    """Smoke that the engine actually round-robins the spawn groups by
+    seed (the whole point of declaring multiple spawn_point groups)."""
+    from pathlib import Path
+
+    from openra_bench.eval_core import RustEnvPool, _scenario_to_tmp_yaml
+    from openra_bench.rust_adapter import RustObsAdapter
+
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    tmp = _scenario_to_tmp_yaml(c)
+    pool = RustEnvPool(size=1, scenario_path=tmp)
+    env = pool.acquire()
+    starts = set()
+    try:
+        for seed in (1, 2, 3, 4):
+            ad = RustObsAdapter()
+            ad.observe(env.reset(seed=seed))
+            u = ad.render_state().get("units_summary", []) or []
+            if u:
+                starts.add(
+                    tuple(sorted((x["cell_x"], x["cell_y"]) for x in u))
+                )
+    finally:
+        pool.release(env)
+        pool.shutdown()
+        Path(tmp).unlink(missing_ok=True)
+    assert len(starts) >= 2, (
+        f"hard seeds 1-4 produced identical starts {starts}; "
+        "spawn_point round-robin not taking effect"
+    )

tests/test_hard_tier.py

@@ -321,6 +321,41 @@ UPGRADED = [
     # 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-reserve / treasury management pack (SC2 cash
+    # overflow / financial runway / operational reserve anchor). Hard
+    # tier defines two agent spawn_point groups (NORTH base y=14 /
+    # SOUTH base y=28) round-robined by seed; the two near patches
+    # sit on the spawn-matched row so throughput is symmetric per
+    # spawn, but a memorised opening cannot generalise across seeds.
+    "econ-cash-reserve-management",
+    # 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",
+    "coord-diversionary-attack",
+    "def-in-depth",
+    "def-surprise-flank-react",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation

tests/test_lh_100_turn_marathon_survival.py

@@ -0,0 +1,352 @@
+"""lh-100-turn-marathon-survival pack — full no-cheat validation on Rust.
+
+Wave-5 Group G long-horizon endurance pack. The win is gated on FOUR
+things still being true at the after_ticks survival gate:
+  1. has_building: fact
+  2. own_units_gte: 3
+  3. building_count_gte pbox 2
+  4. after_ticks N (survived to the gate) AND within_ticks N+x
+
+Sustained pressure comes from STAGGERED hunt squads placed at
+increasing x along the east-west axis, so squads arrive in successive
+time windows rather than all at once. The fail clause uses the
+``any_of: [after_ticks(GATE), not has_building:fact, not own_units_gte:1]``
+idiom — eval_core evaluates win FIRST, so the broad after_ticks
+fail only bites if the win all-of is unsatisfied at the gate (CLAUDE.md
+rule 3: non-win must be a real LOSS, not a draw).
+
+Bar (per CLAUDE.md): the intended SUSTAINED-OPS policy (kick harv +
+build ≥2 pbox + continuously train e1) must WIN on every (level,
+seed); stall / pure-defense-no-reinforce / pure-build-no-repair must
+LOSE on every (level, seed). No draws.
+
+NOTE: episodes are LONG (90/100/120 turns ≈ ~8/9/11 thousand ticks).
+The engine-bound tests parametrise over 4 seeds × 3 levels × 4
+policies = 48 runs; expect this file to take several minutes.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+from openra_bench.eval_core import run_level
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+
+PACK = PACKS_DIR / "lh-100-turn-marathon-survival.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+
+# ── Policies ──────────────────────────────────────────────────────
+
+
+def _stall_policy():
+    """Idles every turn — must LOSE (hunt squads raze fact)."""
+    def pol(obs, Cmd):
+        return [Cmd.observe()]
+    return pol
+
+
+def _pure_defense_no_reinforce_policy():
+    """Build pbox to 4 standing but NEVER train fresh infantry. The
+    starting garrison bleeds under sustained pressure; either fact
+    falls (no infantry to back the pbox line) or own_units drops
+    below 3 (1) at the gate ⇒ LOSS."""
+    state = {"placed_pbox": 0, "harv_kicked": False}
+
+    def pol(obs, Cmd):
+        ob = obs.get("own_buildings", []) or []
+        pbox_have = sum(1 for b in ob if b["type"] == "pbox")
+        prod = obs.get("production", []) or []
+        cash = int(obs.get("cash", 0) or 0)
+        units = obs.get("units_summary", []) or []
+        base = next((b for b in ob if b["type"] == "fact"), None)
+        if not base:
+            return [Cmd.observe()]
+        bx, by = base["cell_x"], base["cell_y"]
+        cmds = []
+        if not state["harv_kicked"]:
+            harv = next((u for u in units if u.get("type") == "harv"), None)
+            if harv:
+                cmds.append(Cmd.harvest([harv["id"]], 2, by))
+                state["harv_kicked"] = True
+        if pbox_have < 4 and "pbox" not in prod and cash >= 600:
+            cmds.append(Cmd.build("pbox"))
+        if pbox_have < 4:
+            i = state["placed_pbox"]
+            cmds.append(Cmd.place_building(
+                "pbox", bx + 4 + (i % 4), by + (-3 + (i // 4))
+            ))
+            state["placed_pbox"] += 1
+        if not cmds:
+            cmds.append(Cmd.observe())
+        return cmds
+    return pol
+
+
+def _pure_build_no_repair_policy():
+    """Build just 2 pbox up front, then idle — no infantry production
+    and no further building. The lone pbox pair gets stripped by
+    sustained hunt fire (rocket squads contribute on medium/hard),
+    fact eventually falls or building_count_gte pbox 2 drops below 2
+    at the gate ⇒ LOSS."""
+    state = {"placed_pbox": 0, "harv_kicked": False}
+
+    def pol(obs, Cmd):
+        ob = obs.get("own_buildings", []) or []
+        prod = obs.get("production", []) or []
+        cash = int(obs.get("cash", 0) or 0)
+        units = obs.get("units_summary", []) or []
+        base = next((b for b in ob if b["type"] == "fact"), None)
+        if not base:
+            return [Cmd.observe()]
+        bx, by = base["cell_x"], base["cell_y"]
+        cmds = []
+        if not state["harv_kicked"]:
+            harv = next((u for u in units if u.get("type") == "harv"), None)
+            if harv:
+                cmds.append(Cmd.harvest([harv["id"]], 2, by))
+                state["harv_kicked"] = True
+        # Build only 2 pbox total — no further construction, no
+        # infantry production, no repair.
+        if state["placed_pbox"] < 2:
+            if "pbox" not in prod and cash >= 600:
+                cmds.append(Cmd.build("pbox"))
+            i = state["placed_pbox"]
+            cmds.append(Cmd.place_building(
+                "pbox", bx + 4 + (i % 4), by + (-3 + (i // 4))
+            ))
+            state["placed_pbox"] += 1
+        if not cmds:
+            cmds.append(Cmd.observe())
+        return cmds
+    return pol
+
+
+def _intended_sustained_ops_policy():
+    """The intended SUSTAINED-OPS capability play:
+       turn 1: kick the pre-placed harvester onto the west mine
+       continuous: keep ≥4 pbox standing in front of the base
+       continuous: train fresh e1 so the e1 garrison stays ≥10
+       (cap so we don't drain the queue waiting on cash).
+       The continuous infantry production replaces losses from
+       sustained hunt attrition; the pbox screen blunts each wave's
+       leading edge so the infantry isn't overrun.
+    """
+    state = {"placed_pbox": 0, "harv_kicked": False}
+
+    def pol(obs, Cmd):
+        ob = obs.get("own_buildings", []) or []
+        pbox_have = sum(1 for b in ob if b["type"] == "pbox")
+        prod = obs.get("production", []) or []
+        cash = int(obs.get("cash", 0) or 0)
+        units = obs.get("units_summary", []) or []
+        e1_count = sum(1 for u in units if u.get("type") == "e1")
+        # Use the LIVE fact position so this policy generalises across
+        # the seed-driven NORTH/SOUTH hard-spawn round-robin.
+        base = next((b for b in ob if b["type"] == "fact"), None)
+        if not base:
+            return [Cmd.observe()]
+        bx, by = base["cell_x"], base["cell_y"]
+        cmds = []
+
+        # Kick the harvester at the west mine (mines are at x=2 on
+        # every level — y matches the base latitude so the loop is
+        # short and doesn't cross the lane).
+        if not state["harv_kicked"]:
+            harv = next((u for u in units if u.get("type") == "harv"), None)
+            if harv:
+                cmds.append(Cmd.harvest([harv["id"]], 2, by))
+                state["harv_kicked"] = True
+
+        # Maintain ≥4 standing pbox in front of the base. Queue one
+        # at a time (cash budget is small early); spread placements.
+        if pbox_have < 4 and "pbox" not in prod and cash >= 600:
+            cmds.append(Cmd.build("pbox"))
+        if pbox_have < 4:
+            i = state["placed_pbox"]
+            cmds.append(Cmd.place_building(
+                "pbox", bx + 4 + (i % 4), by + (-3 + (i // 4))
+            ))
+            state["placed_pbox"] += 1
+
+        # Sustained reinforcement — train fresh riflemen continuously.
+        # The own_units_gte:3 win gate requires the garrison stays
+        # alive; replacing losses is the load-bearing capability.
+        if e1_count < 10 and "e1" not in prod and cash >= 100:
+            cmds.append(Cmd.build("e1"))
+
+        if not cmds:
+            cmds.append(Cmd.observe())
+        return cmds
+    return pol
+
+
+# ── Pack-shape tests (cheap; do not run the engine) ──────────────
+
+
+def test_pack_compiles_with_three_levels():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "lh-100-turn-marathon-survival"
+    assert pack.meta.capability == "reasoning"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+
+
+def test_meta_benchmark_anchor_set():
+    pack = load_pack(PACK)
+    anchors = pack.meta.benchmark_anchor or []
+    assert any("lmgame" in a.lower() for a in anchors), anchors
+    assert any("sc2le" in a.lower() or "endurance" in a.lower() for a in anchors), anchors
+    assert any("sre" in a.lower() or "endurance" in a.lower() for a in anchors), anchors
+
+
+def test_hard_tier_has_seed_driven_spawn_groups():
+    c = compile_level(load_pack(PACK), "hard")
+    sp = {a.spawn_point for a in c.scenario.actors if a.owner == "agent"}
+    assert len(sp) >= 2, f"hard needs ≥2 spawn groups, got {sp}"
+
+
+def test_every_level_has_fail_condition():
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.fail_condition is not None, f"{lvl} missing fail_condition"
+
+
+def test_tick_budget_aligned_with_max_turns():
+    """within_ticks must be reachable inside max_turns, AND the
+    after_ticks win gate must sit comfortably below reachable so the
+    episode can actually reach it."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        level_def = pack.levels[lvl]
+        max_turns = level_def.max_turns
+        reachable = 93 + 90 * (max_turns - 1)
+        win = compile_level(pack, lvl).win_condition.model_dump(exclude_none=True)
+
+        def _collect(node, key, out):
+            if isinstance(node, dict):
+                if key in node:
+                    out.append(node[key])
+                for v in node.values():
+                    _collect(v, key, out)
+            elif isinstance(node, list):
+                for v in node:
+                    _collect(v, key, out)
+        wts: list = []
+        ats: list = []
+        _collect(win, "within_ticks", wts)
+        _collect(win, "after_ticks", ats)
+        assert wts, f"{lvl} has no within_ticks leaf"
+        assert ats, f"{lvl} has no after_ticks leaf (no survival gate)"
+        for wt in wts:
+            assert wt <= reachable, (
+                f"{lvl} within_ticks={wt} > reachable={reachable} "
+                f"(max_turns={max_turns}) — deadline never bites ⇒ draw"
+            )
+        for at in ats:
+            assert at <= reachable, (
+                f"{lvl} after_ticks={at} > reachable={reachable} — "
+                f"survival gate never opens ⇒ win unreachable"
+            )
+
+
+def test_win_predicate_includes_all_four_survival_clauses():
+    """The win must require has_building:fact, own_units_gte:3,
+    building_count_gte pbox≥2, and after_ticks — all four together.
+    A scenario that's missing any clause would be gameable."""
+    for lvl in LEVELS:
+        c = compile_level(load_pack(PACK), lvl)
+        win = c.win_condition.model_dump(exclude_none=True)
+        all_of = win.get("all_of") or []
+        keys: set = set()
+        for clause in all_of:
+            keys |= set(clause.keys())
+        assert "has_building" in keys, f"{lvl} win missing has_building: {keys}"
+        assert "own_units_gte" in keys, f"{lvl} win missing own_units_gte: {keys}"
+        assert "building_count_gte" in keys, (
+            f"{lvl} win missing building_count_gte: {keys}"
+        )
+        assert "after_ticks" in keys, f"{lvl} win missing after_ticks: {keys}"
+        assert "within_ticks" in keys, f"{lvl} win missing within_ticks: {keys}"
+
+
+# ── Engine-bound tests (parameterised over seeds 1..4) ────────────
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_intended_sustained_ops_wins(level, seed):
+    """The intended sustained-ops policy (kick harv + maintain pbox
+    line + continuous infantry production) must WIN on every (level,
+    seed). Load-bearing solvency test."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _intended_sustained_ops_policy(), seed=seed)
+    pbox_n = sum(1 for t, _, _ in res.signals.own_buildings if t == "pbox")
+    fact = any(t == "fact" for t, _, _ in res.signals.own_buildings)
+    assert res.outcome == "win", (
+        f"intended sustained-ops must WIN on {level} s={seed}; "
+        f"got {res.outcome} turns={res.turns} tick={res.signals.game_tick} "
+        f"units_lost={res.signals.units_lost} pbox={pbox_n} fact={fact}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_stall_loses(level, seed):
+    """Do-nothing must LOSE on every (level, seed). Hunt squads raze
+    fact (or the survival gate opens with the win all-of unmet)."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _stall_policy(), seed=seed)
+    assert res.outcome == "loss", (
+        f"stall must LOSE on {level} s={seed}; got {res.outcome} "
+        f"tick={res.signals.game_tick}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_pure_defense_no_reinforce_loses(level, seed):
+    """Build pbox but NEVER train new infantry — the garrison bleeds
+    under sustained pressure and either fact falls or own_units drops
+    below 3 (1) at the survival gate ⇒ LOSS."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _pure_defense_no_reinforce_policy(), seed=seed)
+    pbox_n = sum(1 for t, _, _ in res.signals.own_buildings if t == "pbox")
+    fact = any(t == "fact" for t, _, _ in res.signals.own_buildings)
+    assert res.outcome == "loss", (
+        f"pure-defense-no-reinforce must LOSE on {level} s={seed}; got "
+        f"{res.outcome} tick={res.signals.game_tick} "
+        f"lost={res.signals.units_lost} pbox={pbox_n} fact={fact}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_pure_build_no_repair_loses(level, seed):
+    """Build only 2 pbox up front; no infantry production / no
+    repair / no further building. The lone pbox pair gets stripped
+    and fact eventually falls under sustained attrition ⇒ LOSS."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _pure_build_no_repair_policy(), seed=seed)
+    pbox_n = sum(1 for t, _, _ in res.signals.own_buildings if t == "pbox")
+    fact = any(t == "fact" for t, _, _ in res.signals.own_buildings)
+    assert res.outcome == "loss", (
+        f"pure-build-no-repair must LOSE on {level} s={seed}; got "
+        f"{res.outcome} tick={res.signals.game_tick} "
+        f"lost={res.signals.units_lost} pbox={pbox_n} fact={fact}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+def test_hard_seeds_produce_distinct_starts(seed):
+    """Hard's two spawn_point groups must round-robin per seed."""
+    c = compile_level(load_pack(PACK), "hard")
+    # Stall — deterministic, fast; we only need to check the seed flows.
+    res = run_level(c, _stall_policy(), seed=seed)
+    assert res.outcome == "loss"  # stall must lose
+    sp = {a.spawn_point for a in c.scenario.actors if a.owner == "agent"}
+    assert len(sp) >= 2

tests/test_lh_build_army_coordinate_multifront_attack.py

@@ -0,0 +1,319 @@
+"""lh-build-army-coordinate-multifront-attack — full no-cheat
+validation on Rust.
+
+Group G long-horizon REASONING pack. Two-phase operational plan:
+ASSEMBLE a real army (≥N medium tanks) THEN commit it to a
+SIMULTANEOUS TWO-FRONT assault on TWO separated enemy `fact` markers
+(NE at (130,15) and SE at (130,45), 120 cells apart). The Wave-2
+`then:` happened-before composite enforces the army-clause-before-
+destruction ordering; the two destruction clauses (NE + SE) enforce
+the SPLIT (one mass cannot raze both corners in sequence within the
+clock budget).
+
+Bar (per CLAUDE.md): the intended build-then-split policy WINS on
+every (level, seed); stall / one-front-only / send-2-units-each-front
+all LOSE on every seed.
+
+Scenario shape:
+  - 160×60 arena, allies vs soviet (static — no bot).
+  - easy: 4-tank army threshold, no defenders pressure.
+  - medium: 6-tank army threshold, light pickets.
+  - hard: 8-tank army threshold + 2 spawn_point groups (NORTH/SOUTH
+    agent base latitude flips per seed).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+
+from openra_bench.eval_core import run_level
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+
+PACK = PACKS_DIR / "lh-build-army-coordinate-multifront-attack.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+# Per-level army size (the n in unit_type_count_gte: {type:2tnk, n:N}).
+_ARMY_N = {"easy": 4, "medium": 6, "hard": 8}
+
+# The two fixed enemy fact corners (NE + SE).
+NE = (130, 15)
+SE = (130, 45)
+
+
+# ── Policies ──────────────────────────────────────────────────────
+
+
+def _stall_policy():
+    """Do nothing — must LOSE on the clock on every level/seed."""
+    def pol(obs, Cmd):
+        return [Cmd.observe()]
+    return pol
+
+
+def _attack_one_front_only_policy():
+    """Build the army to the threshold, then attack-move EVERY tank
+    onto the NE fact. The NE destruction clause latches, the army
+    clause latches, but the SE destruction clause NEVER latches (the
+    SE fact stands untouched). Must LOSE on every (level, seed)."""
+    def pol(obs, Cmd):
+        units = obs.get("units_summary", []) or []
+        own_b = {b["type"] for b in (obs.get("own_buildings", []) or [])}
+        prod = obs.get("production", []) or []
+        tnk = [u for u in units if u.get("type") == "2tnk"]
+        cmds = []
+        # Keep building tanks (cap at 12 to avoid runaway queue spam).
+        if "weap" in own_b and len(tnk) < 12 and "2tnk" not in prod:
+            cmds.append(Cmd.build("2tnk"))
+        if tnk:
+            tnk_ids = [u["id"] for u in tnk]
+            # ALL tanks at the NE fact — SE is ignored on purpose.
+            cmds.append(Cmd.attack_move(tnk_ids, NE[0], NE[1]))
+        if not cmds:
+            cmds.append(Cmd.observe())
+        return cmds
+    return pol
+
+
+def _send_too_few_each_front_policy():
+    """Skip the build entirely; just split the two starter 2tnks —
+    one to NE, one to SE — and hope (in vain) that 1 tank per prong
+    can raze a defended fact. Cannot satisfy the army clause (N≥4
+    minimum), and 1 tank cannot raze a fact with defenders inside
+    the clock anyway. Must LOSE on every (level, seed)."""
+    sent = {"ne": False, "se": False}
+
+    def pol(obs, Cmd):
+        units = obs.get("units_summary", []) or []
+        tnk = [u for u in units if u.get("type") == "2tnk"]
+        cmds = []
+        # Sort tanks by id so the split is deterministic.
+        tnk.sort(key=lambda u: u["id"])
+        if tnk:
+            ne_ids = [tnk[0]["id"]]
+            se_ids = [tnk[1]["id"]] if len(tnk) > 1 else []
+            if ne_ids:
+                cmds.append(Cmd.attack_move(ne_ids, NE[0], NE[1]))
+                sent["ne"] = True
+            if se_ids:
+                cmds.append(Cmd.attack_move(se_ids, SE[0], SE[1]))
+                sent["se"] = True
+        if not cmds:
+            cmds.append(Cmd.observe())
+        return cmds
+    return pol
+
+
+def _intended_mass_and_split_policy(army_n: int):
+    """The intended capability play:
+      PHASE 1: build the army to ≥army_n medium tanks (concurrent
+               with idle observation so production can drip).
+      PHASE 2: SPLIT the army half-to-NE, half-to-SE attack-move.
+    Uses a sticky latch on the army milestone so a tank dying after
+    we've reached threshold doesn't bounce the policy back to phase 1.
+
+    Tanks come out of the pre-placed weap (war factory). Starter 2
+    tanks count toward the threshold.
+    """
+    milestone = {"army": False}
+
+    def pol(obs, Cmd):
+        units = obs.get("units_summary", []) or []
+        own_b = {b["type"] for b in (obs.get("own_buildings", []) or [])}
+        prod = obs.get("production", []) or []
+        tnk = [u for u in units if u.get("type") == "2tnk"]
+        if len(tnk) >= army_n:
+            milestone["army"] = True
+        cmds = []
+        # PHASE 1 (always running until army milestone): keep tank
+        # production in flight whenever weap exists and the queue
+        # isn't already producing one.
+        if "weap" in own_b and "2tnk" not in prod:
+            cmds.append(Cmd.build("2tnk"))
+        # PHASE 2: once army milestone latched, split-attack.
+        # The split is deterministic by tank id (lower half → NE,
+        # upper half → SE) so the test is reproducible.
+        if milestone["army"] and tnk:
+            tnk_sorted = sorted(tnk, key=lambda u: u["id"])
+            half = max(1, len(tnk_sorted) // 2)
+            ne_ids = [u["id"] for u in tnk_sorted[:half]]
+            se_ids = [u["id"] for u in tnk_sorted[half:]]
+            if ne_ids:
+                cmds.append(Cmd.attack_move(ne_ids, NE[0], NE[1]))
+            if se_ids:
+                cmds.append(Cmd.attack_move(se_ids, SE[0], SE[1]))
+        if not cmds:
+            cmds.append(Cmd.observe())
+        return cmds
+    return pol
+
+
+# ── Pack-shape tests (cheap; do not run the engine) ──────────────
+
+
+def test_pack_compiles_with_three_levels():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "lh-build-army-coordinate-multifront-attack"
+    assert pack.meta.capability == "reasoning"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+
+
+def test_meta_benchmark_anchor_set():
+    """Required by the spec: SC2 macro-then-multi-prong / military
+    operational planning / PERT / industrial product launch."""
+    pack = load_pack(PACK)
+    anchors = pack.meta.benchmark_anchor or []
+    j = " | ".join(anchors).lower()
+    assert "sc2" in j, anchors
+    assert "operational" in j or "military" in j, anchors
+    assert "pert" in j, anchors
+    assert "industrial" in j or "rollout" in j, anchors
+
+
+def test_hard_tier_has_seed_driven_spawn_groups():
+    """Hard must define ≥2 agent spawn_point groups so seed varies
+    the start base latitude (tests/test_hard_tier.py::UPGRADED
+    contract)."""
+    c = compile_level(load_pack(PACK), "hard")
+    sp = {a.spawn_point for a in c.scenario.actors if a.owner == "agent"}
+    assert len(sp) >= 2, f"hard needs ≥2 spawn groups, got {sp}"
+
+
+def test_every_level_has_fail_condition():
+    """No silent draws — every level must be able to emit a LOSS."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.fail_condition is not None, f"{lvl} missing fail_condition"
+
+
+def test_then_composite_used_in_win():
+    """The win is `all_of[ then{army, NE-raze, SE-raze}, within_ticks ]`.
+    Confirms the load-bearing teeth (mass-then-split) is wired."""
+    for lvl in LEVELS:
+        c = compile_level(load_pack(PACK), lvl)
+        win = c.win_condition.model_dump(exclude_none=True)
+        inner = win.get("all_of") or []
+        then_node = None
+        for cl in inner:
+            if "then" in cl:
+                then_node = cl["then"]
+                break
+        assert then_node is not None, f"{lvl} win missing then-chain: {win}"
+        clauses = (then_node or {}).get("clauses") or []
+        # army → NE-raze → SE-raze ⇒ exactly 3 clauses.
+        assert len(clauses) == 3, (
+            f"{lvl} then-chain must have 3 clauses (army, NE, SE); "
+            f"got {clauses}"
+        )
+
+
+def test_tick_budget_aligned_with_max_turns():
+    """within_ticks must be reachable inside max_turns. Engine
+    advances ~90 ticks/turn → reachable max = 93 + 90·(N-1)."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        level_def = pack.levels[lvl]
+        max_turns = level_def.max_turns
+        reachable = 93 + 90 * (max_turns - 1)
+        win = compile_level(pack, lvl).win_condition.model_dump(exclude_none=True)
+
+        def _collect(node, key, out):
+            if isinstance(node, dict):
+                if key in node:
+                    out.append(node[key])
+                for v in node.values():
+                    _collect(v, key, out)
+            elif isinstance(node, list):
+                for v in node:
+                    _collect(v, key, out)
+        wts = []
+        _collect(win, "within_ticks", wts)
+        assert wts, f"{lvl} has no within_ticks leaf (no clock teeth)"
+        for wt in wts:
+            assert wt <= reachable, (
+                f"{lvl} within_ticks={wt} > reachable={reachable} "
+                f"(max_turns={max_turns}) — deadline never bites ⇒ draw"
+            )
+
+
+# ── Engine-bound tests (parameterised over seeds 1..4) ────────────
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_intended_mass_and_split_wins(level, seed):
+    """The intended capability play — build the army to ≥N then SPLIT
+    half-to-NE half-to-SE attack-move — must WIN on every (level,
+    seed). Load-bearing: the pack is solvable inside the budget by
+    the advertised capability."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _intended_mass_and_split_policy(_ARMY_N[level]), seed=seed)
+    tp = getattr(res.signals, "then_progress", {}) or {}
+    assert res.outcome == "win", (
+        f"intended mass-and-split must WIN on {level} s={seed}; "
+        f"got {res.outcome} (then_progress={tp}, "
+        f"kills={res.signals.units_killed}, "
+        f"own_buildings={res.signals.own_building_types})"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_stall_loses(level, seed):
+    """A do-nothing policy must LOSE on every (level, seed). The
+    fail_condition's after_ticks bites at the turn budget; never a
+    draw."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _stall_policy(), seed=seed)
+    assert res.outcome == "loss", (
+        f"stall must LOSE on {level} s={seed}; got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_attack_one_front_only_loses(level, seed):
+    """A "build army, send EVERY tank to NE only, ignore SE" policy
+    must LOSE on every (level, seed). The SE destruction clause
+    never latches, so the then-chain never completes."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _attack_one_front_only_policy(), seed=seed)
+    tp = getattr(res.signals, "then_progress", {}) or {}
+    assert res.outcome == "loss", (
+        f"one-front-only must LOSE on {level} s={seed}; "
+        f"got {res.outcome} then_progress={tp}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_send_too_few_each_front_loses(level, seed):
+    """A "skip the build, send 1 starter tank to NE + 1 to SE" policy
+    must LOSE on every (level, seed). The army clause (army_n ≥ 4)
+    can never latch with only 2 starter tanks, AND 1 tank per prong
+    bounces off the defenders without razing the fact."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _send_too_few_each_front_policy(), seed=seed)
+    tp = getattr(res.signals, "then_progress", {}) or {}
+    assert res.outcome == "loss", (
+        f"send-too-few must LOSE on {level} s={seed}; "
+        f"got {res.outcome} then_progress={tp}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+def test_hard_seeds_produce_distinct_starts(seed):
+    """Hard's two spawn_point groups must round-robin — different
+    seeds must place the agent base at a different latitude (y=18
+    NORTH vs y=42 SOUTH). Smoke-tests the spawn-variation contract
+    that tests/test_hard_tier.py also enforces."""
+    c = compile_level(load_pack(PACK), "hard")
+    res = run_level(c, _stall_policy(), seed=seed)
+    assert res.outcome == "loss"  # stall must lose on hard
+    sp = {a.spawn_point for a in c.scenario.actors if a.owner == "agent"}
+    assert len(sp) >= 2

tests/test_lh_defense_tech_second_base.py

@@ -0,0 +1,552 @@
+"""lh-defense-tech-second-base — full no-cheat validation on Rust.
+
+Wave-5 Group G long-horizon "secure-expand-with-tech" pack. Uses the
+Wave-2 `then:` happened-before composite to enforce strict 3- (or 4-)
+phase ordering:
+  PHASE 1: building_count_gte:{type:pbox, n:2|3|3}    # defend
+  PHASE 2: has_building: weap                          # tech
+  PHASE 3: building_in_region:{x:130,y:30,r:8,
+                              type:fact,count:1}      # 2nd base
+  PHASE 4 (hard only):
+           building_count_gte:{type:proc, n:2}         # second refinery
+
+Bar (per CLAUDE.md): the intended secure-expand-with-tech policy must
+WIN on every (level, seed); stall / pure-expand-skip-defence /
+pure-defence-no-expand must LOSE on every (level, seed). No draws.
+
+Scenario shape:
+  - 160x60 generator-spec arena, allied agent, soviet `patrol`-bot.
+  - Pre-placed base: fact + tent + 2× powr + proc + harv + mine
+    + 3 rifleman defenders (so income flows from turn 1 and own_units_
+    gte:1 is satisfied immediately).
+  - Spare MCV staged ~30 cells east of base #1 — agent drives it
+    further east and deploys at (131,31) → fact lands at (130,30),
+    the centre of the east target region.
+  - Inert enemy `fact` marker at (154,4) prevents auto-DRAW.
+  - hard: ≥2 spawn_point groups (NORTH y=22 / SOUTH y=38) per the
+    hard-tier contract.
+"""
+
+from __future__ import annotations
+
+import types
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import compile_level
+from openra_bench.scenarios.win_conditions import WinContext, evaluate
+
+PACKS = Path(__file__).parent.parent / "openra_bench" / "scenarios" / "packs"
+PACK_PATH = PACKS / "lh-defense-tech-second-base.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+
+# ── Pack-shape tests (cheap; do not run the engine) ─────────────────
+
+
+def test_pack_compiles_with_three_levels():
+    pack = load_pack(PACK_PATH)
+    assert pack.meta.id == "lh-defense-tech-second-base"
+    assert pack.meta.capability == "reasoning"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+
+
+def test_meta_benchmark_anchor_set():
+    pack = load_pack(PACK_PATH)
+    anchors = pack.meta.benchmark_anchor or []
+    joined = " ".join(anchors).lower()
+    assert "sc2" in joined and "secure-expand" in joined, anchors
+    assert "planbench" in joined, anchors
+    assert "roadmap" in joined or "harden" in joined, anchors
+    assert "industrial" in joined or "second plant" in joined, anchors
+
+
+def test_hard_tier_has_seed_driven_spawn_groups():
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    sp = {a.spawn_point for a in c.scenario.actors if a.owner == "agent"}
+    assert len(sp) >= 2, f"hard needs ≥2 spawn groups, got {sp}"
+
+
+def test_every_level_has_fail_condition():
+    pack = load_pack(PACK_PATH)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.fail_condition is not None, f"{lvl} missing fail_condition"
+
+
+def test_then_composite_used_in_win():
+    """Confirms the secure-expand-with-tech chain wired through to the
+    compiled win condition (the whole point of the pack)."""
+    expected_first = {"easy": 2, "medium": 3, "hard": 3}
+    for lvl in LEVELS:
+        c = compile_level(load_pack(PACK_PATH), lvl)
+        win = c.win_condition.model_dump(exclude_none=True)
+        ao = win.get("all_of") or []
+        assert any("then" in clause for clause in ao), (
+            f"{lvl} win has no then-composite: {win}"
+        )
+        then_clause = next(cl["then"] for cl in ao if "then" in cl)
+        clauses = then_clause["clauses"]
+        # PHASE 1: pbox count
+        assert "building_count_gte" in clauses[0]
+        assert clauses[0]["building_count_gte"]["type"] == "pbox"
+        assert clauses[0]["building_count_gte"]["n"] == expected_first[lvl]
+        # PHASE 2: weap
+        assert "has_building" in clauses[1] and clauses[1]["has_building"] == "weap"
+        # PHASE 3: building_in_region around (130,30) for fact
+        assert "building_in_region" in clauses[2]
+        br = clauses[2]["building_in_region"]
+        assert br["x"] == 130 and br["y"] == 30 and br["type"] == "fact"
+        # Hard has a 4th phase: ≥2 proc
+        if lvl == "hard":
+            assert len(clauses) == 4
+            assert "building_count_gte" in clauses[3]
+            assert clauses[3]["building_count_gte"]["type"] == "proc"
+            assert clauses[3]["building_count_gte"]["n"] == 2
+        else:
+            assert len(clauses) == 3
+
+
+def test_tick_budget_aligned_with_max_turns():
+    """within_ticks must be reachable inside max_turns (~90 ticks/turn)."""
+    pack = load_pack(PACK_PATH)
+    for lvl in LEVELS:
+        level_def = pack.levels[lvl]
+        max_turns = level_def.max_turns
+        reachable = 93 + 90 * (max_turns - 1)
+        win = compile_level(pack, lvl).win_condition.model_dump(exclude_none=True)
+
+        def _collect(node, key, out):
+            if isinstance(node, dict):
+                if key in node:
+                    out.append(node[key])
+                for v in node.values():
+                    _collect(v, key, out)
+            elif isinstance(node, list):
+                for v in node:
+                    _collect(v, key, out)
+        wts: list = []
+        _collect(win, "within_ticks", wts)
+        assert wts, f"{lvl} has no within_ticks leaf (no clock teeth)"
+        for wt in wts:
+            assert wt <= reachable, (
+                f"{lvl} within_ticks={wt} > reachable={reachable} "
+                f"(max_turns={max_turns}) — deadline never bites ⇒ draw"
+            )
+
+
+def _ctx(own_buildings=(), tick=1000):
+    """Synthesize a WinContext from a building list."""
+    sig = types.SimpleNamespace(
+        game_tick=tick,
+        units_killed=0,
+        units_lost=0,
+        own_buildings=list(own_buildings),
+        own_building_types={t for (t, _, _) in own_buildings},
+        enemies_seen_ids=set(),
+        enemy_buildings_seen_ids=set(),
+        cash=0,
+        then_progress={},
+    )
+    return WinContext(signals=sig, render_state={"units_summary": []})
+
+
+def test_predicates_easy():
+    c = compile_level(load_pack(PACK_PATH), "easy")
+    # WIN: full chain — pbox×2 → weap → 2nd fact in east region
+    own = [
+        ("fact", 10, 30),
+        ("pbox", 12, 30), ("pbox", 12, 31),
+        ("weap", 14, 30),
+        ("fact", 130, 30),
+    ]
+    assert evaluate(c.win_condition, _ctx(own, tick=3000))
+    # FAIL: skip pbox — chain never advances past phase 1.
+    own_no_def = [("fact", 10, 30), ("weap", 14, 30), ("fact", 130, 30)]
+    assert not evaluate(c.win_condition, _ctx(own_no_def, tick=3000))
+    # FAIL: skip expand — chain stuck at phase 3.
+    own_no_exp = [
+        ("fact", 10, 30),
+        ("pbox", 12, 30), ("pbox", 12, 31),
+        ("weap", 14, 30),
+    ]
+    assert not evaluate(c.win_condition, _ctx(own_no_exp, tick=3000))
+    # FAIL: no fact at all (base #1 lost).
+    assert evaluate(c.fail_condition, _ctx([], tick=3000))
+    # FAIL: past deadline.
+    assert evaluate(c.fail_condition, _ctx(own, tick=8100))
+
+
+def test_predicates_medium():
+    c = compile_level(load_pack(PACK_PATH), "medium")
+    # WIN: pbox×3 → weap → 2nd fact in east region
+    own = [
+        ("fact", 10, 30),
+        ("pbox", 12, 30), ("pbox", 12, 31), ("pbox", 12, 32),
+        ("weap", 14, 30),
+        ("fact", 130, 30),
+    ]
+    assert evaluate(c.win_condition, _ctx(own, tick=3000))
+    # FAIL: only 2 pbox — bar is 3.
+    own_short = [
+        ("fact", 10, 30),
+        ("pbox", 12, 30), ("pbox", 12, 31),
+        ("weap", 14, 30),
+        ("fact", 130, 30),
+    ]
+    assert not evaluate(c.win_condition, _ctx(own_short, tick=3000))
+    # FAIL: 2nd fact outside east region.
+    own_off = [
+        ("fact", 10, 30),
+        ("pbox", 12, 30), ("pbox", 12, 31), ("pbox", 12, 32),
+        ("weap", 14, 30),
+        ("fact", 100, 30),  # > radius 8 from (130,30)
+    ]
+    assert not evaluate(c.win_condition, _ctx(own_off, tick=3000))
+    assert evaluate(c.fail_condition, _ctx(own, tick=7300))
+
+
+def test_predicates_hard_requires_second_proc():
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    base = [
+        ("fact", 10, 22),
+        ("pbox", 12, 22), ("pbox", 12, 23), ("pbox", 12, 24),
+        ("weap", 14, 22),
+        ("fact", 130, 30),
+        ("proc", 6, 18),
+    ]
+    # FAIL: phase 4 missing — only 1 proc.
+    assert not evaluate(c.win_condition, _ctx(base, tick=3000))
+    # WIN: phase 4 satisfied — 2 procs (the original + a second).
+    base2 = base + [("proc", 130, 32)]
+    assert evaluate(c.win_condition, _ctx(base2, tick=3000))
+
+
+# ── engine-driven scripted policies ─────────────────────────────────
+
+
+def _find_mcv(rs):
+    for u in rs.get("units_summary", []) or []:
+        if str(u.get("type", "")).lower() == "mcv":
+            return u
+    return None
+
+
+def _find_harv(rs):
+    for u in rs.get("units_summary", []) or []:
+        if str(u.get("type", "")).lower() == "harv":
+            return u
+    return None
+
+
+def _base_xy(rs):
+    """Return the base #1 (west-side) fact (cell_x, cell_y), preferring
+    the smaller cell_x (the home base)."""
+    facts = [
+        b for b in (rs.get("own_buildings", []) or [])
+        if str(b.get("type", "")).lower() == "fact"
+    ]
+    if not facts:
+        return None
+    return min(facts, key=lambda b: b["cell_x"])
+
+
+def _stall_policy(rs, Command):
+    """Idles every turn — must LOSE (clock + patrol attrition)."""
+    return [Command.observe()]
+
+
+def _pure_expand_skip_defence_policy():
+    """Race the MCV east + deploy — never build pbox / weap. The
+    chain cannot advance past phase 1 (pbox); the patrol also chews
+    the base over time. Must LOSE."""
+
+    def pol(rs, Command):
+        mcv = _find_mcv(rs)
+        if mcv is None:
+            return [Command.observe()]
+        tx, ty = 131, 31
+        dx = mcv["cell_x"] - tx
+        dy = mcv["cell_y"] - ty
+        if dx * dx + dy * dy <= 36:
+            return [Command.deploy([str(mcv["id"])])]
+        return [Command.move_units([str(mcv["id"])], target_x=tx, target_y=ty)]
+
+    return pol
+
+
+def _pure_defence_no_expand_policy(pbox_target: int):
+    """Build pbox + weap forever — never move the MCV. The chain
+    stalls at phase 3 (no 2nd fact in east region); clock expires
+    ⇒ LOSS."""
+    state = {"placed_pbox": 0, "weap_attempts": 0, "harv_kicked": False}
+
+    def pol(rs, Command):
+        ob = rs.get("own_buildings", []) or []
+        own_b = {b["type"] for b in ob}
+        prod = rs.get("production", []) or []
+        cash = int(rs.get("cash", 0) or 0)
+        base = _base_xy(rs)
+        bx = base["cell_x"] if base else 10
+        by = base["cell_y"] if base else 30
+        cmds = []
+        # Kick the harv at the local mine (west of base).
+        if not state["harv_kicked"]:
+            harv = _find_harv(rs)
+            if harv:
+                cmds.append(Command.harvest([str(harv["id"])], bx - 8, by))
+                state["harv_kicked"] = True
+        pbox_have = sum(1 for b in ob if b["type"] == "pbox")
+        if pbox_have < pbox_target and "pbox" not in prod and cash >= 600:
+            cmds.append(Command.build("pbox"))
+        if pbox_have < pbox_target:
+            i = state["placed_pbox"]
+            row = -3 + 2 * (i % 4)
+            col = 3 + (i // 4)
+            cmds.append(Command.place_building(
+                "pbox", bx + col, by + row
+            ))
+            state["placed_pbox"] += 1
+        if (
+            pbox_have >= pbox_target
+            and "weap" not in own_b
+            and "weap" not in prod
+            and cash >= 2000
+        ):
+            cmds.append(Command.build("weap"))
+        if pbox_have >= pbox_target and "weap" not in own_b:
+            i = state["weap_attempts"]
+            cmds.append(Command.place_building(
+                "weap", bx + 8 + (i % 6), by - 4 + (i // 6)
+            ))
+            state["weap_attempts"] += 1
+        if not cmds:
+            cmds.append(Command.observe())
+        return cmds
+
+    return pol
+
+
+def _intended_secure_expand_with_tech_policy(pbox_target: int, hard: bool = False):
+    """The intended REASONING capability play:
+       turn 1: kick the harvester onto the local mine
+       phase 1: queue pbox one at a time until ≥pbox_target standing
+                AT THE SAME TIME, walk the MCV partway east while
+                income builds
+       phase 2: once phase 1 done, build weap
+       phase 3: once phase 2 done, move MCV the rest of the way and
+                deploy at (131,31) → fact lands at (130,30) inside
+                the east target region
+       phase 4 (hard only): build a SECOND proc at the new east base
+                (place it near the new east fact)
+    """
+    state = {
+        "placed_pbox": 0,
+        "weap_attempts": 0,
+        "proc2_attempts": 0,
+        "harv_kicked": False,
+        "mcv_deployed": False,
+    }
+
+    def pol(rs, Command):
+        ob = rs.get("own_buildings", []) or []
+        own_b = {b["type"] for b in ob}
+        prod = rs.get("production", []) or []
+        cash = int(rs.get("cash", 0) or 0)
+        base = _base_xy(rs)
+        bx = base["cell_x"] if base else 10
+        by = base["cell_y"] if base else 30
+        mcv = _find_mcv(rs)
+        cmds = []
+
+        # Kick the harv at the local mine (west of base).
+        if not state["harv_kicked"]:
+            harv = _find_harv(rs)
+            if harv:
+                cmds.append(Command.harvest([str(harv["id"])], bx - 8, by))
+                state["harv_kicked"] = True
+
+        # ── Phase 1: pbox first ──
+        pbox_have = sum(1 for b in ob if b["type"] == "pbox")
+        in_q_pbox = "pbox" in prod
+        if pbox_have < pbox_target and not in_q_pbox and cash >= 600:
+            cmds.append(Command.build("pbox"))
+        if pbox_have < pbox_target:
+            i = state["placed_pbox"]
+            row = -3 + 2 * (i % 4)
+            col = 3 + (i // 4)
+            cmds.append(Command.place_building(
+                "pbox", bx + col, by + row
+            ))
+            state["placed_pbox"] += 1
+
+        # ── Phase 2: weap (once phase-1 is satisfied) ──
+        if (
+            pbox_have >= pbox_target
+            and "weap" not in own_b
+            and "weap" not in prod
+            and cash >= 2000
+        ):
+            cmds.append(Command.build("weap"))
+        if pbox_have >= pbox_target and "weap" not in own_b:
+            i = state["weap_attempts"]
+            cmds.append(Command.place_building(
+                "weap", bx + 8 + (i % 6), by - 4 + (i // 6)
+            ))
+            state["weap_attempts"] += 1
+
+        # ── Phase 3: drive the MCV east + deploy at (131,31). Start
+        # moving as soon as Phase 1 is observed-locked (the then-
+        # composite is greedy so we can already be in motion). The
+        # MCV deploy itself is gated until weap is up — otherwise a
+        # too-early deploy would attempt to latch clause 3 before
+        # clause 2 and the chain would not advance.
+        if mcv is not None and not state["mcv_deployed"]:
+            tx, ty = 131, 31
+            dx = mcv["cell_x"] - tx
+            dy = mcv["cell_y"] - ty
+            dist2 = dx * dx + dy * dy
+            in_range = dist2 <= 36
+            # Move toward the target as soon as the chain is being
+            # worked; only deploy once weap is up (phase 2 latched).
+            if in_range and "weap" in own_b:
+                cmds.append(Command.deploy([str(mcv["id"])]))
+                state["mcv_deployed"] = True
+            elif not in_range:
+                cmds.append(Command.move_units(
+                    [str(mcv["id"])], target_x=tx, target_y=ty
+                ))
+
+        # ── Phase 4 (hard only): build a SECOND proc near the new
+        # east base. Only attempt once the east fact exists (phase 3
+        # latched).
+        if hard:
+            proc_have = sum(1 for b in ob if b["type"] == "proc")
+            east_fact = any(
+                b["type"] == "fact" and b["cell_x"] >= 100 for b in ob
+            )
+            if (
+                east_fact
+                and proc_have < 2
+                and "proc" not in prod
+                and cash >= 1400
+            ):
+                cmds.append(Command.build("proc"))
+            if east_fact and proc_have < 2:
+                i = state["proc2_attempts"]
+                # Place near the new east fact (which lives near
+                # (130,30) after deploy).
+                cmds.append(Command.place_building(
+                    "proc", 132 + (i % 4), 32 + (i // 4)
+                ))
+                state["proc2_attempts"] += 1
+
+        if not cmds:
+            cmds.append(Command.observe())
+        return cmds
+
+    return pol
+
+
+# ── Engine-bound tests (parameterised over seeds 1..4) ───────────────
+
+
+def _pbox_target(level: str) -> int:
+    return {"easy": 2, "medium": 3, "hard": 3}[level]
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_intended_secure_expand_with_tech_wins(level, seed):
+    """The intended secure-expand-with-tech policy must WIN on every
+    (level, seed). Load-bearing solvency test."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    res = run_level(
+        c,
+        _intended_secure_expand_with_tech_policy(
+            _pbox_target(level), hard=(level == "hard")
+        ),
+        seed=seed,
+    )
+    own_b = res.signals.own_building_types
+    assert res.outcome == "win", (
+        f"intended secure-expand-with-tech must WIN on {level} s={seed}; "
+        f"got {res.outcome} turns={res.turns} "
+        f"own_buildings={own_b} cash={res.signals.cash} "
+        f"units_lost={res.signals.units_lost} "
+        f"then_progress={getattr(res.signals, 'then_progress', {})}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_stall_loses(level, seed):
+    """Do-nothing must LOSE on every (level, seed)."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    res = run_level(c, _stall_policy, seed=seed)
+    assert res.outcome == "loss", (
+        f"stall must LOSE on {level} s={seed}; got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_pure_expand_skip_defence_loses(level, seed):
+    """Race-MCV-east-and-deploy without ever building pbox/weap must
+    LOSE: the then-chain cannot advance past phase 1 (pbox), and the
+    patrol bot is dripping pressure on the undefended base."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    res = run_level(c, _pure_expand_skip_defence_policy(), seed=seed)
+    own_b = res.signals.own_building_types
+    assert res.outcome == "loss", (
+        f"pure-expand-skip-defence must LOSE on {level} s={seed}; got "
+        f"{res.outcome} own_buildings={own_b} "
+        f"then_progress={getattr(res.signals, 'then_progress', {})}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_pure_defence_no_expand_loses(level, seed):
+    """Build pbox + weap forever — never move the MCV east. The
+    then-chain stalls at phase 3 (no 2nd fact in east region); clock
+    expires ⇒ LOSS."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    res = run_level(
+        c, _pure_defence_no_expand_policy(_pbox_target(level)), seed=seed
+    )
+    own_b = res.signals.own_building_types
+    assert res.outcome == "loss", (
+        f"pure-defence-no-expand must LOSE on {level} s={seed}; got "
+        f"{res.outcome} own_buildings={own_b} "
+        f"then_progress={getattr(res.signals, 'then_progress', {})}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+def test_hard_seeds_produce_distinct_starts(seed):
+    """Hard's two spawn_point groups must round-robin per seed."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    res = run_level(c, _stall_policy, seed=seed)
+    assert res.outcome == "loss"  # stall must lose
+    sp = {a.spawn_point for a in c.scenario.actors if a.owner == "agent"}
+    assert len(sp) >= 2

tests/test_lh_multi_checkpoint_5_plus.py

@@ -0,0 +1,413 @@
+"""lh-multi-checkpoint-5-plus pack — no-cheat validation on Rust.
+
+Group G long-horizon: 5+ ordered checkpoints chained via the Wave-2
+`then:` happened-before composite. The chain MIXES checkpoint kinds:
+buildings, quantitative production, episode-aggregate kills, and
+terminal destruction — so the ordering is genuinely load-bearing.
+
+Medium chain (the headline 5-phase cell):
+    PHASE 1: has_building: proc
+    PHASE 2: has_building: weap
+    PHASE 3: unit_type_count_gte: {type: 2tnk, n: 2}
+    PHASE 4: units_killed_gte: 3
+    PHASE 5: enemy_key_buildings_destroyed: {types: [fact]}
+
+Hard adds a 6th regression checkpoint (≥4 tanks after kills) and 2
+spawn_point groups (NORTH/SOUTH base round-robined by seed).
+
+Bar (per CLAUDE.md): the intended phased policy WINS on every
+(level, seed); stall / skip-phase-3 / skip-phase-4 / pre-build all
+LOSE on every seed. The `then:` latch is load-bearing — a "rush
+the fact and kill on the way" play scores early kills but the latch
+does not credit them to clause-4 until proc + weap + tanks have
+latched in order.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+from openra_bench.eval_core import run_level
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+
+PACK = PACKS_DIR / "lh-multi-checkpoint-5-plus.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+# Per-level chain length (the n in `then.clauses`).
+_CHAIN_LEN = {"easy": 3, "medium": 5, "hard": 6}
+
+# Per-level required tank army size for the highest-N tank clause.
+# easy has no tank-count clause; medium has n:2 only; hard has both
+# n:2 (clause 3) and n:4 (clause 5) — the policy must produce ≥4.
+_ARMY_TARGET = {"easy": 0, "medium": 2, "hard": 4}
+
+
+# ── Policies ──────────────────────────────────────────────────────
+
+
+def _stall_policy():
+    """Do nothing — must LOSE on the clock on every level/seed."""
+    def pol(obs, Cmd):
+        return [Cmd.observe()]
+    return pol
+
+
+def _enemy_fact_xy(level: str) -> tuple[int, int]:
+    """Per-level enemy fact coords (lifted from the YAML so the
+    policies attack the right point on each tier)."""
+    return (115, 30) if level in ("easy", "medium") else (115, 20)
+
+
+def _skip_to_attack_policy(level: str):
+    """Rush the enemy fact immediately with the 4 starting tanks; no
+    proc, no weap, no chain. Must LOSE — the then-latch starts at
+    index 0 and `has_building:proc` is never observed-true, so even
+    a successful fact-kill does not advance the chain past clause 0."""
+    fx, fy = _enemy_fact_xy(level)
+
+    def pol(obs, Cmd):
+        units = obs.get("units_summary", []) or []
+        tnk = [u["id"] for u in units if u.get("type") == "2tnk"]
+        if tnk:
+            return [Cmd.attack_move(tnk, fx, fy)]
+        return [Cmd.observe()]
+    return pol
+
+
+def _skip_phase_3_policy(level: str):
+    """Build proc + weap (phases 1+2) then skip the army clause —
+    immediately attack the fact with starting tanks. On easy the
+    chain has no army clause so this should WIN; on medium/hard the
+    chain has a tank-count clause that, despite being satisfied at
+    t=0 by pre-placed tanks, only latches AFTER weap latches — so
+    this policy might still win medium (the latch advances P3→P4→P5
+    once weap lands and there are ≥2 tanks alive). To genuinely
+    skip phase 3 we must KILL one of our own tanks (or lose them in
+    combat) so unit_type_count_gte:{2tnk,n:2} is FALSE for medium,
+    or unit_type_count_gte:{2tnk,n:4} is FALSE for hard. The
+    easier teeth: this policy attacks the fact with 2 tanks held
+    back at base (less than n:4 on hard) — on hard it must LOSE."""
+    fx, fy = _enemy_fact_xy(level)
+
+    # Sticky milestone latches for the build-order phases.
+    state = {"built_proc": False, "built_weap": False}
+
+    def pol(obs, Cmd):
+        ob = obs.get("own_buildings", []) or []
+        own_b = {b["type"] for b in ob}
+        prod = obs.get("production", []) or []
+        units = obs.get("units_summary", []) or []
+        tnk = [u["id"] for u in units if u.get("type") == "2tnk"]
+        cmds = []
+        base = [b for b in ob if b["type"] == "fact"]
+        if "proc" in own_b:
+            state["built_proc"] = True
+        if "weap" in own_b:
+            state["built_weap"] = True
+        # PHASE 1 (proc).
+        if not state["built_proc"]:
+            if "proc" not in prod:
+                cmds.append(Cmd.build("proc"))
+            if base:
+                cmds.append(Cmd.place_building(
+                    "proc", base[0]["cell_x"] + 6, base[0]["cell_y"] + 4
+                ))
+            if not cmds:
+                cmds.append(Cmd.observe())
+            return cmds
+        # PHASE 2 (weap).
+        if not state["built_weap"]:
+            if "weap" not in prod:
+                cmds.append(Cmd.build("weap"))
+            if base:
+                cmds.append(Cmd.place_building(
+                    "weap", base[0]["cell_x"] + 8, base[0]["cell_y"]
+                ))
+            if not cmds:
+                cmds.append(Cmd.observe())
+            return cmds
+        # PHASES 3-5: skip the army-rebuild; attack with whatever
+        # tanks are still alive. On hard this is <4 tanks so clause
+        # 5 (unit_type_count_gte:{2tnk,n:4}) never latches.
+        if tnk:
+            cmds.append(Cmd.attack_move(tnk, fx, fy))
+        if not cmds:
+            cmds.append(Cmd.observe())
+        return cmds
+    return pol
+
+
+def _skip_phase_4_policy(level: str):
+    """Build proc + weap + (rebuild army to target) but NEVER engage
+    — kills stay at 0 so clause-4 (units_killed_gte:3) never latches
+    on medium/hard. The chain stalls at index 3 and the clock expires.
+    On easy there is no kill clause and no army clause, so this
+    policy reduces to "build proc+weap and never attack" — which
+    MUST also LOSE because the engage clause (P3 on easy) never
+    latches without an attack."""
+    target = _ARMY_TARGET[level]
+
+    def pol(obs, Cmd):
+        ob = obs.get("own_buildings", []) or []
+        own_b = {b["type"] for b in ob}
+        prod = obs.get("production", []) or []
+        units = obs.get("units_summary", []) or []
+        tnk = [u for u in units if u.get("type") == "2tnk"]
+        cmds = []
+        base = [b for b in ob if b["type"] == "fact"]
+        if "proc" not in own_b and "proc" not in prod:
+            cmds.append(Cmd.build("proc"))
+        if "proc" not in own_b and base:
+            cmds.append(Cmd.place_building(
+                "proc", base[0]["cell_x"] + 6, base[0]["cell_y"] + 4
+            ))
+        if "proc" in own_b and "weap" not in own_b and "weap" not in prod:
+            cmds.append(Cmd.build("weap"))
+        if "proc" in own_b and "weap" not in own_b and base:
+            cmds.append(Cmd.place_building(
+                "weap", base[0]["cell_x"] + 8, base[0]["cell_y"]
+            ))
+        # Rebuild army if needed but DO NOT engage.
+        if (
+            "weap" in own_b
+            and target > 0
+            and len(tnk) < target
+            and "2tnk" not in prod
+        ):
+            cmds.append(Cmd.build("2tnk"))
+        if not cmds:
+            cmds.append(Cmd.observe())
+        return cmds
+    return pol
+
+
+def _intended_chain_policy(level: str):
+    """The intended 5+ checkpoint chain (sticky milestones so a built-
+    then-destroyed proc doesn't reset the policy). Build proc + weap
+    on the macro thread WHILE concurrently driving the pre-placed
+    tanks east to engage and raze the enemy fact — the `then:` latch
+    only advances clause-by-clause once each predicate is observed-
+    true in order, so doing the work in parallel doesn't skip ahead.
+
+    Must WIN on every (level, seed)."""
+    fx, fy = _enemy_fact_xy(level)
+    issued_attack = {"yes": False}
+
+    def pol(obs, Cmd):
+        ob = obs.get("own_buildings", []) or []
+        own_b = {b["type"] for b in ob}
+        prod = obs.get("production", []) or []
+        units = obs.get("units_summary", []) or []
+        tnk = [u for u in units if u.get("type") == "2tnk"]
+        base = [b for b in ob if b["type"] == "fact"]
+
+        cmds = []
+        # Macro thread: drive proc → weap to completion, then
+        # optionally keep producing tanks (helps hard's n:4 clause
+        # if any pre-placed tank dies mid-engagement).
+        if "proc" not in own_b:
+            if "proc" not in prod:
+                cmds.append(Cmd.build("proc"))
+            if base:
+                cmds.append(Cmd.place_building(
+                    "proc", base[0]["cell_x"] + 6, base[0]["cell_y"] + 4
+                ))
+        elif "weap" not in own_b:
+            if "weap" not in prod:
+                cmds.append(Cmd.build("weap"))
+            if base:
+                cmds.append(Cmd.place_building(
+                    "weap", base[0]["cell_x"] + 8, base[0]["cell_y"]
+                ))
+        else:
+            # Both up — keep producing tanks (cheap insurance for the
+            # n:4 hard clause after attrition; auto-placed by the
+            # engine since `weap` knows its own queue).
+            if "2tnk" not in prod and len(tnk) < 8:
+                cmds.append(Cmd.build("2tnk"))
+
+        # Combat thread: ALWAYS attack-move every tank east toward
+        # the enemy fact. Re-issuing each turn keeps freshly-built
+        # tanks pointed at the objective.
+        if tnk:
+            cmds.append(Cmd.attack_move([u["id"] for u in tnk], fx, fy))
+            issued_attack["yes"] = True
+
+        if not cmds:
+            cmds.append(Cmd.observe())
+        return cmds
+    return pol
+
+
+# ── Pack-shape tests (cheap; do not run the engine) ──────────────
+
+
+def test_pack_compiles_with_three_levels():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "lh-multi-checkpoint-5-plus"
+    assert pack.meta.capability == "action"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+
+
+def test_meta_benchmark_anchor_set():
+    """Required: PlanBench long-sequencing + PERT critical path
+    anchors, per the wave-5 spec."""
+    pack = load_pack(PACK)
+    anchors = pack.meta.benchmark_anchor or []
+    assert any("PlanBench" in a for a in anchors), anchors
+    assert any("PERT" in a for a in anchors), anchors
+    assert any("SOP" in a for a in anchors), anchors
+
+
+def test_hard_tier_has_seed_driven_spawn_groups():
+    """Hard must define ≥2 agent spawn_point groups (UPGRADED
+    contract in tests/test_hard_tier.py)."""
+    c = compile_level(load_pack(PACK), "hard")
+    sp = {a.spawn_point for a in c.scenario.actors if a.owner == "agent"}
+    assert len(sp) >= 2, f"hard needs ≥2 spawn groups, got {sp}"
+
+
+def test_every_level_has_fail_condition():
+    """No silent draws — every level must be able to emit a LOSS."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.fail_condition is not None, f"{lvl} missing fail_condition"
+
+
+def test_then_chain_lengths_per_level():
+    """easy=3, medium=5, hard=6 phases (the headline difficulty
+    axis is the chain length)."""
+    for lvl in LEVELS:
+        c = compile_level(load_pack(PACK), lvl)
+        win = c.win_condition.model_dump(exclude_none=True)
+        inner = win.get("all_of") or []
+        assert any("then" in cl for cl in inner), (
+            f"{lvl} win missing then-chain: {win}"
+        )
+        for cl in inner:
+            if "then" in cl:
+                clauses = (cl["then"] or {}).get("clauses") or []
+                assert len(clauses) == _CHAIN_LEN[lvl], (
+                    f"{lvl} chain must have {_CHAIN_LEN[lvl]} "
+                    f"clauses; got {len(clauses)}"
+                )
+
+
+def test_tick_budget_aligned_with_max_turns():
+    """within_ticks must be reachable inside max_turns. Engine
+    advances ~90 ticks/turn → reachable max = 93 + 90·(N-1)."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        level_def = pack.levels[lvl]
+        max_turns = level_def.max_turns
+        reachable = 93 + 90 * (max_turns - 1)
+        win = compile_level(pack, lvl).win_condition.model_dump(exclude_none=True)
+
+        def _collect(node, key, out):
+            if isinstance(node, dict):
+                if key in node:
+                    out.append(node[key])
+                for v in node.values():
+                    _collect(v, key, out)
+            elif isinstance(node, list):
+                for v in node:
+                    _collect(v, key, out)
+        wts = []
+        _collect(win, "within_ticks", wts)
+        assert wts, f"{lvl} has no within_ticks leaf"
+        for wt in wts:
+            assert wt <= reachable, (
+                f"{lvl} within_ticks={wt} > reachable={reachable} "
+                f"(max_turns={max_turns}) — deadline never bites"
+            )
+
+
+# ── Engine-bound tests (parameterised over seeds 1..4) ────────────
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_intended_chain_policy_wins(level, seed):
+    """The intended N+ checkpoint chain must WIN on every (level, seed)."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _intended_chain_policy(level), seed=seed)
+    tp = getattr(res.signals, "then_progress", {}) or {}
+    assert res.outcome == "win", (
+        f"intended chain must WIN on {level} s={seed}; "
+        f"got {res.outcome} (then_progress={tp}, "
+        f"kills={res.signals.units_killed}, "
+        f"own_buildings={res.signals.own_building_types})"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_stall_loses(level, seed):
+    """A do-nothing policy must LOSE on every (level, seed)."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _stall_policy(), seed=seed)
+    assert res.outcome == "loss", (
+        f"stall must LOSE on {level} s={seed}; got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_skip_to_attack_loses(level, seed):
+    """Rush the fact with starting tanks (no proc, no weap, no
+    chain). Must LOSE on every (level, seed) — clause-1 (proc) is
+    never observed-true so the then-latch never advances past 0."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _skip_to_attack_policy(level), seed=seed)
+    tp = getattr(res.signals, "then_progress", {}) or {}
+    assert res.outcome == "loss", (
+        f"skip-to-attack must LOSE on {level} s={seed}; "
+        f"got {res.outcome} then_progress={tp}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+def test_skip_phase_4_loses_medium(seed):
+    """On medium, building proc+weap but NEVER engaging means kills
+    stay at 0 — clause-4 (units_killed_gte:3) never latches and the
+    chain stalls at index 3."""
+    c = compile_level(load_pack(PACK), "medium")
+    res = run_level(c, _skip_phase_4_policy("medium"), seed=seed)
+    tp = getattr(res.signals, "then_progress", {}) or {}
+    assert res.outcome == "loss", (
+        f"skip-phase-4 must LOSE on medium s={seed}; "
+        f"got {res.outcome} then_progress={tp} "
+        f"kills={res.signals.units_killed}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+def test_skip_phase_4_loses_hard(seed):
+    """Same on hard — no engagement means no kills, no fact-kill,
+    no chain advance past clause 3."""
+    c = compile_level(load_pack(PACK), "hard")
+    res = run_level(c, _skip_phase_4_policy("hard"), seed=seed)
+    tp = getattr(res.signals, "then_progress", {}) or {}
+    assert res.outcome == "loss", (
+        f"skip-phase-4 must LOSE on hard s={seed}; "
+        f"got {res.outcome} then_progress={tp} "
+        f"kills={res.signals.units_killed}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+def test_hard_seeds_produce_distinct_starts(seed):
+    """Hard's two spawn_point groups must round-robin: different
+    seeds place the agent base at a different (x,y) set. Smoke-tests
+    the spawn-variation contract enforced by test_hard_tier.py."""
+    c = compile_level(load_pack(PACK), "hard")
+    res = run_level(c, _stall_policy(), seed=seed)
+    assert res.outcome == "loss"
+    sp = {a.spawn_point for a in c.scenario.actors if a.owner == "agent"}
+    assert len(sp) >= 2

tests/test_lh_scout_react_counter.py

@@ -0,0 +1,418 @@
+"""lh-scout-react-counter pack — full no-cheat validation on Rust.
+
+Group-G long-horizon reasoning pack: observation-driven 3-phase
+chain. The agent has a small fixed force (1× jeep scout + 3× 2tnk)
+at the west; it must (1) SCOUT — drive the jeep east and register
+≥2 enemy buildings (the construction yard AND a paired barracks),
+(2) REACT — engage with the tanks to destroy ≥3 enemy units, then
+(3) COUNTER — raze the enemy construction yard. Wave-2 `then:`
+happened-before composite enforces the order; `within_ticks: 6300`
+is the deadline; hard adds `units_lost_lte: 3` as an attrition
+tooth and a third enemy posture pocket at MID-y.
+
+Bar (per CLAUDE.md): the intended scout-react-counter policy WINS
+on every (level, seed); every stall / skip-scout-attack-blind /
+scout-only-no-attack policy LOSES on every level + seed. The pack
+sits alongside `lh-tech-pivot-attack` (which tests build-the-
+counter as the middle phase) and `mid-tech-switch-on-scout` (the
+2-phase scout-then-counter sibling): this one isolates the
+observation-action-counter loop on a FIXED FORCE (cash 1500 is too
+lean to fund a new production line — the capability is the
+reactive 3-phase chain, not the build-out).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+from openra_bench.eval_core import run_level
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+
+PACK = PACKS_DIR / "lh-scout-react-counter.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+
+# ── Policies ──────────────────────────────────────────────────────
+
+
+def _stall_policy():
+    """Do nothing — must LOSE on after_ticks every level/seed."""
+    def pol(obs, Cmd):
+        return [Cmd.observe()]
+    return pol
+
+
+def _skip_scout_attack_blind_policy():
+    """Rush the tanks straight at the nearest plausible enemy fact
+    coordinate without driving the scout jeep east first. The
+    discovery latch (≥2 buildings) is the load-bearing first
+    clause: a tank rush that smashes the fact MAY register a
+    single building (the fact under attack) but the paired
+    barracks (tent) sits OFF the assault axis (y-offset +4),
+    outside the tank's sight while it shells the fact — so
+    buildings_discovered stays at 1 and the then-chain stalls at
+    clause 1. Even if a stray sight tick caught the tent, the
+    chain still requires ≥3 unit kills BEFORE raze (the tank
+    rush kills the cluster en route only after the fact-attack
+    has begun, and the then-chain credit order matters)."""
+    def pol(obs, Cmd):
+        units = obs.get("units_summary", []) or []
+        own_b = obs.get("own_buildings", []) or []
+        # Pick target y by agent fact latitude (NORTH spawn → y=5,
+        # SOUTH spawn → y=38, easy single-spawn → y=18).
+        agent_fact = next(
+            (b for b in own_b if b.get("type") == "fact"), None,
+        )
+        if agent_fact is None:
+            return [Cmd.observe()]
+        ay = agent_fact["cell_y"]
+        if ay < 14:
+            target_y = 5
+        elif ay > 24:
+            target_y = 38
+        else:
+            target_y = 18
+        tnk_ids = [u["id"] for u in units if u.get("type") == "2tnk"]
+        if not tnk_ids:
+            return [Cmd.observe()]
+        # Attack-move directly at the enemy fact coordinate. No
+        # scout move issued.
+        return [Cmd.attack_move(tnk_ids, 122, target_y)]
+    return pol
+
+
+def _scout_only_no_attack_policy():
+    """Drive the scout jeep east to register the enemy buildings
+    (satisfies clause 1) but never engage with the tanks — the
+    then-chain stalls at clause 2 (units_killed_gte:3), and the
+    clock eventually expires. Asserts that scouting alone is not
+    sufficient — the REACT phase is load-bearing."""
+    state = {"went_outpost": False, "ticks_since_outpost": 0,
+             "went_corner": False}
+
+    def pol(obs, Cmd):
+        units = obs.get("units_summary", []) or []
+        own_b = obs.get("own_buildings", []) or []
+        jeep = next((u for u in units if u.get("type") == "jeep"), None)
+        agent_fact = next(
+            (b for b in own_b if b.get("type") == "fact"), None,
+        )
+        if jeep is None or agent_fact is None:
+            return [Cmd.observe()]
+        ay = agent_fact["cell_y"]
+        # Drive the jeep through the off-axis outpost (registers
+        # the tent), then on to the near fact's y-band (registers
+        # the fact). Both buildings get discovered, but the tanks
+        # never engage so units_killed stays 0 and the chain
+        # stalls at clause 2.
+        if ay < 14:
+            fact_y, outpost = 5, (60, 20)
+        elif ay > 24:
+            fact_y, outpost = 38, (60, 20)
+        else:
+            fact_y, outpost = 18, (60, 36)
+        if not state["went_outpost"]:
+            state["went_outpost"] = True
+            return [Cmd.move_units([jeep["id"]], *outpost)]
+        state["ticks_since_outpost"] += 1
+        if state["ticks_since_outpost"] >= 8 and not state["went_corner"]:
+            state["went_corner"] = True
+            return [Cmd.move_units([jeep["id"]], 120, fact_y)]
+        return [Cmd.observe()]
+    return pol
+
+
+def _intended_scout_react_counter_policy(easy_mode: bool):
+    """The intended capability play. Drives the chain end-to-end:
+      1. Jeep moves to the forward outpost (mid-x off-axis tent),
+         then continues to the near corner — registers BOTH the
+         outpost tent AND the corner fact (≥2 buildings
+         discovered) ⇒ then[0] latches.
+      2. Tanks attack-move at the near fact — the defending
+         stance:0 cluster sits at (118, fact_y) right on the
+         assault axis, so the tanks engage and kill ≥3 ⇒ then[1]
+         latches.
+      3. Tanks continue past the cluster and shell the fact ⇒
+         then[2] (and the top-level enemy_key_buildings_destroyed)
+         both latch ⇒ WIN inside 6300 ticks.
+    """
+    state = {"outpost_dispatched": False, "scout_dispatched": False,
+             "attack_dispatched": False, "scout_ticks": 0}
+
+    def pol(obs, Cmd):
+        units = obs.get("units_summary", []) or []
+        own_b = obs.get("own_buildings", []) or []
+        agent_fact = next(
+            (b for b in own_b if b.get("type") == "fact"), None,
+        )
+        jeep = next((u for u in units if u.get("type") == "jeep"), None)
+        tnk_ids = [u["id"] for u in units if u.get("type") == "2tnk"]
+        cmds = []
+
+        # Pick near corner by agent latitude, and the outpost
+        # coordinate that matches the level's layout.
+        if easy_mode:
+            fact_y = 18
+            outpost = (60, 36)        # easy outpost far south
+        elif agent_fact and agent_fact["cell_y"] < 18:
+            fact_y = 5
+            outpost = (60, 20)        # medium/hard shared mid outpost
+        else:
+            fact_y = 38
+            outpost = (60, 20)
+
+        # 1a. SCOUT — first dispatch jeep to the off-axis outpost.
+        if jeep is not None and not state["outpost_dispatched"]:
+            cmds.append(Cmd.move_units([jeep["id"]], *outpost))
+            state["outpost_dispatched"] = True
+        # 1b. Then redirect jeep east to the near fact's y-band
+        #     (give it a few turns to traverse to the outpost
+        #     and surface the tent in enemy_buildings).
+        elif (jeep is not None
+              and state["outpost_dispatched"]
+              and not state["scout_dispatched"]):
+            state["scout_ticks"] += 1
+            if state["scout_ticks"] >= 8:
+                cmds.append(Cmd.move_units([jeep["id"]], 120, fact_y))
+                state["scout_dispatched"] = True
+
+        # 2 + 3. REACT + COUNTER — dispatch the tanks early; one
+        #    attack_move covers both phases (they engage the
+        #    stance:0 cluster en route, then continue to raze
+        #    the fact). The then-chain's first clause may not
+        #    yet be latched when the tanks start moving — that's
+        #    fine, the greedy advance picks up clauses in order
+        #    once each becomes true, and the rush takes long
+        #    enough that the jeep's scout completes first.
+        if tnk_ids and not state["attack_dispatched"]:
+            cmds.append(Cmd.attack_move(tnk_ids, 122, fact_y))
+            state["attack_dispatched"] = True
+
+        if not cmds:
+            cmds.append(Cmd.observe())
+        return cmds
+    return pol
+
+
+# ── Pack-shape tests (cheap; do not run the engine) ──────────────
+
+
+def test_pack_compiles_with_three_levels():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "lh-scout-react-counter"
+    assert pack.meta.capability == "reasoning"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+
+
+def test_meta_benchmark_anchor_set():
+    """Required by the seed taxonomy: SC2 reactive macro / CICERO
+    info-loop / PlanBench replanning / threat-intel anchors."""
+    pack = load_pack(PACK)
+    anchors = pack.meta.benchmark_anchor or []
+    assert any("SC2" in a for a in anchors), anchors
+    assert any("CICERO" in a for a in anchors), anchors
+    assert any("PlanBench" in a for a in anchors), anchors
+    assert any("threat-intel" in a for a in anchors), anchors
+
+
+def test_hard_tier_has_seed_driven_spawn_groups():
+    """Hard must define ≥2 agent spawn_point groups so seed varies
+    the start base (binding contract from tests/test_hard_tier.py)."""
+    c = compile_level(load_pack(PACK), "hard")
+    sp = {a.spawn_point for a in c.scenario.actors if a.owner == "agent"}
+    assert len(sp) >= 2, f"hard needs ≥2 spawn groups, got {sp}"
+
+
+def test_every_level_has_fail_condition():
+    """No silent draws — every level must be able to emit a LOSS."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.fail_condition is not None, f"{lvl} missing fail_condition"
+
+
+def test_then_composite_used_in_win():
+    """The 3-phase scout-react-counter chain must be wired through
+    to the compiled win condition (the whole point of the pack)."""
+    for lvl in LEVELS:
+        c = compile_level(load_pack(PACK), lvl)
+        win = c.win_condition.model_dump(exclude_none=True)
+        ao = win.get("all_of") or []
+        then_branches = [b for b in ao if "then" in b]
+        assert len(then_branches) >= 1, f"{lvl} missing then-chain: {win}"
+        clauses = then_branches[0]["then"]["clauses"]
+        assert len(clauses) == 3, (
+            f"{lvl} then-chain must be 3 clauses (scout, react, "
+            f"counter), got {len(clauses)}"
+        )
+        # 1. scout latch — ≥2 buildings discovered (NOT ≥1; the
+        #    spec makes scouting load-bearing by requiring a
+        #    second building, defeating the rush-the-fact play).
+        assert clauses[0].get("buildings_discovered_gte") == 2, clauses[0]
+        # 2. react — kill at least 3 enemy units.
+        assert clauses[1].get("units_killed_gte") == 3, clauses[1]
+        # 3. counter — raze the enemy fact.
+        assert "enemy_key_buildings_destroyed" in clauses[2], clauses[2]
+
+
+def test_tick_budget_aligned_with_max_turns():
+    """within_ticks must be reachable inside max_turns. Engine
+    advances ~90 ticks/turn → reachable max = 93 + 90·(N-1)."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        level_def = pack.levels[lvl]
+        max_turns = level_def.max_turns
+        reachable = 93 + 90 * (max_turns - 1)
+        win = compile_level(pack, lvl).win_condition.model_dump(
+            exclude_none=True,
+        )
+
+        def _collect(node, key, out):
+            if isinstance(node, dict):
+                if key in node:
+                    out.append(node[key])
+                for v in node.values():
+                    _collect(v, key, out)
+            elif isinstance(node, list):
+                for v in node:
+                    _collect(v, key, out)
+
+        wts = []
+        _collect(win, "within_ticks", wts)
+        assert wts, f"{lvl} has no within_ticks leaf (no clock teeth)"
+        for wt in wts:
+            assert wt <= reachable, (
+                f"{lvl} within_ticks={wt} > reachable={reachable} "
+                f"(max_turns={max_turns}) — deadline never bites ⇒ draw"
+            )
+
+
+def test_tools_list_matches_spec():
+    """Tools per spec: [observe, build, place_building, move_units,
+    attack_unit, attack_move, stop]."""
+    pack = load_pack(PACK)
+    expected = {"observe", "build", "place_building", "move_units",
+                "attack_unit", "attack_move", "stop"}
+    tools = pack.base.get("tools") if isinstance(pack.base, dict) \
+        else pack.base.tools
+    assert set(tools) == expected, tools
+
+
+def test_starting_cash_is_lean():
+    """Spec calls for starting_cash: 1500 across all levels — the
+    capability is the reactive 3-phase chain on the FIXED force,
+    not a build-out funded from a generous war chest."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        assert pack.levels[lvl].starting_cash == 1500, lvl
+
+
+def test_hard_has_attrition_cap():
+    """Hard adds units_lost_lte:3 as the +1 controlled axis (one
+    new variable per tier per the curation contract)."""
+    c = compile_level(load_pack(PACK), "hard")
+    win = c.win_condition.model_dump(exclude_none=True)
+
+    def _has(node, key):
+        if isinstance(node, dict):
+            if key in node:
+                return True
+            return any(_has(v, key) for v in node.values())
+        if isinstance(node, list):
+            return any(_has(v, key) for v in node)
+        return False
+
+    assert _has(win, "units_lost_lte"), (
+        "hard must include units_lost_lte tooth"
+    )
+
+
+# ── Engine-bound tests (parameterised over seeds 1..4) ────────────
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_intended_scout_react_counter_wins(level, seed):
+    """The intended scout → react → counter capability play must
+    WIN on every (level, seed). This is the load-bearing test
+    that the pack is solvable inside the budget by the advertised
+    capability across all hard-tier spawn variants."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(
+        c, _intended_scout_react_counter_policy(easy_mode=(level == "easy")),
+        seed=seed,
+    )
+    assert res.outcome == "win", (
+        f"intended scout-react-counter must WIN on {level} s={seed}; "
+        f"got {res.outcome} (kills={res.signals.units_killed}, "
+        f"bds={len(res.signals.enemy_buildings_seen_ids)}, "
+        f"lost={res.signals.units_lost}, "
+        f"then_progress={getattr(res.signals, 'then_progress', {})})"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_stall_loses(level, seed):
+    """A do-nothing policy must LOSE (no win, no draw) on every
+    (level, seed). The fail_condition's after_ticks clause bites
+    at the turn budget; never a draw."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _stall_policy(), seed=seed)
+    assert res.outcome == "loss", (
+        f"stall must LOSE on {level} s={seed}; got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_skip_scout_attack_blind_loses(level, seed):
+    """A blind tank-rush at the fact (no scout first) must LOSE
+    on every (level, seed). The then-chain requires ≥2 buildings
+    discovered FIRST; a tank rush only registers the fact under
+    attack (1 building) and the chain stalls at clause 1 — the
+    fact may eventually fall but the chain credit was never
+    earned in order, so within_ticks expires without a WIN. This
+    is the load-bearing 'scout is mandatory' tooth."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _skip_scout_attack_blind_policy(), seed=seed)
+    assert res.outcome == "loss", (
+        f"skip-scout-attack-blind must LOSE on {level} s={seed}; "
+        f"got {res.outcome} (kills={res.signals.units_killed}, "
+        f"bds={len(res.signals.enemy_buildings_seen_ids)}, "
+        f"then_progress={getattr(res.signals, 'then_progress', {})})"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_scout_only_no_attack_loses(level, seed):
+    """A scout-only policy (jeep registers the buildings but the
+    tanks never engage) must LOSE on every (level, seed). The
+    then-chain stalls at clause 2 (units_killed_gte:3) — the
+    REACT phase is load-bearing. The clock eventually expires."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _scout_only_no_attack_policy(), seed=seed)
+    assert res.outcome == "loss", (
+        f"scout-only-no-attack must LOSE on {level} s={seed}; "
+        f"got {res.outcome} (kills={res.signals.units_killed}, "
+        f"bds={len(res.signals.enemy_buildings_seen_ids)}, "
+        f"then_progress={getattr(res.signals, 'then_progress', {})})"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+def test_hard_seeds_produce_distinct_starts(seed):
+    """Hard's two spawn_point groups must actually round-robin —
+    different seeds must place the agent base at a different (x,y)
+    set. Smoke-tests the spawn-variation contract."""
+    c = compile_level(load_pack(PACK), "hard")
+    res = run_level(c, _stall_policy(), seed=seed)
+    assert res.outcome == "loss"  # stall must lose
+    sp = {a.spawn_point for a in c.scenario.actors if a.owner == "agent"}
+    assert len(sp) >= 2