feat(scenario): rob-multiple-simultaneous-pressures — compound-incident triage (SC2 multi-front / ops triage anchor)

Wave-6 REASONING pack: agent must hold THREE pressures simultaneously
— defence (hunt charge on the fact), economy (raider tanks on the
harv patch), and tech (war factory by hard deadline). No single-axis
play wins.

Design highlights
- bot_type: hunt (each enemy unit attacks its OWN nearest agent
target). Two threat axes emerge from geometry — centre-line
tank raiders hunt the nearest harv, flanking infantry hunt the
base buildings — without needing two bot types.
- starting_cash 2000 = exactly the weap cost. The intended play
queues weap on turn 1 and tops up cash from the harvest loop;
pulling harvs home strands the EV bar (economy_value_gte: 1000)
which makes the harvest loop load-bearing through the raid.
- Tools: full set. Pre-placed: fact + proc + powr + 2 harv +
2 mines + 4 1tnk defenders (powr added so the proc/weap chain
has power per gamerules.rs prereqs).
- Hard tier: 2 spawn_point groups (NORTH y=14 / SOUTH y=26)
round-robined by seed; centre-line raiders + hunt squad face
the active spawn with equal pressure on either latitude.
- Anti-DRAW: unarmed enemy fact marker far east per CLAUDE.md
auto-done footgun.

Discrimination (scripted, all seeds 1..4 on every tier)
- stall (only observe) → LOSS (clock + harv-loss)
- focus-defence-skip-tech → LOSS (weap never built)
- focus-tech-lose-econ (no harvest) → LOSS (EV bar never met)
- intended multi-handle → WIN

Registered in tests/test_hard_tier.py::UPGRADED.

Smoke (Qwen/Qwen3.6-Plus, medium s=1): loss composite=0.1894 —
valid model discrimination on the simultaneous-pressure axis.

openra_bench/scenarios/packs/rob-multiple-simultaneous-pressures.yaml

@@ -0,0 +1,396 @@
+# rob-multiple-simultaneous-pressures — compound-incident triage
+#
+# REASONING capability — Wave-6 "multi-front simultaneous pressure"
+# pack. The agent must hold THREE pressures simultaneously, none of
+# which can be sequenced or paused:
+#
+#   1. DEFENCE — the agent fact is under a `hunt` charge that always
+#      picks the nearest agent target. Even if the harvesters die, the
+#      hunters keep coming for the fact / proc.
+#   2. ECONOMY — pre-placed harvesters (`harv`) work the patch east of
+#      the proc and are the closest agent target to the raider tanks
+#      lined up at the lane mouth. Stop harvesting and income stops;
+#      lose a harv and the win predicate breaks (harv≥1).
+#   3. TECH — a war factory (`weap`, cost 2000, prereq `proc`) must be
+#      built and standing by tick 5400. starting_cash 2000 covers the
+#      base weap exactly; the chain only closes if the harvesters keep
+#      running through the raid (so cash is in the tin when defence
+#      tightens). Skipping the tech to focus on combat fails the win.
+#
+# Real-world anchor: ops triage during a compound incident — multiple
+# system failures at once. SC2 multi-front simultaneous pressure. DR
+# multi-system failure response. The discriminating policies:
+#
+#   • stall (only observe): LOSS — no weap built, harvs don't deliver
+#     (`harvest` order needed each turn), eventually clock expires.
+#   • focus-defence-skip-tech (queue defenders, hold the line, never
+#     start weap): LOSS — weap never appears ⇒ the has_building:weap
+#     clause never latches ⇒ timeout LOSS via after_ticks.
+#   • focus-tech-lose-econ (queue weap immediately, pull defenders
+#     back to base, abandon the harvs / never issue harvest orders):
+#     LOSS — the post-weap EV bar (economy_value_gte: 1000) never
+#     latches because starting_cash 2000 is consumed by weap and
+#     the idle harvs add no income ⇒ timeout LOSS via after_ticks.
+#     (Lose-the-harv mode is also possible if the raiders reach
+#     the unprotected harvs, but the EV teeth bite first.)
+#   • intended multi-handle (keep harv ring on the patch, defenders
+#     intercept raiders, queue weap from turn 1, fund it with the
+#     harv income that keeps flowing): WIN.
+#
+# DESIGN
+# ──────
+# - bot_type: `hunt`. Each enemy unit attacks its OWN nearest agent
+#   target (Infantry / Vehicle / MCV / Building per scripted_bot.rs
+#   `foes()`). The TANK raiders are lined up directly east of the
+#   harv lane (their nearest agent target is the harv at the patch
+#   ⇒ economy harassment); the INFANTRY hunters are staged on
+#   FLANKING latitudes where the nearest agent target is the fact /
+#   proc / powr (⇒ base-hunt pressure). Same bot, two threat axes
+#   driven by geometry — the "raider for econ + hunt for base" of
+#   the spec is realised by positioning, not by two bot types.
+# - starting_cash: 2000 — exactly the weap cost. The intended play
+#   queues weap immediately and tops up cash from the running harv
+#   loop while the defenders intercept the raiders. Stalling lets
+#   the cash sit unused; spending it on defenders pre-empts weap.
+# - Tools: full set (observe + build + place_building + harvest +
+#   move_units + attack_unit + attack_move + stop). The pack tests
+#   simultaneous management, not tool restriction.
+# - Pre-placed: fact + proc + powr (power for the queue) + 2 harv +
+#   2 mines + 4 1tnk defenders. Powr is included because weap is
+#   queued from the Building list — without power the build is
+#   silently slow / blocked (CLAUDE.md underpowered-queue footgun).
+#   The spec lists "fact + proc + 2 harv + 2 mines + 4 defenders" as
+#   the core seed; powr is treated as core infrastructure (proc
+#   itself needs powr per gamerules.rs).
+# - Anti-DRAW: unarmed enemy `fact` marker far east — the engine
+#   auto-`done`s on enemy-MustBeDestroyed wipe before the win/fail
+#   check otherwise (CLAUDE.md auto-done footgun).
+#
+# Engine facts used (CLAUDE.md / gamerules.rs):
+#   - weap cost 2000, prereq `proc` (pre-placed ⇒ available T1).
+#   - proc prereq is `powr` (pre-placed ⇒ proc functions).
+#   - hunt bot's foes() includes Building, so flanking infantry that
+#     have the fact as their nearest target attack the base.
+#   - `harv` Command.harvest(uid, mx, my) per turn keeps the harvest
+#     loop running; idle harvs ⇒ no income.
+#   - place_building has no adjacency requirement; weap can be
+#     placed anywhere in-bounds (we pre-pick a safe spot via the
+#     description's coordinate hint).
+#   - hard tier: ≥2 agent spawn_point groups (UPGRADED contract,
+#     tests/test_hard_tier.py) — north-flank vs south-flank base.
+#
+# Validate (no model / no network):
+#   python3 -m pytest tests/test_rob_multiple_simultaneous_pressures.py -q
+
+meta:
+  id: rob-multiple-simultaneous-pressures
+  title: 'Compound Incident — Multi-Front Simultaneous Pressure (Defence + Economy + Tech)'
+  capability: reasoning
+  real_world_meaning: >
+    Ops triage during a compound incident — three independent failures
+    must be handled simultaneously, none of which can be sequenced or
+    paused. Your base is under a hunt charge (defence), the harvesters
+    feeding income are being raided (economy), and a tech objective
+    (war factory) must be completed before a hard deadline. Focusing
+    on any single pressure forfeits the others; the intended play
+    keeps all three loops running in parallel, funding the tech with
+    the harvest income that the defenders are simultaneously
+    protecting.
+  robotics_analogue: >
+    Disaster-recovery multi-system failure — a control room handles
+    a security event (perimeter under attack), a throughput event
+    (data pipeline workers under harassment), and a planned upgrade
+    (capability rollout) at the same time. Pausing the upgrade to
+    fight the security incident misses the rollout SLA; abandoning
+    the pipeline to harden the perimeter starves the upgrade of
+    resources. The capability under test is parallel-task triage
+    under genuine simultaneous pressure.
+  benchmark_anchor:
+    - 'SC2 multi-front simultaneous pressure'
+    - 'ops triage during compound incident'
+    - 'DR multi-system failure'
+    - 'military theater-wide simultaneous threats'
+  author: openra-bench
+
+base_map: rush-hour-arena
+# Exactly enough for the weap (cost 2000). The intended play funds
+# any extra defender / structure spend from the harvest loop income
+# that runs THROUGH the raid. Anything more than 2000 lets a
+# focus-defence policy buy out the threat without ever touching tech.
+starting_cash: 2000
+
+base:
+  agent:
+    faction: allies
+  # `hunt`: each enemy unit attacks its OWN nearest agent target
+  # (Infantry/Vehicle/MCV/Building). The geometry of the placed
+  # enemy units splits the pressure into two axes — tanks at the
+  # patch lane hunt the harvs (economy raid), flanking infantry
+  # hunt the fact/proc (base hunt).
+  enemy:
+    faction: soviet
+    bot_type: hunt
+  tools:
+    - observe
+    - build
+    - place_building
+    - harvest
+    - move_units
+    - attack_unit
+    - attack_move
+    - stop
+  planning: true
+  # No interrupts: fixed-cadence steps give the predictable
+  # ~90 ticks/turn we need to align the after_ticks 5401 fail
+  # clause with max_turns 61 (93+90·60=5493 ≥ 5401 ✓). Interrupt
+  # mode shortens the per-step advance and would make a stall
+  # episode draw before the deadline bites.
+  termination:
+    max_ticks: 12000
+  # Per-level actors via overrides — keeps the audit explicit for
+  # each tier's threat composition.
+  actors: []
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Bare three-pressure skill: ONE flanking hunt group (only the base
+  # pressure axis), pre-placed defenders blunt the raid mouth, weap
+  # is the sole tech clause. Stall / focus-defence-skip-tech /
+  # focus-tech-lose-econ all LOSE; the intended multi-handle WINS.
+  # max_turns 61 → reachable tick 93 + 90·60 = 5493 > 5401 ✓.
+  easy:
+    description: >
+      Compound incident. You hold a base on the west — Construction
+      Yard (fact at 10,18), refinery (proc at 8,18), power plant
+      (powr at 8,20), and 2 harvesters working an ore patch east of
+      the proc (mines at 24,16 and 24,22). Four light tank defenders
+      ring the patch at x=18. You start with $2000 — exactly enough
+      for a war factory. THREE pressures are live AT THE SAME TIME:
+      (1) DEFEND — a single hunt squad of 3 rifle infantry is staged
+          NORTH of the base; they charge whatever agent target is
+          nearest, including the fact.
+      (2) ECONOMY — one enemy tank (raider) is at the lane mouth
+          east of the patch; under the hunt bot it targets the
+          harvester nearest to it. If the harvs die the win breaks.
+      (3) TECH — you must have a war factory (weap, cost 2000, prereq
+          proc) standing by tick 5400.
+      Win = `weap` AND `proc` AND ≥1 harvester AND `fact` still
+      standing, before tick 5400. Stalling, focusing on defence and
+      skipping tech, and focusing on tech while abandoning the
+      harvesters all LOSE.
+    overrides:
+      actors:
+        # Agent base on the west — fact + proc + powr + 2 harv +
+        # 2 mines + 4 defenders per the pack core.
+        - {type: fact, owner: agent, position: [10, 18]}
+        - {type: proc, owner: agent, position: [8,  18]}
+        - {type: powr, owner: agent, position: [8,  20]}
+        - {type: harv, owner: agent, position: [14, 16]}
+        - {type: harv, owner: agent, position: [14, 22]}
+        - {type: mine, owner: neutral, position: [24, 16]}
+        - {type: mine, owner: neutral, position: [24, 22]}
+        # Four 1tnk defenders ringing the patch lane at x=18
+        # (between the harvs and the raider mouth). Tank-on-tank
+        # is required to actually kill a raider 1tnk (rifle e1 dies
+        # before it can do it).
+        - {type: '1tnk', owner: agent, position: [18, 16]}
+        - {type: '1tnk', owner: agent, position: [18, 22]}
+        - {type: '1tnk', owner: agent, position: [22, 18]}
+        - {type: '1tnk', owner: agent, position: [22, 20]}
+        # ECONOMY-RAID PRESSURE — 1 raider tank at the lane mouth.
+        # Its nearest agent target is the harv at (14,16) ⇒ raids the
+        # economy under hunt semantics.
+        - {type: '1tnk', owner: enemy, position: [60, 18]}
+        # BASE-HUNT PRESSURE — 3 e1 infantry staged on the NORTHERN
+        # flank. Their nearest agent target is fact/powr (no harv
+        # between them and the base from y=4), so under hunt the
+        # group charges the base buildings directly.
+        - {type: e1, owner: enemy, position: [40, 4], stance: 3, count: 3}
+        # Anti-DRAW: persistent unarmed enemy `fact` marker far east.
+        - {type: fact, owner: enemy, position: [120, 4]}
+    win_condition:
+      all_of:
+        - {has_building: weap}
+        - {has_building: proc}
+        - {unit_type_count_gte: {type: harv, n: 1}}
+        - {has_building: fact}
+        # ECONOMY teeth: post-weap residual EV bar. starting_cash 2000
+        # exactly funds the weap (cost 2000) ⇒ to clear this 1000-EV
+        # bar the harvesters MUST be in `harvest` mode through the
+        # raid so cash refills. A focus-tech policy that queues weap
+        # and pulls the harvs home (no harvest order) drains cash to
+        # 0 and never re-fills ⇒ this clause never latches ⇒ LOSS by
+        # the after_ticks fail clause.
+        - {economy_value_gte: 1000}
+        - {within_ticks: 5400}
+    # 5401 ≤ 93 + 90·60 = 5493 ⇒ deadline bites inside max_turns.
+    # Loss is reachable: clock OR fact razed OR harvs eradicated.
+    fail_condition:
+      any_of:
+        - {after_ticks: 5401}
+        - {not: {has_building: fact}}
+        - {not: {unit_type_count_gte: {type: harv, n: 1}}}
+    max_turns: 61
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 controlled variable vs easy: the raid axis now has TWO raider
+  # tanks (one at each patch latitude — the harv ring can't ignore
+  # either) AND the hunt squad is heavier (4× e1 + 1× e3). Same
+  # clock; the budget is still 2000 ⇒ no slack on the cash side.
+  medium:
+    description: >
+      The same compound incident, scaled up on both pressure axes.
+      Base layout unchanged (fact+proc+powr at the west, 2 harvs on
+      the patch east of proc, 4 light tank defenders on the ring).
+      Pressures:
+      (1) DEFEND — a heavier hunt squad of 4 rifle infantry + 1
+          rocket soldier (e3) on the northern flank charges the base.
+      (2) ECONOMY — TWO raider tanks are staged at the patch lane
+          mouth, one on each harv latitude (y=16 and y=22) — the
+          harv ring can't ignore either.
+      (3) TECH — war factory (`weap`) by tick 5400.
+      Win = `weap` AND `proc` AND ≥1 harvester AND `fact` standing
+      before tick 5400. Stall, focus-defence-skip-tech,
+      focus-tech-lose-econ all LOSE.
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 18]}
+        - {type: proc, owner: agent, position: [8,  18]}
+        - {type: powr, owner: agent, position: [8,  20]}
+        - {type: harv, owner: agent, position: [14, 16]}
+        - {type: harv, owner: agent, position: [14, 22]}
+        - {type: mine, owner: neutral, position: [24, 16]}
+        - {type: mine, owner: neutral, position: [24, 22]}
+        - {type: '1tnk', owner: agent, position: [18, 16]}
+        - {type: '1tnk', owner: agent, position: [18, 22]}
+        - {type: '1tnk', owner: agent, position: [22, 18]}
+        - {type: '1tnk', owner: agent, position: [22, 20]}
+        # ECONOMY-RAID — two raiders, one per harv latitude.
+        - {type: '1tnk', owner: enemy, position: [60, 16]}
+        - {type: '1tnk', owner: enemy, position: [60, 22]}
+        # BASE-HUNT — 4 e1 + 1 e3 on the northern flank.
+        - {type: e1, owner: enemy, position: [40, 4], stance: 3, count: 4}
+        - {type: e3, owner: enemy, position: [42, 4], stance: 3, count: 1}
+        # Anti-DRAW marker.
+        - {type: fact, owner: enemy, position: [120, 4]}
+    win_condition:
+      all_of:
+        - {has_building: weap}
+        - {has_building: proc}
+        - {unit_type_count_gte: {type: harv, n: 1}}
+        - {has_building: fact}
+        # See easy: post-weap EV bar makes the harvest loop load-
+        # bearing so focus-tech-lose-econ cannot satisfy the win.
+        - {economy_value_gte: 1000}
+        - {within_ticks: 5400}
+    fail_condition:
+      any_of:
+        - {after_ticks: 5401}
+        - {not: {has_building: fact}}
+        - {not: {unit_type_count_gte: {type: harv, n: 1}}}
+    max_turns: 61
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +2 controlled variables vs medium (per the spec "hunt + raider +
+  # tighter clock + 2 spawn groups"):
+  #   1. TIGHTER clock (within_ticks 4500; max_turns 51 → reachable
+  #      tick 93+90·50 = 4593 ≥ 4501 ✓). The tech window shrinks so a
+  #      sequenced "defend then tech" attempt runs out of clock.
+  #   2. TWO spawn_point groups (north y=14 base vs south y=26 base)
+  #      — the BASE LATITUDE flips by seed, so a single memorised
+  #      ring / weap placement cannot generalise. Both spawns face
+  #      the SAME enemy composition (enemy actors are not spawn-
+  #      filtered, per oramap.rs): the medium pack's 2 raider tanks
+  #      and one heavy hunt squad, plus a mirrored off-axis hunt
+  #      squad so the seed that lands on the off-axis flank still
+  #      gets a same-latitude charge (otherwise the off-axis flank
+  #      would have noticeably lighter pressure than the on-axis
+  #      one). Same composition as medium per axis — the discriminator
+  #      is clock-tightness + spawn variation, not enemy-count
+  #      escalation.
+  hard:
+    description: >
+      The compound incident on a tighter clock and a seed-varied
+      start. Your base stages from a seed-chosen latitude (NORTH
+      y=14 or SOUTH y=26) — both formations cover the same patch
+      column (mines at x=24, two per latitude). Pressures:
+      (1) DEFEND — a hunt squad of 4 rifle infantry + 1 rocket
+          soldier charges from the centre-line; whichever base
+          latitude you got is the one it heads for.
+      (2) ECONOMY — TWO raider tanks at the patch lane mouth on
+          the centre-line; they hunt the nearest harv (which is
+          always the active spawn's, since the off-axis spawn
+          isn't placed).
+      (3) TECH — war factory (`weap`) by tick 4500 (clock down from
+          5400).
+      Win = `weap` AND `proc` AND ≥1 harvester AND `fact` standing
+      before tick 4500. Stall, focus-defence-skip-tech,
+      focus-tech-lose-econ, and slow-multi-handle (over-budget on
+      clock) all LOSE.
+    overrides:
+      actors:
+        # Spawn 0 — NORTH base (y centered on 14). Four 1tnk
+        # defenders ring the two harv latitudes (12 and 16).
+        - {type: fact, owner: agent, position: [10, 14], spawn_point: 0}
+        - {type: proc, owner: agent, position: [8,  14], spawn_point: 0}
+        - {type: powr, owner: agent, position: [8,  16], spawn_point: 0}
+        - {type: harv, owner: agent, position: [14, 12], spawn_point: 0}
+        - {type: harv, owner: agent, position: [14, 16], spawn_point: 0}
+        - {type: '1tnk', owner: agent, position: [18, 12], spawn_point: 0}
+        - {type: '1tnk', owner: agent, position: [18, 16], spawn_point: 0}
+        - {type: '1tnk', owner: agent, position: [22, 13], spawn_point: 0}
+        - {type: '1tnk', owner: agent, position: [22, 15], spawn_point: 0}
+        # Spawn 1 — SOUTH base (y centered on 26). Mirror of spawn 0
+        # at y=24/28.
+        - {type: fact, owner: agent, position: [10, 26], spawn_point: 1}
+        - {type: proc, owner: agent, position: [8,  26], spawn_point: 1}
+        - {type: powr, owner: agent, position: [8,  28], spawn_point: 1}
+        - {type: harv, owner: agent, position: [14, 24], spawn_point: 1}
+        - {type: harv, owner: agent, position: [14, 28], spawn_point: 1}
+        - {type: '1tnk', owner: agent, position: [18, 24], spawn_point: 1}
+        - {type: '1tnk', owner: agent, position: [18, 28], spawn_point: 1}
+        - {type: '1tnk', owner: agent, position: [22, 25], spawn_point: 1}
+        - {type: '1tnk', owner: agent, position: [22, 27], spawn_point: 1}
+        # Mines — neutrals are NOT spawn-filtered (per CLAUDE.md);
+        # one set per latitude so each spawn has a workable patch
+        # on each of its two harv rows.
+        - {type: mine, owner: neutral, position: [24, 12]}
+        - {type: mine, owner: neutral, position: [24, 16]}
+        - {type: mine, owner: neutral, position: [24, 24]}
+        - {type: mine, owner: neutral, position: [24, 28]}
+        # ECONOMY-RAID — TWO raider tanks (matching medium) at the
+        # patch lane mouth. Placed at the centre-line latitudes
+        # (y=18, y=22) so they sit equidistant from the two
+        # possible base latitudes (y=14 north / y=26 south) and the
+        # hunt bot resolves each raider to whichever harv is
+        # currently nearest. (Enemy actors are not spawn-filtered.)
+        - {type: '1tnk', owner: enemy, position: [60, 18]}
+        - {type: '1tnk', owner: enemy, position: [60, 22]}
+        # BASE-HUNT — one heavy hunt squad (matching medium: 4 e1 +
+        # 1 e3) at the centre-line so it charges the nearest base
+        # buildings whichever latitude the agent is on (the e1 at
+        # the centre is ≤12 cells from either spawn's fact, and the
+        # rotation between spawns is the seed-driven variation).
+        - {type: e1, owner: enemy, position: [40, 20], stance: 3, count: 4}
+        - {type: e3, owner: enemy, position: [42, 20], stance: 3, count: 1}
+        # Anti-DRAW marker.
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {has_building: weap}
+        - {has_building: proc}
+        - {unit_type_count_gte: {type: harv, n: 1}}
+        - {has_building: fact}
+        # See easy: post-weap EV bar makes the harvest loop load-
+        # bearing so focus-tech-lose-econ cannot satisfy the win.
+        # Bar held at 1000 (same as easy/medium) — the discriminator
+        # on hard is the tighter clock + spawn variation, not a
+        # harder EV target.
+        - {economy_value_gte: 1000}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {has_building: fact}}
+        - {not: {unit_type_count_gte: {type: harv, n: 1}}}
+    max_turns: 51

tests/test_hard_tier.py

@@ -486,6 +486,12 @@ UPGRADED = [
     # assignment flips per seed and a memorised "which jeep to which
     # corner" plan cannot generalise.
     "scout-map-reveal-percent-target",
+    # Wave-6 compound-incident triage pack (defence + economy + tech
+    # under simultaneous pressure). Hard tier defines two agent
+    # spawn_point groups (NORTH y=14 / SOUTH y=26) round-robined by
+    # seed; the centre-line raider tanks and centre-line hunt squad
+    # face the seed-chosen latitude with equal pressure.
+    "rob-multiple-simultaneous-pressures",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation

tests/test_rob_multiple_simultaneous_pressures.py

@@ -0,0 +1,437 @@
+"""rob-multiple-simultaneous-pressures — compound-incident triage.
+
+Wave-6 REASONING pack: three live pressures must be handled at once —
+DEFENCE (hunt charge on the fact), ECONOMY (raider tanks on the harv
+patch), TECH (`weap` by deadline). Single-axis policies cannot win;
+the intended multi-handle keeps all three loops running in parallel.
+
+Bar (per CLAUDE.md): the intended multi-handle policy must WIN on
+every (level, seed); stall / focus-defence-skip-tech / focus-tech-
+lose-econ must LOSE on every (level, seed). No draws.
+"""
+
+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 / "rob-multiple-simultaneous-pressures.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 == "rob-multiple-simultaneous-pressures"
+    assert pack.meta.capability == "reasoning"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+
+
+def test_meta_benchmark_anchor_includes_required_anchors():
+    pack = load_pack(PACK_PATH)
+    anchors = pack.meta.benchmark_anchor or []
+    joined = " ".join(anchors).lower()
+    for needle in (
+        "sc2 multi-front",
+        "ops triage",
+        "dr multi-system",
+        "military",
+    ):
+        assert needle in joined, f"missing anchor keyword: {needle!r}"
+
+
+def test_uses_hunt_bot():
+    """A `hunt` bot drives both pressure axes — the raiders at the
+    patch hunt the harvesters; the flanking infantry hunt the base
+    buildings. The pack must declare `hunt`."""
+    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")
+    assert bot == "hunt", f"expected hunt bot, got {bot!r}"
+
+
+def test_starting_cash_is_2000_exact():
+    """starting_cash must equal weap cost (2000) so cash slack cannot
+    be used to bypass either the tech or the income-from-harvest loop."""
+    pack = load_pack(PACK_PATH)
+    assert pack.starting_cash == 2000, (
+        f"expected starting_cash 2000 (weap cost), got {pack.starting_cash}"
+    )
+
+
+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_hard_has_two_spawn_point_groups():
+    """Hard-tier curation contract: ≥2 distinct agent spawn_point
+    groups so the seed round-robins the base latitude."""
+    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 needs ≥2 spawn_point groups, got {sp}"
+
+
+def test_tick_budget_aligned_with_max_turns():
+    """within_ticks and after_ticks must be reachable inside max_turns
+    (~90 ticks/turn): otherwise the deadline never bites and a stall
+    draws instead of losing."""
+    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 clock teeth"
+        for wt in wts:
+            assert wt <= reachable, (
+                f"{lvl} within_ticks={wt} > reachable={reachable}"
+            )
+        fail = compile_level(pack, lvl).fail_condition.model_dump(exclude_none=True)
+        ats: list = []
+        _collect(fail, "after_ticks", ats)
+        assert ats, f"{lvl} has no after_ticks fail teeth"
+        for at in ats:
+            assert at <= reachable, (
+                f"{lvl} after_ticks={at} > reachable={reachable}"
+            )
+
+
+# ── Predicate-level checks (synthesised WinContext, no engine) ──────
+
+
+def _ctx(*, own_buildings=(), units=(), tick=1000, cash=2000, resources=0):
+    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=cash,
+        resources=resources,
+        then_progress={},
+    )
+    return WinContext(
+        signals=sig,
+        render_state={"units_summary": list(units)},
+    )
+
+
+def test_predicates_easy():
+    c = compile_level(load_pack(PACK_PATH), "easy")
+    full = [
+        ("fact", 10, 18), ("proc", 8, 18), ("powr", 8, 20),
+        ("weap", 14, 18),
+    ]
+    harvs = [
+        {"cell_x": 14, "cell_y": 16, "type": "harv"},
+        {"cell_x": 14, "cell_y": 22, "type": "harv"},
+    ]
+    # WIN: weap + proc + ≥1 harv + fact + EV ≥ 1000, in time.
+    assert evaluate(
+        c.win_condition,
+        _ctx(own_buildings=full, units=harvs, tick=3000, cash=1200),
+    )
+    # No weap → not a win.
+    no_weap = [b for b in full if b[0] != "weap"]
+    assert not evaluate(
+        c.win_condition,
+        _ctx(own_buildings=no_weap, units=harvs, tick=3000, cash=1200),
+    )
+    # EV below 1000 → not a win (focus-tech-lose-econ failure mode).
+    assert not evaluate(
+        c.win_condition,
+        _ctx(own_buildings=full, units=harvs, tick=3000, cash=0),
+    )
+    # No harv → fail.
+    assert evaluate(
+        c.fail_condition,
+        _ctx(own_buildings=full, units=[], tick=3000, cash=1200),
+    )
+    # No fact (base razed) → fail.
+    no_fact = [b for b in full if b[0] != "fact"]
+    assert evaluate(
+        c.fail_condition,
+        _ctx(own_buildings=no_fact, units=harvs, tick=3000, cash=1200),
+    )
+    # Past deadline → fail.
+    assert evaluate(
+        c.fail_condition,
+        _ctx(own_buildings=full, units=harvs, tick=5402, cash=1200),
+    )
+
+
+def test_predicates_hard_tighter_clock():
+    """Hard's within_ticks is 4500 (tighter than easy/medium's 5400)."""
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    full = [
+        ("fact", 10, 14), ("proc", 8, 14), ("powr", 8, 16),
+        ("weap", 14, 14),
+    ]
+    harvs = [{"cell_x": 14, "cell_y": 12, "type": "harv"}]
+    assert evaluate(
+        c.win_condition,
+        _ctx(own_buildings=full, units=harvs, tick=4000, cash=1200),
+    )
+    assert evaluate(
+        c.fail_condition,
+        _ctx(own_buildings=full, units=harvs, tick=4501, cash=1200),
+    )
+
+
+# ── engine-driven scripted policies ─────────────────────────────────
+
+
+def _find_units(rs, type_name):
+    return [
+        u for u in (rs.get("units_summary", []) or [])
+        if str(u.get("type", "")).lower() == type_name
+    ]
+
+
+def _base_xy(rs):
+    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(rs, Command):
+    """Idle every turn — no harvest, no build, no defence orders.
+    Defenders auto-engage but harvs never harvest (no income) and
+    weap is never built ⇒ has_building:weap never latches ⇒ timeout
+    LOSS via after_ticks."""
+    return [Command.observe()]
+
+
+def _focus_defence_skip_tech(rs, Command):
+    """Hold every defender at the lane mouth; KICK harvs on the patch
+    (income flows); but NEVER queue weap. Weap is required by the win
+    predicate, so this LOSES on the clock even though the base may
+    survive."""
+    cmds = []
+    base = _base_xy(rs)
+    bx = base["cell_x"] if base else 10
+    by = base["cell_y"] if base else 18
+    harvs = _find_units(rs, "harv")
+    patch_xs = [24, 24, 24, 24]
+    patch_ys = [by - 2, by + 2, by - 4, by + 4]
+    for i, h in enumerate(harvs):
+        mx = patch_xs[i % len(patch_xs)]
+        my = patch_ys[i % len(patch_ys)]
+        cmds.append(Command.harvest([str(h["id"])], mx, my))
+    for u in (rs.get("units_summary", []) or []):
+        if str(u.get("type", "")).lower() == "1tnk":
+            cmds.append(
+                Command.move_units([str(u["id"])], target_x=bx + 4, target_y=by)
+            )
+    if not cmds:
+        cmds.append(Command.observe())
+    return cmds
+
+
+def _focus_tech_lose_econ_policy():
+    """Queue weap from turn 1 (using the starting cash) BUT pull every
+    defender AND harvester to the base — the patch is abandoned, so
+    raiders eat the harvs (unit_type_count_gte:{harv,1} ⇒ fail). Even
+    if weap finishes, the harv-count fail clause kills the run."""
+    state = {"weap_queued": False, "weap_attempts": 0}
+
+    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 18
+        cmds = []
+        if (
+            "weap" not in own_b
+            and "weap" not in prod
+            and cash >= 2000
+        ):
+            cmds.append(Command.build("weap"))
+            state["weap_queued"] = True
+        if "weap" not in own_b:
+            i = state["weap_attempts"]
+            cmds.append(
+                Command.place_building("weap", bx + 6 + (i % 4), by - 2 + (i // 4))
+            )
+            state["weap_attempts"] += 1
+        for u in (rs.get("units_summary", []) or []):
+            cmds.append(
+                Command.move_units([str(u["id"])], target_x=bx, target_y=by)
+            )
+        if not cmds:
+            cmds.append(Command.observe())
+        return cmds
+
+    return pol
+
+
+def _intended_multi_handle_policy():
+    """The intended REASONING capability play: handle all three
+    pressures in parallel from turn 1.
+
+       PRESSURE A (economy/raid): keep both harvesters in `harvest`
+         mode every turn — they cycle between proc and the local
+         mine; income accrues to top up the tech buy. The pre-placed
+         tank ring is on Defend stance and auto-fires on incoming
+         raiders at the patch lane mouth (no explicit move orders
+         needed — moving the defenders OFF the ring would abandon
+         the patch and lose).
+       PRESSURE B (defence/hunt): the ring tanks ALSO catch any
+         flanking hunter that crosses the patch column on its way to
+         the fact (Defend stance auto-engage). For close-in hunters
+         the harv proximity is enough to make them targets too.
+       PRESSURE C (tech): queue `weap` on turn 1 with the starting
+         cash, place it immediately in a safe slot west of the base
+         (between fact and proc, away from the hunt approach).
+    """
+    state = {"weap_queued": False, "weap_attempts": 0}
+
+    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 18
+        cmds = []
+
+        if (
+            "weap" not in own_b
+            and "weap" not in prod
+            and cash >= 2000
+        ):
+            cmds.append(Command.build("weap"))
+            state["weap_queued"] = True
+        if "weap" not in own_b:
+            i = state["weap_attempts"]
+            cmds.append(
+                Command.place_building(
+                    "weap", bx + 4 + (i % 4), by + (i // 4)
+                )
+            )
+            state["weap_attempts"] += 1
+
+        harvs = _find_units(rs, "harv")
+        patch_xs = [24, 24, 24, 24]
+        patch_ys = [by - 2, by + 2, by - 4, by + 4]
+        for i, h in enumerate(harvs):
+            mx = patch_xs[i % len(patch_xs)]
+            my = patch_ys[i % len(patch_ys)]
+            cmds.append(Command.harvest([str(h["id"])], mx, my))
+
+        if not cmds:
+            cmds.append(Command.observe())
+        return cmds
+
+    return pol
+
+
+# ── Engine-bound tests (parameterised over seeds 1..4) ───────────────
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_intended_multi_handle_wins(level, seed):
+    """Intended multi-handle must WIN 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, _intended_multi_handle_policy(), seed=seed)
+    own_b = res.signals.own_building_types
+    assert res.outcome == "win", (
+        f"intended multi-handle must WIN on {level} s={seed}; got "
+        f"{res.outcome} turns={res.turns} own_buildings={own_b} "
+        f"units_lost={res.signals.units_lost} cash={res.signals.cash}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_stall_loses(level, seed):
+    """Stall must be a real timeout LOSS 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, seed=seed)
+    assert res.outcome == "loss", (
+        f"stall must LOSS on {level} s={seed}; got {res.outcome} "
+        f"own_buildings={res.signals.own_building_types}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_focus_defence_skip_tech_loses(level, seed):
+    """Focus on defence and never queue weap ⇒ has_building:weap
+    never latches ⇒ timeout LOSS 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, _focus_defence_skip_tech, seed=seed)
+    own_b = res.signals.own_building_types
+    assert res.outcome == "loss", (
+        f"focus-defence-skip-tech must LOSE on {level} s={seed}; got "
+        f"{res.outcome} own_buildings={own_b}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_focus_tech_lose_econ_loses(level, seed):
+    """Focus on tech (queue weap, pull everything home) ⇒ harvs
+    abandoned ⇒ fail by harv-count (or by clock). Must LOSE."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    res = run_level(c, _focus_tech_lose_econ_policy(), seed=seed)
+    own_b = res.signals.own_building_types
+    assert res.outcome == "loss", (
+        f"focus-tech-lose-econ must LOSE on {level} s={seed}; got "
+        f"{res.outcome} own_buildings={own_b} "
+        f"units_lost={res.signals.units_lost}"
+    )