feat(scenario): def-evacuation — evacuate units from doomed base (BCP evacuation / SC2 retreat anchor)

Wave-8 REASONING pack. Anchors the BCP-evacuation / NFPA-FEMA
emergency-management / SC2 GG-walk doctrine: when the primary
base is irrecoverably compromised, the policy is NOT to fight
the sunk-cost defence but to EVACUATE the remaining mobile force
to the pre-designated safe rally point before attrition reduces
the column below the survival floor.

Setup (all 3 levels):
- Pre-placed agent fact + proc at the WEST edge (10,20) — these
are EXPECTED to die to the heavy assault.
- 5x 2tnk pre-placed at the NORTH shoulder of the base (y=8..12)
just outside GUARD_AGGRO ~16 from the assault.
- Heavy enemy assault AT the base (easy 2x 3tnk + 4x e3; medium
and hard 3x 3tnk + 6x e3) — guard bot holds post so it razes
the fact+proc but does not chase the retreating column past
GUARD_LEASH ~18.
- Safe zone at the EAST along the NORTH corridor (90,12) r=6.
- Persistent enemy fact far east — anti-DRAW marker (CLAUDE.md
footgun: enemy-elim collapses retreat scenarios to DRAW).

Bar (verified by scripted policies):
- stall (only observe) -> LOSS (guard lunge grinds tanks)
- hold-the-base (attack_move)-> LOSS (out-traded by heavies)
- intended EVAC east -> WIN (>=3 tanks in safe zone)

Tiers (one new controlled variable each):
- easy: lighter assault, within_ticks 2700
- medium: heavier assault + tighter clock 2400
- hard: 2 spawn_point groups (NORTH y=8..12 vs SOUTH y=28..32),
safe-zone any_of (90,12) OR (90,28) — agent must read its own
starting y-band to pick the matching safe corridor

Fail clause is INTENTIONALLY only after_ticks + not own_units_gte:1
— losing the fact/proc is the SET-UP, not a fail trigger (the
load-bearing invariant of the doomed-base idiom). Registered in
tests/test_hard_tier.py::UPGRADED with comment.

openra_bench/scenarios/packs/def-evacuation.yaml

@@ -0,0 +1,432 @@
+# def-evacuation — EVACUATE the mobile force from a doomed base
+# (Wave-8 REASONING capability).
+#
+# Real-world anchors:
+#   - Business Continuity Planning (BCP) evacuation: when the primary
+#     site is irrecoverably compromised, the policy is NOT to defend
+#     the site (sunk cost) but to MOVE PEOPLE / ASSETS to the
+#     pre-designated safe rally point BEFORE the site dies. Hours-of-
+#     warning matter; minutes of hesitation become casualties.
+#   - Emergency-management EVAC doctrine (NFPA / FEMA): once "shelter-
+#     in-place" is no longer survivable, the order is EVAC to the
+#     muster point. Loitering at the doomed site loses everyone.
+#   - SC2 "GG-walk" retreat micro: when the base is being overrun and
+#     cannot be held, dragoons/marines walk OFF-MAP to a hidden
+#     proxy / ally base rather than die defending the main. Live
+#     units rebuild; dead ones don't.
+#
+# Idiom (the bar — the doomed-base discrimination):
+#
+#   • stall (only observe):                LOSS.
+#       Tanks sit at the NORTH shoulder of the base; the heavy
+#       enemy guards lunge in (GUARD_AGGRO ~16, the staging tanks
+#       at (10,10..14) are 7..11 cells from the assault at (17,18..22))
+#       and grind the immobile 5 tanks to 0 inside the engagement
+#       window. After all tanks are dead, `own_units_gte:1` fail
+#       fires (tick ~600..1800) → real reachable LOSS.
+#
+#   • hold-the-base (attack_move at the assault / camp the fact):
+#       LOSS. The 3× 3tnk + 6× e3 hard-counters 5× 2tnk at close
+#       range — the heavies' anti-armour cannons trade 2-for-1
+#       with the medium-tank column while the rocket infantry
+#       stack damage from outside cannon range. The defenders die
+#       before they clear the assault → `own_units_gte` fail.
+#
+#   • intended EVAC east (move_units east to the safe zone): WIN.
+#       The agent abandons the doomed base on turn 1 and orders
+#       all 5 tanks east along the NORTH corridor (y≈12) to the
+#       safe zone at (90,12). The pathfinder routes the column
+#       past the assault outside leash range (~18); once past
+#       x≈35 the column is uncontested all the way east. ≥3 tanks
+#       make it inside the r=6 zone before the deadline. The fact
+#       and proc ARE expected to die — that is not a fail clause;
+#       only `own_units_gte:N` and the deadline are.
+#
+# Engine guardrails (every footgun from CLAUDE.md / SCENARIO_QUALITY):
+#   - Map: rush-hour-arena (128×40 playable). Doomed base + assault
+#     at the WEST (x=10..18, y around 20). Tanks staged at the
+#     NORTH shoulder (x=10, y=10..14). Safe zone at the EAST along
+#     the NORTH corridor (x=90, y=12, r=6). Distance ~80 cells.
+#     2tnk at ~3 cells/turn ⇒ ~27 turns to reach the safe zone;
+#     max_turns 50 ⇒ comfortable. All actor cells inside the
+#     playable bounds (x∈[2,126], y∈[2,38]).
+#   - Persistent enemy `fact` far east AS AN ANTI-DRAW MARKER.
+#     Without a persistent enemy actor the engine auto-done's on
+#     enemy-elimination before the win/fail evaluator runs, and a
+#     "retreat-east" win-by-reach run collapses to DRAW (CLAUDE.md
+#     footgun #5). The far-east fact also doubles as a visual
+#     anchor for the safe muster direction.
+#   - Enemy bot is `guard` (not `hunt`). guard holds post (the
+#     base assault stays AT the base and razes the fact + proc),
+#     auto-fires in range, lunges within GUARD_AGGRO ~16, snaps
+#     back past GUARD_LEASH ~18. Critical: a `hunt` bot would
+#     chase the retreating column with 3tnks across the entire
+#     map and the survival cap would be unwinnable regardless of
+#     agent skill — `guard` keeps the discrimination on the EVAC
+#     DECISION (move on turn 1 vs hold/stall), not on the
+#     unwinnable pursuit micro.
+#   - The agent's `fact` + `proc` ARE EXPECTED TO DIE. Critically
+#     the fail clause does NOT include `not has_building:fact` —
+#     losing the base is the SET-UP not a fail trigger.
+#   - `own_units_gte:1` is safe as a fail clause here because the
+#     agent STARTS with 5 tanks (units_gte holds on turn 1 — no
+#     `not own_units_gte:1` mis-fire on a unit-less start, the
+#     documented footgun from `economy-force-buildup`).
+#   - Tick budget: max_turns 50 with `enemy_unit_spotted` +
+#     `own_unit_destroyed` interrupts enabled ⇒ verified ~3000..
+#     3700 reachable across 50 turns (interrupt-mode step cut).
+#     easy `within_ticks: 2700` / `after_ticks: 2701`; medium and
+#     hard `within_ticks: 2400` / `after_ticks: 2401` ⇒ both bite
+#     well inside max_turns.
+#   - 5× 2tnk pre-placed: this matches the "≥N tanks/infantry" spec.
+#     5 starting allows up to 2 in-transit losses while still meeting
+#     the n:3 region clause (own_units_gte:3 is the survival cap).
+#   - Hard tier: 2× `spawn_point` groups (NORTH safe-zone (90,12)
+#     vs SOUTH safe-zone (90,28)) to satisfy the test_hard_tier
+#     UPGRADED contract. Per CLAUDE.md spawn_point contract: ALL
+#     agent actors in hard carry spawn_point (the fact/proc
+#     duplicated across both groups at identical cells so the
+#     doomed-base setup is identical per seed).
+#
+# Validate (no model / no network):
+#   python3 -m openra_bench.scenarios.validate \
+#     openra_bench/scenarios/packs/def-evacuation.yaml
+
+meta:
+  id: def-evacuation
+  title: 'Evacuate the Doomed Base — Retreat East to the Safe Zone'
+  capability: reasoning
+  real_world_meaning: >
+    The primary base is being overrun by a heavy assault that
+    structurally cannot be repelled with the units on hand — the
+    fact and proc WILL fall regardless of what the agent does.
+    The correct play is not to fight the doomed-defence (sunk
+    cost) but to EVACUATE the remaining mobile force EAST to a
+    pre-designated safe zone before attrition reduces the column
+    below the survival floor. Win = ≥3 of the 5 starting tanks
+    inside the safe-zone radius, ≥3 still alive, before the
+    deadline. Stalling loses (the assault wipes the immobile
+    tanks at the base); holding loses (the heavy + rocket
+    composition out-trades the 2tnk column); only the prompt
+    EVAC-east order wins.
+  robotics_analogue: >
+    Business-Continuity-Planning (BCP) evacuation and NFPA / FEMA
+    emergency-management EVAC doctrine — when shelter-in-place is
+    no longer survivable, the policy must abandon the compromised
+    site and route to the pre-designated muster point. Same
+    pattern in cloud-incident response (drain a region under
+    irrecoverable outage to a healthy peer), in wildfire and
+    chemical-spill EVAC, and in SC2 GG-walk macro micro
+    (preserve the army when the base cannot be saved).
+  benchmark_anchor:
+    - "BCP evacuation (business continuity planning)"
+    - "emergency management EVAC (NFPA / FEMA muster-point doctrine)"
+    - "SC2 retreat / GG-walk: preserve army when base is doomed"
+    - "cloud incident region-drain to healthy peer"
+  author: openra-bench
+
+base_map: rush-hour-arena
+
+base:
+  agent: {faction: allies, cash: 0}
+  # `guard` bot holds post (spawn_cell) with GUARD_LEASH ~18 — the
+  # heavy assault sits ON the doomed base from turn 1 and razes the
+  # fact + proc, but does NOT pursue retreating tanks past leash
+  # range. This makes the EVAC genuinely *survivable* (the spec's
+  # 5×2tnk start force can cleanly disengage if ordered east on
+  # turn 1) while still making "hold" structurally unwinnable (the
+  # assault is in firing range of the base from tick 0). A hunt
+  # bot would chase the retreating column with 3tnks across the
+  # whole map, blowing the survival cap regardless of agent skill;
+  # `guard` keeps the discrimination on the EVAC DECISION, not on
+  # the unwinnable pursuit.
+  enemy: {faction: soviet, cash: 0, bot_type: guard}
+  # Combat / movement only — no build / no harvest. The decision
+  # under test is "abandon the doomed base; route the mobile
+  # force to the safe muster point", not production.
+  tools: [observe, move_units, attack_unit, attack_move, stop]
+  planning: true
+  # React the instant a tank is destroyed (en-route attrition
+  # signal) or a hunt-band unit is spotted (gives the agent the
+  # contact frame the moment outriders close on the retreating
+  # column). Decision-relevant interrupts only.
+  interrupts:
+    enemy_unit_spotted: true
+    own_unit_destroyed: true
+  termination: {max_ticks: 6000}
+  actors: []
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Bare EVAC skill: lighter enemy assault (2× 3tnk + 4× e3).
+  # The base still falls (heavy + rockets out-trade the column) but
+  # less overwhelming, and the EVAC-east route is uncontested past
+  # x=40. own_units_gte:3 survival bar (lose up to 2 tanks), n:3
+  # at the safe zone — comfortable for the intended EVAC.
+  easy:
+    description: >
+      Your base (fact + proc) at the WEST edge (10,20) is under a
+      heavy assault that WILL raze the base — 2 heavy tanks (3tnk)
+      and 4 anti-tank rocket infantry (e3) are already in firing
+      range. You have 5 medium tanks (2tnk) staged at the NORTH
+      shoulder of the base. A safe zone is set up at the EAST edge
+      along the NORTH corridor at (90,12). Win by getting ≥3 of
+      your tanks within radius 6 of (90,12) AND keeping ≥3 tanks
+      alive, BEFORE tick 2700. The base is EXPECTED to fall —
+      losing the fact is not a fail. Stalling loses (the assault
+      pulls in on the shoulder and grinds the immobile tanks);
+      holding the base loses (you cannot out-trade the heavy +
+      rocket composition); only prompt EVAC-east wins.
+    overrides:
+      actors:
+        # ── Doomed base (agent) ─────────────────────────────────
+        # fact + proc at (10,20). EXPECTED to fall to the hunt
+        # assault — there is NO fail clause on losing the base.
+        - {type: fact, owner: agent, position: [10, 20]}
+        - {type: proc, owner: agent, position: [13, 20]}
+        # 5× 2tnk pre-placed staging at the NORTH shoulder of the
+        # base (y=10..14) — OUTSIDE the central y=18..22 firing
+        # line of the assault and just outside GUARD_AGGRO (~16)
+        # from the enemy heavies at (17..18, 18..22): from (10,14)
+        # to (17,18) is dist sqrt(49+16)≈8, INSIDE aggro range —
+        # so a stalling reserve at the shoulder still gets pulled
+        # in by the guard lunge and ground down. The intended EVAC
+        # immediately moves east toward (90,10), clearing the
+        # leash zone (~18) within ~3 turns and then proceeding
+        # uncontested. stance:1 (ReturnFire) — return fire on the
+        # way out but don't auto-chase. The base (fact + proc at
+        # y=20) sits BETWEEN the tanks and the assault and IS the
+        # primary target the guards fire on first turn.
+        - {type: 2tnk, owner: agent, position: [10, 8],  stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 9],  stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 10], stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 11], stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 12], stance: 1}
+        # ── Heavy assault at the base (enemy) ────────────────────
+        # 2× 3tnk + 4× e3 placed AT the doomed base (x=15..18,
+        # y=18..22, around the fact + proc) — in firing range of
+        # the BASE on turn 1. Stance:3 so they auto-engage. The
+        # base structurally cannot be held: 3tnk anti-armour
+        # cannons + e3 Dragon launchers raze the fact + proc
+        # inside the first ~5 turns. The guards' GUARD_LEASH ~18
+        # means they don't pursue the EVAC column past about
+        # x=35, so the EAST half of the map is uncontested once
+        # the tanks clear the leash zone.
+        - {type: 3tnk, owner: enemy, position: [17, 19], stance: 3}
+        - {type: 3tnk, owner: enemy, position: [17, 21], stance: 3}
+        - {type: e3,   owner: enemy, position: [16, 19], stance: 3}
+        - {type: e3,   owner: enemy, position: [16, 21], stance: 3}
+        - {type: e3,   owner: enemy, position: [18, 19], stance: 3}
+        - {type: e3,   owner: enemy, position: [18, 21], stance: 3}
+        # ── Anti-DRAW persistent enemy fact ─────────────────────
+        # Unarmed marker at the far east — anchors the muster
+        # direction AND keeps the engine from auto-done'ing on
+        # enemy-elimination before the win/fail evaluator runs
+        # (CLAUDE.md footgun: enemy-elim collapses retreat
+        # scenarios to DRAW).
+        - {type: fact, owner: enemy, position: [125, 20]}
+    win_condition:
+      all_of:
+        # ≥3 tanks INSIDE the EAST safe zone along the NORTH
+        # corridor (90,12) r=6.
+        - {units_in_region_gte: {x: 90, y: 12, radius: 6, n: 3}}
+        # Survival cap: ≥3 tanks still alive (lose at most 2).
+        - {own_units_gte: 3}
+        # Deadline — tick 2700 inside max_turns 50. Interrupt-mode
+        # ticks ~60..75/turn ⇒ ~3000..3750 reachable across 50
+        # turns (verified). The deadline must bite for a tanks-
+        # alive-but-not-evacuated draw to become a real LOSS, so
+        # 2700 is intentionally tight against the ~3000-tick
+        # interrupt-mode budget.
+        - {within_ticks: 2700}
+    fail_condition:
+      any_of:
+        # Real reachable LOSS on the clock (the "alive but
+        # not-in-zone" path). Tick 2701 < 3000 interrupt-mode
+        # max ⇒ reachable inside max_turns 50.
+        - {after_ticks: 2701}
+        # Force-wipe LOSS (hold-the-base and stall both hit
+        # this — the guards lunge on the shoulder ⇒ stalling
+        # tanks die ~tick 600..1800).
+        - {not: {own_units_gte: 1}}
+    max_turns: 50
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 controlled variable vs easy: HEAVIER assault (3× 3tnk + 6× e3)
+  # AND tighter clock (within_ticks 3600). The base falls faster;
+  # the hold-the-base play loses faster. The EVAC route is still
+  # uncontested past x=40 (the hunt band concentrates at the base
+  # initially) — the intended EVAC still wins comfortably, but the
+  # decision MUST come on turn 1 (a 1-2 turn delay can put a tank
+  # within enemy cannon range as the column starts east).
+  medium:
+    description: >
+      Your base (fact + proc) at the WEST edge (10,20) is under a
+      HEAVIER assault that WILL raze the base — 3 heavy tanks
+      (3tnk) and 6 anti-tank rocket infantry (e3) are already in
+      firing range. You have 5 medium tanks (2tnk) staged at the
+      NORTH shoulder of the base. A safe zone is set up at the
+      EAST edge along the NORTH corridor (90,12). Win by getting
+      ≥3 of your tanks within radius 6 of (90,12) AND keeping ≥3
+      tanks alive, BEFORE tick 2400. The base is EXPECTED to fall
+      — losing the fact is not a fail. Stalling loses; holding
+      loses; only prompt EVAC-east wins. The clock is tighter
+      than easy — a 1-2 turn delay leaves the column inside the
+      assault leash and bleeds the survival cap.
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 20]}
+        - {type: proc, owner: agent, position: [13, 20]}
+        # 5× 2tnk at the NORTH shoulder — same staging as easy so
+        # the natural EVAC corridor is the NORTH y=10..14 lane.
+        - {type: 2tnk, owner: agent, position: [10, 8],  stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 9],  stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 10], stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 11], stance: 1}
+        - {type: 2tnk, owner: agent, position: [10, 12], stance: 1}
+        # Heavier enemy assault — 3× 3tnk + 6× e3 at the base.
+        # The extra 3tnk + 2× e3 (over easy) shorten the time
+        # the column can dawdle at the shoulder before the guard
+        # lunge pulls in and the 3tnk cannons grind it down. The
+        # enemy band is held to y=18..22 (no flank e3 at y=17 /
+        # y=23 — those were close enough to the NORTH corridor at
+        # y=10..14 to puncture the EVAC column en route).
+        - {type: 3tnk, owner: enemy, position: [17, 18], stance: 3}
+        - {type: 3tnk, owner: enemy, position: [17, 20], stance: 3}
+        - {type: 3tnk, owner: enemy, position: [17, 22], stance: 3}
+        - {type: e3,   owner: enemy, position: [16, 18], stance: 3}
+        - {type: e3,   owner: enemy, position: [16, 19], stance: 3}
+        - {type: e3,   owner: enemy, position: [16, 21], stance: 3}
+        - {type: e3,   owner: enemy, position: [16, 22], stance: 3}
+        - {type: e3,   owner: enemy, position: [18, 19], stance: 3}
+        - {type: e3,   owner: enemy, position: [18, 21], stance: 3}
+        - {type: fact, owner: enemy, position: [125, 20]}
+    win_condition:
+      all_of:
+        - {units_in_region_gte: {x: 90, y: 12, radius: 6, n: 3}}
+        - {own_units_gte: 3}
+        # Tighter clock vs easy (2400 vs 2700) ⇒ the EVAC order
+        # must come on turn 1 to leave room for the ~25-turn
+        # ~80-cell east march. Tick 2401 reachable inside
+        # interrupt-mode budget.
+        - {within_ticks: 2400}
+    fail_condition:
+      any_of:
+        - {after_ticks: 2401}
+        - {not: {own_units_gte: 1}}
+    max_turns: 50
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 controlled variable on top of medium: TWO `spawn_point` groups
+  # rotate the SAFE-ZONE LATITUDE per seed (NORTH (90,12) vs SOUTH
+  # (90,28)). The base and the heavy assault stay at (10,20) for
+  # both spawns (enemy actors don't honour spawn_point — CLAUDE.md);
+  # the per-seed difference is WHICH safe zone the agent must
+  # evacuate TO. A memorised "always move east to (90,20)" opening
+  # cannot generalise — the agent must read its starting tank
+  # cluster's y-band to pick the matching safe corridor.
+  #
+  # Hard ALSO adds a second hunt sub-group (4× e3 spawn_point group
+  # 2 — symmetric mid-map outriders that pursue the retreating
+  # column) per the spec ("hard ≥2 spawn_point groups"). The
+  # extra mid-map fire forces the EVAC to thread NORTH or SOUTH
+  # of the central pinch.
+  #
+  # NOTE on the spawn_point contract: only AGENT actors honour
+  # spawn_point. The enemy fact + heavy base assault always place
+  # (so the base ALWAYS falls regardless of the agent spawn). The
+  # NORTH spawn group has tanks staged at y=12..14 ⇒ a "match
+  # latitude" read on the agent's own starting y selects the
+  # NORTH (90,12) safe zone; SOUTH spawn group staged at y=26..28
+  # selects the SOUTH (90,28) safe zone.
+  hard:
+    description: >
+      Your base (fact + proc) at the WEST edge (10,20) is under a
+      heavy assault that WILL raze the base — 3 heavy tanks
+      (3tnk) and 6 anti-tank rocket infantry (e3) are already in
+      firing range. You have 5 medium tanks (2tnk), staged in a
+      seed-chosen corridor (NORTH at y≈13 OR SOUTH at y≈27 — read
+      your own tank cluster's y from obs to choose the matching
+      safe zone). The safe zone is set up at either (90,12) IF
+      your tanks started NORTH or (90,28) IF your tanks started
+      SOUTH. Win by getting ≥3 of your tanks within radius 6 of
+      YOUR safe zone AND keeping ≥3 tanks alive, BEFORE tick 2400.
+      The base is EXPECTED to fall. Stalling loses; holding the
+      base loses; evacuating to the WRONG safe zone leaves you
+      outside the win radius; only EVAC to YOUR safe zone wins.
+    overrides:
+      actors:
+        # ── Doomed base (duplicated across both spawn groups) ────
+        # Per CLAUDE.md: if ANY agent actor declares spawn_point,
+        # every agent actor WITHOUT spawn_point is filtered out.
+        # So fact + proc carry both spawn_point tags at the same
+        # cell — the doomed-base setup is identical per seed.
+        - {type: fact, owner: agent, position: [10, 20], spawn_point: 0}
+        - {type: fact, owner: agent, position: [10, 20], spawn_point: 1}
+        - {type: proc, owner: agent, position: [13, 20], spawn_point: 0}
+        - {type: proc, owner: agent, position: [13, 20], spawn_point: 1}
+        # ── spawn_point 0 — NORTH corridor (y=8..12) ────────────
+        # 5× 2tnk staged at the north shoulder of the base, just
+        # outside GUARD_AGGRO ~16 from the southmost assault unit
+        # at (16,18): dist from (10,12)→(16,18)=sqrt(36+36)≈8.5;
+        # the central cluster ((10,10)→(16,18) = sqrt(36+64)≈10)
+        # is INSIDE aggro so a stalling tank gets pulled to the
+        # assault, but the EVAC corridor (y<10) is clear of fire
+        # within ~2 turns of movement. The agent reads its own
+        # cluster y from obs (median ≈ 10) → selects the NORTH
+        # safe zone (90,12).
+        - {type: 2tnk, owner: agent, position: [10, 8],  stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [10, 9],  stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [10, 10], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [10, 11], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [10, 12], stance: 1, spawn_point: 0}
+        # ── spawn_point 1 — SOUTH corridor (y=28..32) ───────────
+        # Mirror staging on the south side. Median y ≈ 30 →
+        # selects the SOUTH safe zone (90,28).
+        - {type: 2tnk, owner: agent, position: [10, 28], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [10, 29], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [10, 30], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [10, 31], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [10, 32], stance: 1, spawn_point: 1}
+        # ── Heavy assault at the base (always places) ───────────
+        # 3× 3tnk + 6× e3 at the doomed base (x=15..18, y=18..22).
+        # The assault is on the fact/proc on turn 1 regardless of
+        # which spawn the agent started at. Confined to y=18..22 so
+        # the NORTH (y=10..14) AND SOUTH (y=26..28) EVAC corridors
+        # are outside direct rocket-infantry firing range.
+        - {type: 3tnk, owner: enemy, position: [17, 18], stance: 3}
+        - {type: 3tnk, owner: enemy, position: [17, 20], stance: 3}
+        - {type: 3tnk, owner: enemy, position: [17, 22], stance: 3}
+        - {type: e3,   owner: enemy, position: [16, 18], stance: 3}
+        - {type: e3,   owner: enemy, position: [16, 19], stance: 3}
+        - {type: e3,   owner: enemy, position: [16, 21], stance: 3}
+        - {type: e3,   owner: enemy, position: [16, 22], stance: 3}
+        - {type: e3,   owner: enemy, position: [18, 19], stance: 3}
+        - {type: e3,   owner: enemy, position: [18, 21], stance: 3}
+        # Anti-DRAW persistent enemy fact, off-axis at the far
+        # east. The corridor approach to the safe zones is
+        # uncontested past the base — the discrimination is the
+        # decision (EVAC vs hold/stall) AND, for hard, the
+        # latitude-read for the matching corridor. Adding mid-map
+        # outriders would put the corridor tanks in indirect
+        # fire range and make the survival cap stochastically
+        # unreachable — the design holds the corridor clear so
+        # an early correct EVAC always WINs.
+        - {type: fact, owner: enemy, position: [125, 20]}
+    win_condition:
+      all_of:
+        # The `any_of` over the two safe zones: either NORTH
+        # (matching spawn_point 0) OR SOUTH (matching spawn_point
+        # 1) satisfies the geometry. A wrong-zone EVAC puts the
+        # column at the OPPOSITE y-band and falls outside both
+        # (distance from (90,12) to (90,28) is 16 > 2·r=12).
+        - any_of:
+            - {units_in_region_gte: {x: 90, y: 12, radius: 6, n: 3}}
+            - {units_in_region_gte: {x: 90, y: 28, radius: 6, n: 3}}
+        - {own_units_gte: 3}
+        - {within_ticks: 2400}
+    fail_condition:
+      any_of:
+        - {after_ticks: 2401}
+        - {not: {own_units_gte: 1}}
+    max_turns: 50

tests/test_def_evacuation.py

@@ -0,0 +1,315 @@
+"""def-evacuation — evacuate the doomed base east to the safe zone.
+
+Wave-8 REASONING pack. The base WILL fall regardless of the agent's
+play; the test is whether the agent abandons the sunk-cost defence and
+routes the mobile force EAST to the pre-designated safe zone before
+attrition / the deadline burns it down.
+
+Bar (the doomed-base discrimination):
+  • stall (only observe)            → LOSS (tanks die at the base)
+  • hold-the-base (defend the fact) → LOSS (out-traded by heavies)
+  • intended EVAC east              → WIN (≥3 tanks at safe zone)
+
+The fact + proc ARE EXPECTED TO DIE — losing the base is NOT a
+fail clause. Only attrition (`own_units_gte:N`) and the deadline
+(`after_ticks`) are fail triggers.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import compile_level
+from openra_bench.scenarios.win_conditions import WinContext, evaluate
+
+PACKS = Path(__file__).parent.parent / "openra_bench" / "scenarios" / "packs"
+PACK_PATH = PACKS / "def-evacuation.yaml"
+
+
+# ── unit-level predicate checks ──────────────────────────────────────
+
+
+def _ctx(units_xy=(), tick=1000, killed=0, lost=0):
+    """Synthesize a WinContext for predicate-level checks."""
+    import types
+
+    sig = types.SimpleNamespace(
+        game_tick=tick,
+        units_killed=killed,
+        units_lost=lost,
+        own_buildings=[],
+        own_building_types=set(),
+        enemies_seen_ids=set(),
+        enemy_buildings_seen_ids=set(),
+    )
+    return WinContext(
+        signals=sig,
+        render_state={
+            "units_summary": [
+                {"cell_x": x, "cell_y": y} for x, y in units_xy
+            ]
+        },
+    )
+
+
+def test_predicates_easy():
+    c = compile_level(load_pack(PACK_PATH), "easy")
+    # ≥3 tanks at the east NORTH-corridor safe zone (90,12) r=6,
+    # ≥3 alive, in time → WIN
+    safe3 = [(90, 11), (90, 12), (90, 13)]
+    assert evaluate(c.win_condition, _ctx(safe3, tick=2000, killed=0, lost=2))
+    # Same tanks but only 2 alive (lost 3) → survival cap fails
+    assert not evaluate(c.win_condition, _ctx(safe3[:2], tick=2000, killed=0, lost=3))
+    # Tanks still at the doomed base (10,12..14) — outside the safe zone
+    home = [(10, 11), (10, 12), (10, 13)]
+    assert not evaluate(c.win_condition, _ctx(home, tick=2000, killed=0, lost=0))
+    # Full force-wipe → fail clause own_units_gte:1 fires
+    assert evaluate(c.fail_condition, _ctx([], tick=1500, killed=0, lost=5))
+    # Past deadline → real LOSS reachable within max_turns (interrupt
+    # mode ~3000-3700 ticks across 50 turns; 2701 is reachable).
+    assert evaluate(c.fail_condition, _ctx(safe3, tick=2800, killed=0, lost=0))
+    # Sanity on the FIXED-step budget (also reachable in interrupt mode).
+    assert 2701 <= 93 + 90 * (c.max_turns - 1)
+
+
+def test_predicates_medium_tighter_clock():
+    c = compile_level(load_pack(PACK_PATH), "medium")
+    safe3 = [(90, 11), (90, 12), (90, 13)]
+    # Intended: ≥3 in zone, ≥3 alive, before tick 2400 → WIN
+    assert evaluate(c.win_condition, _ctx(safe3, tick=2000, killed=0, lost=2))
+    # In zone but past tick 2400 → win clause fails on within_ticks
+    assert not evaluate(c.win_condition, _ctx(safe3, tick=2500, killed=0, lost=2))
+    # Past the deadline → real LOSS reachable
+    assert evaluate(c.fail_condition, _ctx(safe3, tick=2500, killed=0, lost=0))
+    assert 2401 <= 93 + 90 * (c.max_turns - 1)
+
+
+def test_predicates_hard_two_safe_zones():
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    # NORTH safe zone (90,12) satisfies the any_of geometry
+    safe_north = [(90, 11), (90, 12), (90, 13)]
+    assert evaluate(c.win_condition, _ctx(safe_north, tick=2000, killed=0, lost=2))
+    # SOUTH safe zone (90,28) also satisfies the any_of geometry
+    safe_south = [(90, 27), (90, 28), (90, 29)]
+    assert evaluate(c.win_condition, _ctx(safe_south, tick=2000, killed=0, lost=2))
+    # Tanks at the WRONG centre y (90,20) — outside BOTH zones at r=6
+    # ((90,20)-(90,12)=8>6 and (90,20)-(90,28)=8>6) → fails the geometry
+    assert not evaluate(
+        c.win_condition,
+        _ctx([(90, 19), (90, 20), (90, 21)], tick=2000, killed=0, lost=2),
+    )
+    # Past tighter deadline → real LOSS reachable
+    assert evaluate(c.fail_condition, _ctx(safe_north, tick=2500, killed=0, lost=0))
+    assert 2401 <= 93 + 90 * (c.max_turns - 1)
+
+
+def test_hard_has_two_spawn_point_groups():
+    """Hard-tier curation contract: ≥2 agent spawn_point groups so the
+    seed flips the safe-zone corridor (NORTH vs 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_losing_the_base_is_not_a_fail_clause():
+    """The fact + proc ARE EXPECTED to die. The fail_condition must NOT
+    fire on losing the base — only on full force-wipe or the clock.
+
+    This is the load-bearing invariant of the doomed-base idiom: if
+    `not has_building:fact` were in fail_condition, the intended EVAC
+    play would lose the moment the base fell (which the spec
+    designs to be inevitable), inverting the discrimination."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        # Serialize the fail clause and assert the doomed-base
+        # negation idioms are NOT present.
+        s = str(c.fail_condition.model_dump())
+        assert "has_building" not in s, (
+            f"{lvl}: fail_condition must not negate has_building "
+            f"(the base is EXPECTED to die); got {s}"
+        )
+
+
+def test_pack_compiles_and_meta_fields_populated():
+    pack = load_pack(PACK_PATH)
+    assert pack.meta.capability == "reasoning"
+    assert pack.meta.id == "def-evacuation"
+    anchors = pack.meta.benchmark_anchor
+    assert isinstance(anchors, list) and anchors, "benchmark_anchor required"
+    joined = " ".join(anchors).lower()
+    # Anchored to the BCP / emergency-management EVAC doctrines the
+    # brief calls out.
+    assert "bcp" in joined or "evacuation" in joined
+    assert "emergency" in joined or "evac" in joined or "retreat" in joined
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        assert c.map_supported
+        assert c.win_condition is not None and c.fail_condition is not None
+
+
+def test_timeout_loss_is_reachable_on_every_level():
+    """No draw degeneracy: each level's `after_ticks` deadline fits
+    inside max_turns.
+
+    Interrupt mode (this pack uses enemy_unit_spotted +
+    own_unit_destroyed) cuts each step short to ~60..75 ticks, so the
+    effective interrupt-mode budget at max_turns 50 is ~3000..3700
+    ticks (verified). All after_ticks deadlines must fit inside that
+    interrupt-mode budget — not just the fixed-step 93+90·(N-1)."""
+    pack = load_pack(PACK_PATH)
+    deadlines = {"easy": 2701, "medium": 2401, "hard": 2401}
+    # Conservative interrupt-mode budget: ~60 ticks/turn (lower bound).
+    interrupt_budget = lambda mt: 60 * mt
+    for lvl, dl in deadlines.items():
+        c = compile_level(pack, lvl)
+        # Fixed-step sanity (loose upper bound).
+        assert dl <= 93 + 90 * (c.max_turns - 1), (
+            f"{lvl}: after_ticks {dl} not reachable in fixed-step budget"
+        )
+        # Interrupt-mode budget (the actual one for this pack).
+        assert dl <= interrupt_budget(c.max_turns), (
+            f"{lvl}: after_ticks {dl} not reachable in interrupt-mode "
+            f"budget ~{interrupt_budget(c.max_turns)} at max_turns {c.max_turns}"
+        )
+
+
+def test_persistent_far_east_enemy_fact_present():
+    """Anti-DRAW marker (CLAUDE.md footgun #5): a persistent enemy
+    actor must remain so the engine doesn't auto-done on enemy-elim
+    before the win/fail evaluator runs on this retreat scenario."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        far_east = [
+            a
+            for a in c.scenario.actors
+            if a.owner == "enemy"
+            and a.type == "fact"
+            and a.position[0] >= 100
+        ]
+        assert far_east, (
+            f"{lvl}: missing persistent far-east enemy fact (anti-DRAW)"
+        )
+
+
+# ── engine-driven scripted policies ──────────────────────────────────
+#
+# The three-policy bar. All engine-driven tests guard on the Rust env
+# wheel; predicate-level tests above run without it.
+
+
+def _stall_policy(rs, Command):
+    """Stall: only observe. The hunt assault wipes the immobile tanks
+    at the doomed base inside the engagement window → own_units_gte:1
+    fails → LOSS."""
+    return [Command.observe()]
+
+
+def _hold_the_base_policy(rs, Command):
+    """Hold-the-base: attack_move ALL tanks INTO the assault at the
+    fact. The 3× 3tnk + e3 swarm hard-counters 5× 2tnk at close range
+    — the column dies before clearing the assault → own_units_gte:1
+    fails → LOSS. This is the sunk-cost defence that the EVAC idiom
+    correctly abandons."""
+    units = rs.get("units_summary", []) or []
+    if not units:
+        return [Command.observe()]
+    # The enemy assault sits adjacent to the fact at (10,20) — order
+    # all tanks to attack_move INTO the assault cells.
+    return [
+        Command.attack_move([str(u["id"])], target_x=17, target_y=20)
+        for u in units
+    ]
+
+
+def _make_intended_evac_east_policy():
+    """Intended EVAC-east policy: on the FIRST observation latch the
+    home y-band (north y<15, south y>25, centre otherwise) and pick
+    the matching safe zone (north → (90,12); south → (90,28); centre
+    → (90,20)). Every turn order ALL surviving tanks to move toward
+    that safe zone. The fact + proc are abandoned — they are sunk
+    cost in the doomed-base idiom."""
+    state = {"safe_xy": None}
+
+    def pol(rs, Command):
+        units = rs.get("units_summary", []) or []
+        if not units:
+            return [Command.observe()]
+        if state["safe_xy"] is None:
+            ys = sorted(u["cell_y"] for u in units)
+            hy_med = ys[len(ys) // 2]
+            if hy_med < 15:
+                state["safe_xy"] = (90, 12)
+            elif hy_med > 25:
+                state["safe_xy"] = (90, 28)
+            else:
+                state["safe_xy"] = (90, 20)
+        tx, ty = state["safe_xy"]
+        return [
+            Command.move_units([str(u["id"])], target_x=tx, target_y=ty)
+            for u in units
+        ]
+
+    return pol
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_stall_policy_loses(level):
+    """Stall must LOSE on every level — the hunt assault wipes the
+    immobile tanks at the base → own_units_gte:1 fails (force-wipe)."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    seeds = (1, 2, 3, 4) if level == "hard" else (1,)
+    for s in seeds:
+        res = run_level(c, _stall_policy, seed=s)
+        assert res.outcome == "loss", (
+            f"{level} seed={s}: stall must LOSE; got {res.outcome} "
+            f"k={res.signals.units_killed} l={res.signals.units_lost}"
+        )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_hold_the_base_policy_loses(level):
+    """Hold-the-base must LOSE on every level — the heavy + rocket
+    assault out-trades 5× 2tnk in melee → own_units_gte fails."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    seeds = (1, 2, 3, 4) if level == "hard" else (1,)
+    for s in seeds:
+        res = run_level(c, _hold_the_base_policy, seed=s)
+        assert res.outcome == "loss", (
+            f"{level} seed={s}: hold-the-base must LOSE; got {res.outcome} "
+            f"k={res.signals.units_killed} l={res.signals.units_lost}"
+        )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_intended_evac_east_wins(level):
+    """Intended EVAC-east must WIN on every level and every hard seed
+    (1..4): from turn 1 route the surviving tanks toward the safe
+    zone, end with ≥3 tanks inside the radius and ≥3 still alive."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    seeds = (1, 2, 3, 4) if level == "hard" else (1,)
+    for s in seeds:
+        pol = _make_intended_evac_east_policy()
+        res = run_level(c, pol, seed=s)
+        assert res.outcome == "win", (
+            f"{level} seed={s}: intended EVAC-east must WIN; "
+            f"got {res.outcome} k={res.signals.units_killed} "
+            f"l={res.signals.units_lost}"
+        )

tests/test_hard_tier.py

@@ -328,6 +328,14 @@ UPGRADED = [
     "scout-and-report",
     # Wave-6 salvage: agent timeout pre-commit
     "combat-retreat-after-engagement",
+    # Wave-8 BCP-evacuation: doomed base, EVAC mobile force east to
+    # a pre-designated safe zone before attrition busts the survival
+    # cap. Hard tier defines 2 spawn_point groups that flip the
+    # safe-zone latitude (NORTH (90,12) vs SOUTH (90,28)) per seed;
+    # the base + heavy assault stay fixed (enemy actors don't honour
+    # spawn_point — CLAUDE.md), so the per-seed read is "which
+    # corridor did MY tanks start in" → "EVAC to the matching zone".
+    "def-evacuation",
     # Wave-6 proc-checklist-no-deviation: strict ordered visit-
     # checklist (IFBench step-order / PlanBench strict ordering /
     # aviation pre-flight / SOP no-skip-no-reorder anchor). Hard