feat(scenario): def-position-expected-direction — fortify intel'd threat axis (ERQA / MicroRTS anchor)

Group C reasoning pack on rush-hour-arena: the mission brief states
WHERE the enemy will attack from (NORTH on easy/medium; matched-side
NORTH/SOUTH per spawn on hard) and the agent must commit its pillbox
triple to that lane.

Win idiom: building_count_gte:{pbox,3} AND building_in_region:{pbox,
NORTH_centre, r=6, 3} AND has_building:fact AND own_units_gte:3
AND within_ticks:5400 (paired with after_ticks:5401 for a real
reachable timeout LOSS).

Hard tier defines two agent spawn_point groups (NORTH base y=12 /
SOUTH base y=28) round-robined by seed; the win clause is any_of
over the two correct region orientations so 'NORTH of YOUR base'
flips per seed and a single memorised pbox cell cannot generalise.

Scripted-bar (all seeds 1..4): intended NORTH-pbox triple WINS
every level + every hard seed; stall / defenses-SOUTH / no-defenses
ALL LOSE (real reachable timeout LOSS) every level + every hard
seed — never a draw.

Model smoke: Qwen/Qwen3.6-Plus on medium seed 1 = LOSS (composite
0.3305) — valid discrimination, the model failed to commit defence
to the declared threat axis.

Anchors: ERQA spatial commit, MicroRTS terrain-aware defence,
military pre-positioned defence, intel-driven facility hardening.

openra_bench/scenarios/packs/def-position-expected-direction.yaml

@@ -0,0 +1,320 @@
+# def-position-expected-direction.yaml
+#
+# REASONING capability — DEFENSE POSITIONING BASED ON DECLARED THREAT
+# DIRECTION. The model is TOLD where the enemy will attack from (the
+# objective brief states the intel: "rushers will come from the
+# NORTH"). The decision is purely one of spatial commitment: invest
+# the defence budget on the CORRECT lane — the NORTH lane — and
+# the rush is blunted; commit the SAME budget on the WRONG lane
+# (SOUTH) and the rushers walk past, the deadline expires (the
+# wrong-direction pbox cannot satisfy the NORTH region clause), and
+# the run loses. Building no defences at all also loses (no pbox).
+#
+# Win idiom:
+#   * `building_count_gte:{pbox, 3}` — three pillboxes total
+#     (forces a real defence commitment, not a token pbox);
+#   * `building_in_region:{pbox, NORTH_centre, r, 3}` — ALL THREE
+#     must be in the NORTH-of-base region (a SOUTH-built triple
+#     does not satisfy this clause);
+#   * `has_building: fact` — the construction yard still stands
+#     (sanity / anti-degeneracy);
+#   * `own_units_gte: 3` — the four pre-placed defenders must
+#     mostly survive (a chaotic micro that bleeds them out fails
+#     this even with the NORTH pbox triple in place);
+#   * `within_ticks: 5400` paired with a `after_ticks: 5401` fail
+#     ⇒ reachable timeout LOSS, never a draw.
+#
+# Real-world / benchmark anchors:
+#   - Pre-positioned defence based on known threat direction;
+#   - ERQA spatial commit (commit to one of N candidate spatial
+#     regions given a textual cue);
+#   - MicroRTS terrain-aware defence;
+#   - military prepared-defence doctrine (intel-driven facility
+#     hardening on the threat axis).
+#
+# Distinct from siblings (Group C):
+#   * defense-rush-survive — REACTIVE rush-defence under tempo (the
+#     threat axis is one fixed lane; the decision is balancing
+#     defence + throughput under clock). This pack is purely about
+#     COMMITTING DEFENCE TO THE CORRECT AXIS given declared intel.
+#   * tech-turtle-defensive-tech — sequenced fortify-then-tech
+#     (the axis is fixed; the decision is the order, not the side).
+#   * expansion-turtle-1-base-fortified — single-base mass-defence
+#     (no directional axis; the whole perimeter must be covered).
+#
+# Validate:
+#   cd /Users/berta/Projects/OpenRA-Bench && \
+#   python3 -m openra_bench.scenarios.validate \
+#     openra_bench/scenarios/packs/def-position-expected-direction.yaml
+
+meta:
+  id: def-position-expected-direction
+  title: 'Fortify the Threat Axis — Pre-Position Defence on the Intel Lane'
+  capability: reasoning
+  real_world_meaning: >
+    Spatial commitment of a finite defence budget to the CORRECT
+    direction given declared intel. The mission brief states where the
+    enemy will attack from; the agent must invest its pillboxes on
+    that lane (and not the opposite lane). A correct-axis commitment
+    blunts the rush; a wrong-axis commitment lets the rushers walk
+    past and the run loses on the spatial clause. This is the
+    decision drill of pre-positioned defence: not "should I defend?"
+    but "WHERE should I defend, given what intel says?".
+  robotics_analogue: >
+    Intel-driven facility hardening: a security operator is told the
+    threat axis (a perimeter breach is expected on the NORTH gate)
+    and must commit the available barriers / sensors / responders to
+    that axis. Spending the same budget on the SOUTH gate satisfies
+    no objective. This pack tests whether the policy converts a
+    textual directional cue into a CORRECT spatial commitment.
+  benchmark_anchor:
+    - 'ERQA spatial commit'
+    - 'MicroRTS terrain-aware defense'
+    - 'military pre-positioned defense'
+    - 'intel-driven facility hardening'
+  author: openra-bench
+
+# rush-hour-arena (128×40, playable x∈[2..126], y∈[2..38]). Agent
+# base at (20, 20) with the fact + tent + powr + 4 starter e1s
+# pre-placed (so 3 pbox can build immediately — pbox needs tent which
+# needs powr — and the throughput SLA `own_units_gte:3` is trivially
+# satisfied at start; the rush will erode it unless the NORTH lane is
+# covered). The scripted `rusher` bot concentrates its whole band on
+# the agent centroid (~8-tick interval, see scripted_bot.rs::Rusher)
+# — declared NORTH of the base, so the band charges SOUTH straight at
+# the fact and is intercepted by a NORTH-placed pbox triple.
+base_map: rush-hour-arena
+
+# Pack-wide budget — funds exactly the intended NORTH-pbox triple
+# (3 × 600cr = 1800cr) with a small buffer (~600) for any
+# replacement e1 the agent decides to queue. Spamming pbox in the
+# wrong direction burns the same budget without satisfying the
+# NORTH region clause.
+starting_cash: 2400
+
+base:
+  agent:
+    faction: allies
+  # Relentless concentrated charge at the agent centroid every
+  # ~8 ticks — the canonical rush-defence opponent. The bot's
+  # spawn position (NORTH for easy/medium, NORTH+SOUTH on hard) is
+  # the declared intel the model gets in the brief.
+  enemy:
+    faction: soviet
+    bot_type: rusher
+  tools:
+    - observe
+    - build
+    - place_building
+    - move_units
+    - attack_unit
+    - attack_move
+    - stop
+  planning: true
+  # Re-decide the instant a rusher unit is spotted at the lane mouth
+  # or a defender is lost — defence commitment is reactive.
+  interrupts:
+    enemy_unit_spotted: true
+    own_unit_destroyed: true
+  termination:
+    max_ticks: 12000
+  actors:
+    # Base-pack defaults; each level overrides with the spawn-specific
+    # layout. (Anti-empty-actors sanity for the loader.)
+    - {type: fact, owner: agent, position: [20, 20]}
+
+levels:
+  # ── EASY ── the bare directional-commit skill. A LIGHT rusher push
+  # (3 e1) comes from the NORTH (spawn at (20, 6)). The model is told
+  # in the brief "rushers will come from the NORTH" and must place
+  # three pillboxes in the NORTH region of its base (around (20, 14),
+  # radius 6). The starting 4 defenders survive the light push so
+  # own_units_gte:3 holds; the deadline is forgiving but real.
+  # max_turns 66 → reachable tick 93+90·65 = 5943 ≥ 5402 even with
+  # interrupts firing (per-turn step shrinks below 90 ticks when an
+  # interrupt fires; the empirical floor on this pack is ~86 t/turn,
+  # so 66 turns × 86 ≈ 5676 still clears the 5401 deadline).
+  easy:
+    description: >
+      INTEL: the enemy will attack from the NORTH. You start with a
+      construction yard, a barracks, a power plant, and four rifle
+      defenders at (20, 20). Build at least THREE pillboxes (pbox)
+      and place them in the NORTH region of your base (within radius
+      6 of (20, 14)) — that is, BETWEEN your base and the enemy's
+      approach. Keep your construction yard standing AND ≥3 of your
+      own units alive. Win before tick 5400. Placing pillboxes south
+      of your base does not satisfy the NORTH-region clause; building
+      no pillboxes never reaches the count; stalling loses on the
+      clock.
+    overrides:
+      actors:
+        # Agent base — fact at the centre, tent + powr supporting
+        # so the pbox tech chain is satisfied from turn 1 (no
+        # waiting on powr→tent before pbox). Tent placed WEST of the
+        # fact, powr SOUTH; both well clear of the NORTH defence
+        # region so a NORTH-placed pbox triple is unobstructed.
+        - {type: fact, owner: agent, position: [20, 20]}
+        - {type: tent, owner: agent, position: [16, 20]}
+        - {type: powr, owner: agent, position: [20, 24]}
+        # Four starter defenders south of the base (away from the
+        # NORTH lane mouth) — they survive a light push and satisfy
+        # `own_units_gte:3` even if one dies; positioning them away
+        # from the lane avoids the auto-target-fire complication.
+        - {type: e1, owner: agent, position: [22, 24], stance: 2}
+        - {type: e1, owner: agent, position: [24, 24], stance: 2}
+        - {type: e1, owner: agent, position: [22, 26], stance: 2}
+        - {type: e1, owner: agent, position: [24, 26], stance: 2}
+        # Light rusher push from the NORTH — 3 e1 at (20, 6).
+        # The rusher bot drives them straight at the agent
+        # centroid (the fact at 20,20); a NORTH pbox triple at
+        # y≈12..16 intercepts them on the way.
+        - {type: e1, owner: enemy, position: [20, 6], stance: 3, count: 3}
+        # Unarmed high-HP enemy marker far east — keeps the episode
+        # alive past the rush, so the win/fail predicate has time
+        # to evaluate (anti-DRAW per CLAUDE.md footgun).
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - building_count_gte: {type: pbox, n: 3}
+        - building_in_region: {type: pbox, x: 20, y: 14, radius: 6, count: 3}
+        - has_building: fact
+        - own_units_gte: 3
+        - within_ticks: 5400
+    fail_condition:
+      any_of:
+        - after_ticks: 5401
+        - not: {has_building: fact}
+        - not: {own_units_gte: 1}
+    max_turns: 66
+
+  # ── MEDIUM ── +1 controlled variable: a STRONGER northern push
+  # (5 e1 + 1 e3). The starter 4 defenders can no longer absorb the
+  # rush on their own — a NORTH pbox triple is REQUIRED to blunt the
+  # rocket soldier (e3 splash) before it ploughs through the
+  # defenders. Wrong-direction pbox (SOUTH) leaves the NORTH lane
+  # naked, the e3 kills the defenders, `own_units_gte:3` fails AND
+  # `building_in_region` fails ⇒ double LOSS path.
+  # max_turns 62 → reachable tick 5583 ≥ 5402.
+  medium:
+    description: >
+      INTEL: the enemy will attack from the NORTH. You start with a
+      construction yard, a barracks, a power plant, and four rifle
+      defenders at (20, 20). A stronger northern push — 5 rifle
+      infantry and 1 rocket soldier — will charge your base. Build
+      at least THREE pillboxes (pbox) and place all three in the
+      NORTH region of your base (within radius 6 of (20, 14)). Keep
+      the construction yard standing AND ≥3 of your own units alive
+      before tick 5400. Placing pillboxes south of your base does
+      not satisfy the NORTH-region clause AND leaves the northern
+      lane naked (the rocket soldier ploughs through the defenders);
+      building no pillboxes loses on both counts; stalling loses on
+      the clock.
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [20, 20]}
+        - {type: tent, owner: agent, position: [16, 20]}
+        - {type: powr, owner: agent, position: [20, 24]}
+        - {type: e1, owner: agent, position: [22, 24], stance: 2}
+        - {type: e1, owner: agent, position: [24, 24], stance: 2}
+        - {type: e1, owner: agent, position: [22, 26], stance: 2}
+        - {type: e1, owner: agent, position: [24, 26], stance: 2}
+        # Stronger northern push: 5 e1 + 1 e3. The e3 is the
+        # discriminator — it has splash + AT damage; a defender-only
+        # screen cannot kill it before it bursts the screen.
+        - {type: e1, owner: enemy, position: [20, 6], stance: 3, count: 5}
+        - {type: e3, owner: enemy, position: [22, 6], stance: 3, count: 1}
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - building_count_gte: {type: pbox, n: 3}
+        - building_in_region: {type: pbox, x: 20, y: 14, radius: 6, count: 3}
+        - has_building: fact
+        - own_units_gte: 3
+        - within_ticks: 5400
+    fail_condition:
+      any_of:
+        - after_ticks: 5401
+        - not: {has_building: fact}
+        - not: {own_units_gte: 1}
+    max_turns: 66
+
+  # ── HARD ── +1 controlled variable: TWO spawn_point groups — the
+  # AGENT base round-robins between a NORTH-staged base (centre
+  # (20, 12), enemy comes from y≈4) and a SOUTH-staged base (centre
+  # (20, 28), enemy comes from y≈36). The intel rotates accordingly:
+  # for the NORTH base, "fortify NORTH" means defend at (20, 6)
+  # (between the base and the enemy north of it); for the SOUTH
+  # base, "fortify SOUTH" means defend at (20, 34) (between the
+  # base and the enemy south of it). The win predicate uses `any_of`
+  # over the two correct region orientations — the agent must place
+  # its pbox triple on the lane that matches its OWN spawn (a
+  # NORTH-base pbox triple does NOT satisfy the SOUTH-base region).
+  # The rusher hits from BOTH latitudes (each spawn faces the side
+  # matching its base — see comment on enemy actors below).
+  # max_turns 62 → reachable tick 5583 ≥ 5402.
+  hard:
+    description: >
+      INTEL: the enemy will attack from the side FACING your base —
+      from the NORTH if your base is in the NORTH half, from the
+      SOUTH if your base is in the SOUTH half. Identify your base's
+      latitude from the observation, then build at least THREE
+      pillboxes (pbox) and place all three BETWEEN your base and the
+      threat — within radius 6 of either (20, 6) (if your base is at
+      y=12) or (20, 34) (if your base is at y=28). Keep the
+      construction yard standing AND ≥3 of your own units alive
+      before tick 5400. Defending on the WRONG side (the side away
+      from your base's threat) does not satisfy the region clause
+      AND leaves the threat axis naked; building no pillboxes loses
+      both clauses; stalling loses on the clock.
+    overrides:
+      actors:
+        # ── NORTH spawn (spawn_point 0) — base centred at (20, 12).
+        # Defence region for THIS spawn: (20, 6) r 5 (between the
+        # base and the rusher band north of it at y=4).
+        - {type: fact, owner: agent, position: [20, 12], spawn_point: 0}
+        - {type: tent, owner: agent, position: [16, 12], spawn_point: 0}
+        - {type: powr, owner: agent, position: [20, 16], spawn_point: 0}
+        - {type: e1, owner: agent, position: [22, 16], stance: 2, spawn_point: 0}
+        - {type: e1, owner: agent, position: [24, 16], stance: 2, spawn_point: 0}
+        - {type: e1, owner: agent, position: [22, 18], stance: 2, spawn_point: 0}
+        - {type: e1, owner: agent, position: [24, 18], stance: 2, spawn_point: 0}
+        # ── SOUTH spawn (spawn_point 1) — base centred at (20, 28).
+        # Defence region for THIS spawn: (20, 34) r 5 (between the
+        # base and the rusher band south of it at y=36).
+        - {type: fact, owner: agent, position: [20, 28], spawn_point: 1}
+        - {type: tent, owner: agent, position: [16, 28], spawn_point: 1}
+        - {type: powr, owner: agent, position: [20, 24], spawn_point: 1}
+        - {type: e1, owner: agent, position: [22, 22], stance: 2, spawn_point: 1}
+        - {type: e1, owner: agent, position: [24, 22], stance: 2, spawn_point: 1}
+        - {type: e1, owner: agent, position: [22, 24], stance: 2, spawn_point: 1}
+        - {type: e1, owner: agent, position: [24, 24], stance: 2, spawn_point: 1}
+        # Enemy rushers — CLAUDE.md: enemy actors WITHOUT a
+        # spawn_point are placed regardless of the chosen agent
+        # group, so we declare BOTH a north and a south rush band.
+        # The `rusher` bot charges the agent centroid; whichever
+        # spawn is active, the matching-side band is the immediate
+        # threat (the opposite band has further to walk and the
+        # matching-side correct pbox triple will already be
+        # absorbing the lead band by the time the far band closes).
+        - {type: e1, owner: enemy, position: [20, 4],  stance: 3, count: 4}
+        - {type: e3, owner: enemy, position: [22, 4],  stance: 3, count: 1}
+        - {type: e1, owner: enemy, position: [20, 36], stance: 3, count: 4}
+        - {type: e3, owner: enemy, position: [22, 36], stance: 3, count: 1}
+        - {type: fact, owner: enemy, position: [120, 20]}
+    # Two CORRECT region orientations — the pbox triple must sit
+    # between THIS spawn's base and THIS spawn's matching rush band.
+    win_condition:
+      all_of:
+        - building_count_gte: {type: pbox, n: 3}
+        - any_of:
+            - building_in_region: {type: pbox, x: 20, y: 6,  radius: 5, count: 3}
+            - building_in_region: {type: pbox, x: 20, y: 34, radius: 5, count: 3}
+        - has_building: fact
+        - own_units_gte: 3
+        - within_ticks: 5400
+    fail_condition:
+      any_of:
+        - after_ticks: 5401
+        - not: {has_building: fact}
+        - not: {own_units_gte: 1}
+    max_turns: 66

tests/test_def_position_expected_direction.py

@@ -0,0 +1,339 @@
+"""def-position-expected-direction scenario pack, full loop on Rust.
+
+REASONING capability — DEFENSE POSITIONING BASED ON DECLARED THREAT
+DIRECTION. The model is TOLD where the enemy will attack from
+(the objective brief states the intel: "rushers from the NORTH").
+The decision is purely one of SPATIAL COMMITMENT: invest the
+defence budget on the CORRECT lane and the rush is blunted; commit
+the same budget on the WRONG lane (SOUTH) and the rushers walk past,
+the deadline expires (the wrong-direction pbox cannot satisfy the
+NORTH region clause), and the run loses. Building no defences at
+all also loses (no pbox).
+
+The win predicate makes the directional axis load-bearing:
+
+* `building_count_gte:{pbox, 3}` ⇒ three pillboxes total (forces a
+  real defence commitment, not a token pbox);
+* `building_in_region:{pbox, NORTH_centre, r=6, 3}` ⇒ ALL THREE must
+  sit in the NORTH region — a SOUTH-built triple cannot satisfy it;
+* `has_building: fact` ⇒ the construction yard still stands;
+* `own_units_gte: 3` ⇒ the throughput SLA (the four pre-placed
+  defenders must mostly survive);
+* `within_ticks: 5400` paired with `after_ticks: 5401` ⇒ a non-
+  finisher is a real reachable timeout LOSS (max_turns 62 reaches
+  tick 5583 in interrupt mode), never a draw.
+
+These tests prove deterministically (no model / no network) that:
+
+* the intended NORTH-pbox triple WINS every level + every hard seed;
+* stall, build-defences-SOUTH (wrong direction), and build-no-
+  defences ALL LOSE every level + every hard seed (a real LOSS,
+  never a draw);
+* `after_ticks` is reachable inside `max_turns`;
+* the hard tier defines ≥2 spawn_point groups so the threat axis
+  rotates by seed (single-cell memorisation cannot generalise).
+"""
+
+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-position-expected-direction.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+
+# ── helpers ──────────────────────────────────────────────────────────
+
+
+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"])
+
+
+# ── scripted policies ────────────────────────────────────────────────
+
+
+def stall(rs, C):
+    """Observe-only. Never builds anything; never satisfies the pbox
+    count or the region clauses → reachable timeout LOSS."""
+    return [C.observe()]
+
+
+def make_intended():
+    """Build THREE pbox in the NORTH region of the agent base. The
+    NORTH side is `fy - 6` from the base (for easy/medium the base
+    is at y=20 so pbox at y≈14; for the hard NORTH spawn at y=12
+    pbox at y≈6; for the hard SOUTH spawn at y=28 pbox at y≈34).
+    Detects spawn by reading fact y and picks the side AWAY from
+    the centre (rushers come from the OUTSIDE on hard; on easy/
+    medium they come from the NORTH so the centre IS the rush
+    direction)."""
+
+    def policy(rs, C):
+        own_b = rs.get("own_buildings") or []
+        types = [b.get("type") for b in own_b]
+        pbox_count = sum(1 for t in types if t == "pbox")
+        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
+        # Pick the defence side: for easy/medium fact at y=20 →
+        # NORTH lane (fy-6 = 14). For hard NORTH spawn (fy=12) →
+        # NORTH (fy-6 = 6). For hard SOUTH spawn (fy=28) → SOUTH
+        # (fy+6 = 34). Heuristic: if fact y is in the SOUTH half
+        # (y>20), defend SOUTH; otherwise defend NORTH.
+        if fy > 20:
+            target_y = fy + 6  # SOUTH of base
+        else:
+            target_y = fy - 6 if fy >= 12 else fy - 6  # NORTH of base
+        cmds = []
+        if pbox_count < 3:
+            if prod_items.count("pbox") + pbox_count < 3:
+                cmds.append(C.build("pbox"))
+            # Stagger placement so 3 pbox sit in a tight cluster on
+            # the threat lane (all within radius 6 of (fx, target_y)).
+            dx = -2 + 2 * pbox_count
+            cmds.append(
+                C.place_building("pbox", fx + dx, target_y)
+            )
+        if not cmds:
+            cmds.append(C.observe())
+        return cmds
+
+    return policy
+
+
+def make_defenses_south():
+    """Build THREE pbox in the WRONG region (the SOUTH side of the
+    base when the intel says NORTH, and vice versa for the hard SOUTH
+    spawn). Satisfies `building_count_gte:pbox,3` but NEVER the
+    `building_in_region` NORTH clause ⇒ deadline LOSS — AND the
+    NORTH lane is left naked so the rusher band tears through the
+    starter defenders (additional LOSS path on `own_units_gte`)."""
+
+    def policy(rs, C):
+        own_b = rs.get("own_buildings") or []
+        types = [b.get("type") for b in own_b]
+        pbox_count = sum(1 for t in types if t == "pbox")
+        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
+        # WRONG side: invert the intended heuristic.
+        if fy > 20:
+            wrong_y = fy - 6  # NORTH of a SOUTH base ⇒ wrong
+        else:
+            wrong_y = fy + 6  # SOUTH of a NORTH base ⇒ wrong
+        cmds = []
+        if pbox_count < 3:
+            if prod_items.count("pbox") + pbox_count < 3:
+                cmds.append(C.build("pbox"))
+            dx = -2 + 2 * pbox_count
+            cmds.append(
+                C.place_building("pbox", fx + dx, wrong_y)
+            )
+        if not cmds:
+            cmds.append(C.observe())
+        return cmds
+
+    return policy
+
+
+def no_defenses(rs, C):
+    """Build no pillboxes ever. Never satisfies `building_count_gte:
+    pbox,3` ⇒ reachable timeout LOSS. (Also typically dies on
+    `own_units_gte` as the rush eats the defenders.)"""
+    # Burn the budget on extra power plants — proves the agent had
+    # cash to spend, just spent it on the wrong category.
+    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)]
+    n_powr = sum(1 for b in own_b if b.get("type") == "powr")
+    xy = _fact_xy(rs)
+    if xy is None:
+        return [C.observe()]
+    fx, fy = xy
+    cmds = []
+    if n_powr < 5 and "powr" not in prod_items:
+        cmds.append(C.build("powr"))
+        cmds.append(
+            C.place_building("powr", fx - 4, fy + 2 + n_powr)
+        )
+    if not cmds:
+        cmds.append(C.observe())
+    return cmds
+
+
+# ── scenario-shape invariants ────────────────────────────────────────
+
+
+def test_pack_compiles_with_three_levels_and_rusher_bot():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "def-position-expected-direction"
+    assert pack.meta.capability == "reasoning"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+    # Required-by-spec benchmark anchors.
+    anchors = pack.meta.benchmark_anchor
+    assert any("ERQA" in a for a in anchors), anchors
+    assert any("MicroRTS" in a for a in anchors), anchors
+    assert any("military" in a.lower() for a in anchors), anchors
+    assert any("intel" in a.lower() for a in anchors), anchors
+    # Rusher bot wired through to the engine for every level.
+    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"
+    )
+
+
+@pytest.mark.parametrize("level", LEVELS)
+def test_every_level_enforces_pbox_count_and_region(level):
+    """The directional axis must be load-bearing: the win condition
+    must require BOTH ≥3 pbox AND those pbox in the correct region."""
+    c = compile_level(load_pack(PACK), level)
+    win = c.win_condition.model_dump(exclude_none=True)
+    flat = str(win)
+    assert "building_count_gte" in flat and "pbox" in flat, win
+    assert "building_in_region" in flat, win
+    # The placement region must be NORTH-of-base (low y) on
+    # easy/medium, and `any_of` over NORTH+SOUTH on hard.
+    region_ys = []
+
+    def walk(node):
+        if isinstance(node, dict):
+            if "building_in_region" in node:
+                v = node["building_in_region"]
+                if (v or {}).get("type") == "pbox":
+                    region_ys.append(int(v["y"]))
+            for v in node.values():
+                walk(v)
+        elif isinstance(node, list):
+            for v in node:
+                walk(v)
+
+    walk(win)
+    assert region_ys, win
+    if level == "hard":
+        # hard must use any_of over the two correct region orientations.
+        assert "any_of" in flat, win
+        assert set(region_ys) == {6, 34}, region_ys
+    else:
+        # easy/medium fortify NORTH of base (y=20) ⇒ region centre y=14.
+        assert region_ys == [14], region_ys
+
+
+def test_hard_has_two_spawn_point_groups():
+    """Hard-tier contract: ≥2 distinct seed-driven spawn_point groups
+    so the threat axis rotates by seed (anti-memorisation)."""
+    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).
+    for a in c.scenario.actors:
+        x, y = a.position
+        assert 2 <= x <= 126 and 2 <= y <= 38, (a.type, a.position)
+
+
+# ── solvency: intended WINS every level + every hard seed ────────────
+
+
+@pytest.mark.parametrize("level", LEVELS)
+def test_intended_north_pbox_triple_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 NORTH-pbox-triple play "
+            f"must WIN; got {r.outcome} "
+            f"(tick={r.signals.game_tick}, "
+            f"lost={r.signals.units_lost}, "
+            f"buildings={r.signals.own_buildings})"
+        )
+
+
+# ── no-cheat: every wrong / lazy policy LOSES (real LOSS, not draw) ──
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize(
+    "policy_name,policy_factory",
+    [
+        ("stall", lambda: stall),
+        ("defenses_south", make_defenses_south),
+        ("no_defenses", lambda: no_defenses),
+    ],
+)
+def test_lazy_and_wrong_direction_policies_lose_every_level_and_seed(
+    level, policy_name, policy_factory
+):
+    """Stall (no pbox), defenses-SOUTH (3 pbox in WRONG region), and
+    no-defenses (no pbox, just power) must ALL LOSE on every level +
+    every seed — a real reachable timeout LOSS, never a 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} "
+            f"(tick={r.signals.game_tick}, "
+            f"lost={r.signals.units_lost}, "
+            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) == (b.outcome, b.turns), (
+        "same seed must be deterministic"
+    )

tests/test_hard_tier.py

@@ -152,6 +152,13 @@ UPGRADED = [
     # main session.
     "lh-opening-to-tech-to-army",
     "lh-tech-pivot-attack",
+    # Wave-5 Group G long-horizon: 5+ ordered checkpoints chained via
+    # the Wave-2 `then:` composite (PERT critical path / PlanBench
+    # long-sequencing anchor). Hard defines 2 agent spawn_point groups
+    # (NORTH base y=14..18 / SOUTH base y=22..26) round-robined by
+    # seed; the per-seed base latitude flips so a memorised 6-phase
+    # opening cannot generalise.
+    "lh-multi-checkpoint-5-plus",
     "mfb-tech-base-vs-economy-base",
     "combat-harass-balanced-hit-and-run",
     "tech-aggro-all-in",
@@ -201,6 +208,119 @@ UPGRADED = [
     # regardless (enemy actors don't honour spawn_point — CLAUDE.md),
     # so a memorised pbox layout from one spawn does not generalise.
     "expansion-turtle-1-base-fortified",
+    # Wave-5 Group G long-horizon "secure-expand-with-tech" pack (SC2
+    # secure-expand multi-base macro / PlanBench multi-stage credit
+    # assignment anchor). Strict 3-phase chain (pbox×3 → weap → 2nd
+    # fact in east region) on medium; 4-phase on hard (+ second proc).
+    # Hard defines two agent spawn_point groups (NORTH y=22 / SOUTH
+    # y=38) round-robined by seed; two patrol bands hit BOTH latitudes
+    # (enemy actors don't honour spawn_point — CLAUDE.md) so a memorised
+    # base layout cannot generalise.
+    "lh-defense-tech-second-base",
+    # Wave-5 Group C reasoning seed — central reserve doctrine /
+    # chess-piece centralization / military QRF. Hard tier defines two
+    # agent spawn_point groups (centre column x=40 / x=50) round-
+    # robined by seed so the reserve's exact staging cell varies but
+    # both remain equidistant from N/S flanks; THREE simultaneous
+    # rush bands (N/S/E) always place (enemy actors don't honour
+    # spawn_point — CLAUDE.md), so a single committed-flank policy
+    # cannot generalise and the centre-then-react doctrine is the
+    # only winning play.
+    "def-pre-position-mobile-reserve",
+    # Wave-5 Group C reasoning pack — ERQA spatial commit / MicroRTS
+    # terrain-aware defence / military pre-positioned defence /
+    # intel-driven facility hardening anchor. The model is TOLD where
+    # the enemy will attack from; the decision is purely spatial
+    # commitment (build the pbox triple on the CORRECT lane). Hard
+    # tier defines two agent spawn_point groups (NORTH base y=12 /
+    # SOUTH base y=28) round-robined by seed and the win clause is
+    # `any_of` over the two correct region orientations — the
+    # threat-axis intel rotates with the spawn so "NORTH of YOUR
+    # base" flips per seed; a memorised single-cell pbox layout
+    # cannot generalise.
+    "def-position-expected-direction",
+    # Wave-5 Group N coordination pack — SC2 triple-prong assault /
+    # military convergent (pincer) attack / envelopment doctrine. Hard
+    # tier defines two agent spawn_point groups (squads staged
+    # NORTH/WEST/SOUTH in group 0, NORTH/EAST/SOUTH in group 1)
+    # round-robined by seed; the third squad's ingress bearing flips
+    # per seed and a single memorised opening cannot generalise. The
+    # defender cluster is symmetric so both spawns face the same
+    # convergent geometry from different start corners.
+    "coord-converge-on-target",
+    # Wave-5 Group N coordination pack — SC2 attack-wave timing /
+    # SMAC relay strike / military overlapping fires (bound-and-bound)
+    # anchor. Squad A (3× e3 rockets) softens the enemy 2tnk cluster
+    # FIRST; Squad B (3× 2tnk) follows up to mop up the e1 survivors.
+    # Hard tier defines two agent spawn_point groups (NORTH staging
+    # y=12..18 / SOUTH staging y=28..34) round-robined by seed; the
+    # central enemy cluster (6× 2tnk + 6× e1 at y=20) is symmetric
+    # across the map's mid-latitude so either staging faces an
+    # equivalent relay decision but no memorised approach corridor
+    # generalises across seeds.
+    "coord-relay-attack",
+    # Wave-5 Group G long-horizon "marathon survival" pack — lmgame-Bench
+    # multi-hour endurance / SC2LE full-game extended testing / SRE
+    # extended on-call anchor. Hard tier defines two agent spawn_point
+    # groups (NORTH y=12 / SOUTH y=28) round-robined by seed; six
+    # staggered hunt squads always place at BOTH latitudes (enemy
+    # actors don't honour spawn_point — CLAUDE.md), so a memorised
+    # pbox-lane / starting cell cannot generalise across seeds.
+    "lh-100-turn-marathon-survival",
+    # Wave-5 Group F reasoning pack — SC2 mass-vs-elite army composition
+    # / industrial mass-production vs craftsmanship / military
+    # quantity-vs-quality doctrine / OR unit-composition optimisation
+    # anchor. Hard tier defines two agent spawn_point groups (NORTH
+    # base y=10 / SOUTH base y=30) round-robined by seed; TWO enemy
+    # garrisons of OPPOSING composition (anti-INFANTRY at the north
+    # latitude, anti-VEHICLE at the south latitude) always place
+    # (enemy actors don't honour spawn_point — CLAUDE.md), so the
+    # right counter (mass-cheap rifles vs elite heavy tanks) flips
+    # per seed and a single memorised opening cannot generalise.
+    "econ-quantitative-vs-qualitative-spend",
+    # Wave-5 Group N coord seed: SQUAD HANDOFF via Wave-2 `then:`
+    # composite + new `units_of_type_in_region_gte` predicate (type-
+    # filtered region count). Hard defines two agent spawn_point groups
+    # (NW staging y=5..12 / SW staging y=33..38) round-robined by seed;
+    # the four-leg alternating handoff (A→P1→B→P2→A→P3→B→P4) is
+    # symmetric across starts but the per-squad long-haul leg flips
+    # per seed so a memorised opening cannot generalise.
+    "coord-squad-handoff",
+    # Wave-5 Group G long-horizon reasoning seed — SC2 macro-then-
+    # multi-prong-attack / military operational planning (force build
+    # then theater assault) / PERT theater-wide ops sequencing.
+    # Two-phase plan: assemble ≥N medium tanks THEN raze TWO separated
+    # enemy fact (NE 130,15 + SE 130,45) in parallel. Hard tier defines
+    # two agent spawn_point groups (NORTH base y=18 / SOUTH base y=42)
+    # round-robined by seed; both enemy bases always place (enemy
+    # actors don't honour spawn_point — CLAUDE.md), so the "near" vs
+    # "far" front flips per seed and the per-prong assignment must be
+    # re-computed instead of memorised.
+    "lh-build-army-coordinate-multifront-attack",
+    # Wave-5 Group F turtle-recovery seed — SC2 turtle-back-to-economy
+    # / business bankruptcy turnaround / military rebuild-from-defeat /
+    # startup pivot-after-runway-crisis anchor. Agent starts with a
+    # minimum viable kit (fact + proc + 1 harv + 1 mine) and $0 cash;
+    # must commit to harvest first then reinvest into a war factory +
+    # 2nd/3rd harvester. Hard tier defines 2 agent spawn_point groups
+    # (NORTH base y=14 / SOUTH base y=26) round-robined by seed; each
+    # spawn has its own symmetric two-patch geometry so the harv
+    # routing flips per seed and a memorised "place weap at (8,18)"
+    # opening cannot generalise.
+    "econ-recover-from-zero-cash",
+    # Wave-5 Group C defense-topology pack — graph theory min-cut /
+    # military bunker placement / firewall topology at chokepoints /
+    # Lanchester defense concentration anchor. The win predicate makes
+    # the cluster-vs-spread topology decision load-bearing
+    # (`building_in_region` ≥ N out of `building_count_gte` ≥ M total).
+    # Hard tier defines two agent spawn_point groups (NORTH base y=10 /
+    # SOUTH base y=30) round-robined by seed; the rusher band is staged
+    # symmetrically at y=20 (enemies don't honour spawn_point — CLAUDE.md)
+    # and charges the agent centroid, so the cluster's required world
+    # cell is geographically distant from each base — a memorised
+    # relative-to-base placement that lands in the same world cell on
+    # every seed cannot generalise.
+    "def-tower-line-vs-cluster",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation