feat(scenario): def-reinforce-the-breach — reactive defense, shift the reserve to the breached lane (military reserve commitment)

ACTION pack: a two-lane defence with a mobile reserve held at the
centre. Mid-episode a heavy breach wave is injected on the south lane
via scheduled_events; the agent must read which lane was breached and
shift the reserve forward into it. Stall and brute LOSE; reinforcing
the wrong (un-breached) lane LOSES on medium/hard; only shifting the
reserve into the breached lane WINS. The win carries an after_ticks
gate so it cannot latch before the breach develops. Hard defines two
seed-driven reserve spawn_point columns.

openra_bench/scenarios/packs/def-reinforce-the-breach.yaml

@@ -0,0 +1,331 @@
+# def-reinforce-the-breach — ACTION, reactive defense: shift the
+# mobile reserve to the lane that gets breached mid-episode
+# (Wave-12).
+#
+# The capability under test is REACTIVE RESERVE COMMITMENT. The
+# agent holds a multi-lane defence: a north lane and a south lane,
+# each with a light fixed garrison, plus a mobile armoured reserve
+# held UNCOMMITTED at the centre. At t=0 both lanes face only a
+# light probe. Mid-episode a HEAVY breach wave is injected on ONE
+# lane (the south lane) via a `scheduled_events: spawn_actors` hook
+# — the lane is breached. The light garrison there cannot hold the
+# breach alone; the agent must REACT, read which lane was breached,
+# and shift the mobile reserve FORWARD into that lane to reinforce
+# it before the line collapses.
+#
+# Real-world anchors:
+#   • Military "reinforce the breach" doctrine / reserve commitment:
+#     the general reserve is held uncommitted until the enemy's main
+#     effort localises; the instant a sector is breached the reserve
+#     is committed FORWARD to that sector to restore the line.
+#   • Incident surge response: an on-call response team is staged
+#     centrally; when one site escalates, the surge capacity is
+#     committed to THAT site — not held back, not sent to a quiet
+#     site.
+#   • SC2 reactive defence: hold an army at a central position, then
+#     react to the opponent's attack by reinforcing the lane that is
+#     actually being hit.
+#
+# Mechanism (the load-bearing design):
+#   • TWO lanes (north y≈12 / south y≈28), each with a 2-tank fixed
+#     garrison. A 4-tank mobile reserve is held at the CENTRE
+#     (x≈44, y=20) — equidistant from both lanes.
+#   • At t=0 both lanes face only a light 3×e1 probe. The breach
+#     wave (a heavier e1 wave) is injected on the SOUTH lane at a
+#     scheduled tick via `scheduled_events: spawn_actors`.
+#   • The enemy uses the `hunt` bot so each enemy unit advances on
+#     and engages the NEAREST agent unit — the two lanes are
+#     genuinely INDEPENDENT fights (a `rusher` bot would pool every
+#     band onto the agent centroid and collapse the multi-lane
+#     test; CLAUDE.md / def-pre-position-mobile-reserve).
+#   • The win is a FORWARD-ZONE clause: `units_in_region_gte` at the
+#     SOUTH lane's intercept zone, requiring N tanks there. The
+#     2-tank south garrison alone cannot fill the zone — the
+#     reserve must reinforce it. A reserve held at the centre, or
+#     sent to the un-breached NORTH lane, never fills the south
+#     zone ⇒ LOSS. Plus an `own_units_gte` survival clause: a
+#     breach left un-reinforced overruns the south garrison ⇒ the
+#     survival clause busts too.
+#
+# Discrimination (four-policy bar — scripted, no model needed):
+#   • stall (observe-only): the reserve sits at the centre; the
+#     forward-zone clause is never satisfied AND the un-reinforced
+#     south garrison is overrun by the breach wave ⇒ LOSS (the
+#     `after_ticks` deadline is a backstop — no draw degeneracy).
+#   • reinforce-the-wrong-lane (commit the reserve to the NORTH
+#     lane): the south forward zone is left short ⇒ the
+#     `units_in_region_gte` clause fails ⇒ LOSS (medium/hard, where
+#     the zone needs the reserve's tanks; on easy the bar is looser
+#     — see the level notes).
+#   • brute (one attack_move straight east, ignore the lanes): the
+#     reserve drives off the breached lane's intercept zone ⇒ the
+#     forward-zone clause fails ⇒ LOSS.
+#   • intended reinforce-the-breach (read the mid-episode breach,
+#     shift the reserve FORWARD into the SOUTH lane's intercept
+#     zone): the forward-zone clause is satisfied AND the
+#     reinforced line holds ⇒ WIN.
+#
+# Engine facts used (CLAUDE.md / verified against the installed
+# openra_train wheel, 2026-05-20):
+#   • `scheduled_events: spawn_actors` injects fresh-id actors at a
+#     scheduled tick (Wave-9 feature; test_scheduled_events). The
+#     breach wave is the only way to make ONE lane heavier
+#     MID-episode — a t=0 placement cannot exercise "react to a
+#     breach that develops".
+#   • `hunt` bot: each enemy unit advances on and attacks the
+#     NEAREST agent unit, so the two lanes are independent fights;
+#     a far-off breach wave still advances (a `stance:3` actor only
+#     advances toward a VISIBLE enemy and would stall in fog).
+#   • `units_in_region_gte: {x, y, radius, n}` — the load-bearing
+#     forward-zone clause: it is pure geometry and does not depend
+#     on combat resolution, so the discrimination is deterministic.
+#   • Tick alignment (~90 ticks/turn): within_ticks ≤ 93+90·
+#     (max_turns−1); fail after_ticks = within_ticks+1 ⇒ a
+#     non-finisher is a real reachable LOSS, never a DRAW. The win
+#     also carries an `after_ticks: 720` GATE — the win cannot
+#     latch until the breach wave has developed (it spawns at tick
+#     450 and is fully in play by ~720), so a reserve that rushes
+#     the south zone BEFORE the breach cannot win prematurely. The
+#     win is purely positional (no conquest clause) and the far
+#     enemy `fact` is never destroyed, so the `after_ticks` win
+#     gate is safe from the engine's enemy-elimination auto-done
+#     (CLAUDE.md after_ticks/Conquest footgun does not apply).
+#   • A far inert enemy `fact` marker keeps the engine from
+#     auto-`done`ing on enemy-elimination before the win/fail
+#     evaluator runs (CLAUDE.md auto-done footgun).
+#   • Hard tier: two agent spawn_point groups round-robin the
+#     mobile reserve's start COLUMN (x=40 vs x=50 — both remain
+#     equidistant from the two lanes) so a memorised reserve cell
+#     cannot generalise; the centre-then-react DOCTRINE does. The
+#     garrisons and the breach wave (no spawn_point) place every
+#     seed.
+#
+# Validate (no model / no network):
+#   python3 -m pytest tests/test_def_reinforce_the_breach.py -q
+
+meta:
+  id: def-reinforce-the-breach
+  title: 'Reactive Defense — Reinforce the Breached Lane'
+  capability: action
+  real_world_meaning: >
+    A multi-lane defence with a mobile armoured reserve held
+    uncommitted at the centre. At first both lanes face only a light
+    probe, but mid-episode one lane is BREACHED by a heavier wave.
+    The light garrison there cannot hold the breach alone; the agent
+    must react — read which lane was breached — and shift the mobile
+    reserve FORWARD into that lane to reinforce it before the line
+    collapses. Holding the reserve at the centre, or committing it to
+    the quiet lane, lets the breach overrun the line. The pack tests
+    reactive reserve commitment: identify the developing breach and
+    commit the reserve to the sector that is actually being hit.
+  robotics_analogue: >
+    Incident surge response: an on-call response team is staged
+    centrally, equidistant from candidate sites. When one site
+    escalates into a breach, the surge capacity must be committed to
+    THAT site — promptly and in force. Holding the reserve back or
+    dispatching it to a quiet site both fail the response: the skill
+    is reading where the main effort has localised and committing
+    the reserve there.
+  benchmark_anchor:
+    - "military reserve commitment"
+    - "reinforce the breach doctrine"
+    - "incident surge response"
+  author: openra-bench
+
+base_map: rush-hour-arena
+
+base:
+  agent: {faction: allies, cash: 0}
+  # `hunt`: each enemy unit advances on and engages the NEAREST
+  # agent unit, so the north and south lanes are genuinely
+  # independent fights (a `rusher` bot pools every band onto the
+  # agent centroid and collapses the multi-lane test).
+  enemy: {faction: soviet, cash: 0, bot_type: hunt}
+  tools: [observe, move_units, attack_unit, attack_move, stop]
+  planning: true
+  termination: {max_ticks: 8000}
+  actors: []
+
+levels:
+  # ── EASY ────────────────────────────────────────────────────────
+  # The bare reactive-reserve skill: REACT AT ALL. Two lanes, a
+  # 4-tank reserve at the centre. The south lane is breached at tick
+  # 450 by an 8×e1 wave. The forward-zone bar is n=3 — the 2-tank
+  # south garrison plus ONE reinforcing reserve tank fills it. The
+  # discrimination at this tier is stall (reserve never moves ⇒ zone
+  # unfilled + garrison overrun ⇒ LOSS) vs reinforce (move the
+  # reserve south ⇒ WIN). Picking the WRONG lane is punished at
+  # medium; easy only tests that the agent reacts.
+  easy:
+    description: >
+      You hold a two-lane defence — a NORTH lane (y≈12) and a SOUTH
+      lane (y≈28), each with a 2-tank garrison — plus a 4-tank
+      mobile reserve held at the CENTRE (x≈44, y=20). At first both
+      lanes face only a light probe. Mid-episode the SOUTH lane is
+      BREACHED by a heavier wave. React: shift the mobile reserve
+      FORWARD into the SOUTH lane to reinforce it — at least 3 tanks
+      must be within radius 12 of the south intercept point
+      (62, 28) at win time, you must keep at least 4 tanks alive,
+      and finish before tick 2400. Holding the reserve at the centre
+      LOSES — the breach overruns the un-reinforced south garrison.
+      Stalling LOSES.
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 20]}
+        # NORTH lane garrison.
+        - {type: 2tnk, owner: agent, position: [30, 11], stance: 2}
+        - {type: 2tnk, owner: agent, position: [30, 13], stance: 2}
+        # SOUTH lane garrison.
+        - {type: 2tnk, owner: agent, position: [30, 27], stance: 2}
+        - {type: 2tnk, owner: agent, position: [30, 29], stance: 2}
+        # Mobile reserve at the CENTRE — equidistant from both lanes.
+        - {type: 2tnk, owner: agent, position: [44, 19], stance: 2}
+        - {type: 2tnk, owner: agent, position: [44, 20], stance: 2}
+        - {type: 2tnk, owner: agent, position: [44, 21], stance: 2}
+        - {type: 2tnk, owner: agent, position: [45, 20], stance: 2}
+        # Initial light probes — one per lane.
+        - {type: e1, owner: enemy, position: [78, 12], stance: 3, count: 3}
+        - {type: e1, owner: enemy, position: [78, 28], stance: 3, count: 3}
+        # Far inert enemy marker — anti-DRAW.
+        - {type: fact, owner: enemy, position: [120, 20]}
+      # Breach wave — heavier wave injected on the SOUTH lane.
+      scheduled_events:
+        - tick: 450
+          type: spawn_actors
+          actors:
+            - {type: e1, owner: enemy, position: [78, 28], stance: 3, count: 8}
+    win_condition:
+      all_of:
+        # `after_ticks` gate: the win cannot latch until the breach
+        # wave has developed (it spawns at tick 450 and is fully in
+        # play by ~720) — so a reserve that rushes the zone before
+        # the breach cannot win prematurely.
+        - {after_ticks: 720}
+        - {units_in_region_gte: {x: 62, y: 28, radius: 12, n: 3}}
+        - {own_units_gte: 4}
+        - {within_ticks: 2400}
+    fail_condition:
+      any_of:
+        - {after_ticks: 2401}
+        - {not: {own_units_gte: 1}}
+    max_turns: 40
+
+  # ── MEDIUM ──────────────────────────────────────────────────────
+  # +1 controlled variable: REACT TO THE RIGHT LANE. The forward-
+  # zone bar rises to n=4 — the 2-tank south garrison can no longer
+  # fill it alone, and a reserve committed to the NORTH lane leaves
+  # the south zone two tanks short. Now reinforcing the WRONG lane
+  # LOSES, not just stalling. Same breach (south, tick 450, 8×e1),
+  # same clock.
+  medium:
+    description: >
+      You hold a two-lane defence — a NORTH lane and a SOUTH lane,
+      each with a 2-tank garrison — plus a 4-tank mobile reserve at
+      the CENTRE. Mid-episode one lane is BREACHED by a heavier
+      wave. React to the lane that is actually hit: shift the mobile
+      reserve FORWARD into the BREACHED lane — at least 4 tanks must
+      be within radius 12 of that lane's intercept point at win
+      time, you must keep at least 4 tanks alive, and finish before
+      tick 2400. Holding the reserve at the centre LOSES; committing
+      it to the QUIET lane LOSES (the breached lane is left two
+      tanks short); stalling LOSES.
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 20]}
+        - {type: 2tnk, owner: agent, position: [30, 11], stance: 2}
+        - {type: 2tnk, owner: agent, position: [30, 13], stance: 2}
+        - {type: 2tnk, owner: agent, position: [30, 27], stance: 2}
+        - {type: 2tnk, owner: agent, position: [30, 29], stance: 2}
+        - {type: 2tnk, owner: agent, position: [44, 19], stance: 2}
+        - {type: 2tnk, owner: agent, position: [44, 20], stance: 2}
+        - {type: 2tnk, owner: agent, position: [44, 21], stance: 2}
+        - {type: 2tnk, owner: agent, position: [45, 20], stance: 2}
+        - {type: e1, owner: enemy, position: [78, 12], stance: 3, count: 3}
+        - {type: e1, owner: enemy, position: [78, 28], stance: 3, count: 3}
+        - {type: fact, owner: enemy, position: [120, 20]}
+      # Breach wave — SOUTH lane, tick 450.
+      scheduled_events:
+        - tick: 450
+          type: spawn_actors
+          actors:
+            - {type: e1, owner: enemy, position: [78, 28], stance: 3, count: 8}
+    win_condition:
+      all_of:
+        # `after_ticks` gate: the win cannot latch until the breach
+        # wave has developed (it spawns at tick 450 and is fully in
+        # play by ~720) — so a reserve that rushes the zone before
+        # the breach cannot win prematurely.
+        - {after_ticks: 720}
+        - {units_in_region_gte: {x: 62, y: 28, radius: 12, n: 4}}
+        - {own_units_gte: 4}
+        - {within_ticks: 2400}
+    fail_condition:
+      any_of:
+        - {after_ticks: 2401}
+        - {not: {own_units_gte: 1}}
+    max_turns: 40
+
+  # ── HARD ────────────────────────────────────────────────────────
+  # +2 controlled variables vs medium:
+  #   1. Tighter deadline (~1900 ticks instead of ~2400) — the
+  #      reserve must be committed PROMPTLY; a dawdling shift misses
+  #      the clock.
+  #   2. TWO agent spawn_point groups round-robin the mobile
+  #      reserve's start COLUMN (x=40 vs x=50 — both equidistant
+  #      from the two lanes) so a memorised reserve cell cannot
+  #      generalise; the centre-then-react doctrine does. The
+  #      garrisons and the breach wave (no spawn_point) place every
+  #      seed.
+  hard:
+    description: >
+      You hold a two-lane defence — a NORTH lane and a SOUTH lane,
+      each with a 2-tank garrison — plus a 4-tank mobile reserve at
+      the CENTRE (its exact start column varies by seed). Mid-
+      episode one lane is BREACHED by a heavier wave. React
+      promptly: shift the mobile reserve FORWARD into the BREACHED
+      lane — at least 4 tanks must be within radius 12 of that
+      lane's intercept point at win time, you must keep at least 4
+      tanks alive, and finish before tick 1900 (a tight window).
+      Holding the reserve at the centre LOSES; committing it to the
+      QUIET lane LOSES; stalling LOSES.
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 20]}
+        - {type: 2tnk, owner: agent, position: [30, 11], stance: 2}
+        - {type: 2tnk, owner: agent, position: [30, 13], stance: 2}
+        - {type: 2tnk, owner: agent, position: [30, 27], stance: 2}
+        - {type: 2tnk, owner: agent, position: [30, 29], stance: 2}
+        # spawn_point 0 — reserve start column x=40.
+        - {type: 2tnk, owner: agent, position: [40, 19], stance: 2, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [40, 20], stance: 2, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [40, 21], stance: 2, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [41, 20], stance: 2, spawn_point: 0}
+        # spawn_point 1 — reserve start column x=50.
+        - {type: 2tnk, owner: agent, position: [50, 19], stance: 2, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [50, 20], stance: 2, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [50, 21], stance: 2, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [51, 20], stance: 2, spawn_point: 1}
+        - {type: e1, owner: enemy, position: [78, 12], stance: 3, count: 3}
+        - {type: e1, owner: enemy, position: [78, 28], stance: 3, count: 3}
+        - {type: fact, owner: enemy, position: [120, 20]}
+      # Breach wave — SOUTH lane, tick 450.
+      scheduled_events:
+        - tick: 450
+          type: spawn_actors
+          actors:
+            - {type: e1, owner: enemy, position: [78, 28], stance: 3, count: 8}
+    win_condition:
+      all_of:
+        # `after_ticks` gate: the win cannot latch until the breach
+        # wave has developed (it spawns at tick 450 and is fully in
+        # play by ~720) — so a reserve that rushes the zone before
+        # the breach cannot win prematurely.
+        - {after_ticks: 720}
+        - {units_in_region_gte: {x: 62, y: 28, radius: 12, n: 4}}
+        - {own_units_gte: 4}
+        - {within_ticks: 1900}
+    fail_condition:
+      any_of:
+        - {after_ticks: 1901}
+        - {not: {own_units_gte: 1}}
+    max_turns: 30

tests/test_def_reinforce_the_breach.py

@@ -0,0 +1,327 @@
+"""def-reinforce-the-breach — ACTION capability validation.
+
+Reactive reserve commitment: a two-lane defence with a mobile
+reserve held at the centre. Mid-episode a HEAVY breach wave is
+injected on the SOUTH lane via `scheduled_events: spawn_actors`.
+The agent must read which lane was breached and shift the reserve
+FORWARD into that lane's intercept zone.
+
+Bar (CLAUDE.md "no defect, no cheat, no draw"):
+
+  * stall (observe-only) LOSES every tier / every hard seed — the
+    reserve sits at the centre; the forward-zone clause is never
+    satisfied and the un-reinforced south garrison is overrun.
+  * brute (one attack_move straight east) LOSES every tier / seed
+    — the reserve drives off the breached lane's intercept zone.
+  * reinforce-the-wrong-lane (commit the reserve to the NORTH
+    lane) LOSES on medium/hard — the south forward zone is left
+    two tanks short of the n=4 bar.
+  * intended reinforce-the-breach (shift the reserve into the
+    SOUTH lane's intercept zone) WINS every tier / every hard
+    seed.
+  * the win carries an `after_ticks: 720` gate so it cannot latch
+    before the breach (tick 450) has developed — no premature win.
+  * hard tier defines ≥2 agent spawn_point groups (reserve start
+    column x=40 / x=50) round-robined by seed.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+
+from openra_bench.eval_core import run_level
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+from openra_bench.scenarios.win_conditions import WinContext, evaluate
+
+PACK = PACKS_DIR / "def-reinforce-the-breach.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+
+# ── scripted policies ───────────────────────────────────────────────
+
+
+def _tanks(rs):
+    return [u for u in (rs.get("units_summary") or []) if u.get("type") == "2tnk"]
+
+
+def _reserve(own):
+    """The centre reserve: tanks on the mid latitude, x ≥ 37."""
+    return [u for u in own if 17 <= u["cell_y"] <= 23 and u["cell_x"] >= 37]
+
+
+def _stall(rs, C):
+    """Observe-only — the reserve never moves; the forward-zone clause
+    is never satisfied and the south garrison is overrun → LOSS."""
+    return [C.observe()]
+
+
+def _brute(rs, C):
+    """One attack_move straight east — the reserve drives off the
+    breached lane's intercept zone → the forward-zone clause fails →
+    LOSS."""
+    own = _tanks(rs)
+    if not own:
+        return [C.observe()]
+    return [
+        C.attack_move([str(u["id"]) for u in own], target_x=110, target_y=own[0]["cell_y"])
+    ]
+
+
+def _make_reinforce(lane_y):
+    """Shift the reserve forward into the lane at `lane_y` (28 = the
+    breached SOUTH lane; 12 = the un-breached NORTH lane). The
+    garrisons attack the nearest visible enemy."""
+
+    def p(rs, C):
+        own = _tanks(rs)
+        if not own:
+            return [C.observe()]
+        enemies = rs.get("enemy_summary") or []
+        reserve = _reserve(own)
+        cmds = []
+        for u in reserve:
+            if enemies and lane_y == 28:
+                t = min(
+                    enemies,
+                    key=lambda e: abs(e["cell_x"] - u["cell_x"])
+                    + abs(e["cell_y"] - u["cell_y"]),
+                )
+                cmds.append(C.attack_unit([str(u["id"])], str(t["id"])))
+            else:
+                cmds.append(
+                    C.attack_move([str(u["id"])], target_x=58, target_y=lane_y)
+                )
+        for u in own:
+            if u not in reserve and enemies:
+                t = min(
+                    enemies,
+                    key=lambda e: abs(e["cell_x"] - u["cell_x"])
+                    + abs(e["cell_y"] - u["cell_y"]),
+                )
+                cmds.append(C.attack_unit([str(u["id"])], str(t["id"])))
+        return cmds or [C.observe()]
+
+    return p
+
+
+# ── structural tests ────────────────────────────────────────────────
+
+
+def test_pack_loads_and_meta_action():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "def-reinforce-the-breach"
+    assert pack.meta.capability == "action"
+    assert pack.meta.real_world_meaning
+    assert pack.meta.robotics_analogue
+    anchors = " ".join(pack.meta.benchmark_anchor).lower()
+    assert "military reserve commitment" in anchors, anchors
+    assert "reinforce the breach doctrine" in anchors, anchors
+    assert "incident surge response" in anchors, anchors
+
+
+def test_enemy_uses_hunt_bot():
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        enemy = c.scenario.enemy
+        bot = getattr(enemy, "bot_type", None) or getattr(enemy, "bot", None)
+        assert str(bot).lower() == "hunt", f"{lvl}: enemy bot must be 'hunt'; got {bot}"
+
+
+def test_every_level_has_a_scheduled_breach_wave():
+    """Every level injects the breach via scheduled_events:
+    spawn_actors — the breach must develop MID-episode."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        ev = getattr(c, "scheduled_events", None)
+        assert ev, f"{lvl}: must declare scheduled_events"
+        spawns = [e for e in ev if e.get("type") == "spawn_actors"]
+        assert spawns, f"{lvl}: must have a spawn_actors breach wave"
+        # The breach wave fires after t=0 (mid-episode).
+        for e in spawns:
+            assert int(e["tick"]) > 0, f"{lvl}: breach tick must be > 0"
+
+
+def test_win_has_after_ticks_gate_before_the_breach_resolves():
+    """The win carries an `after_ticks` gate so it cannot latch
+    before the breach wave (scheduled) has developed."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        win = c.win_condition.model_dump()["all_of"]
+        gate = next((int(x["after_ticks"]) for x in win if "after_ticks" in x), None)
+        assert gate is not None, f"{lvl}: win must carry an after_ticks gate"
+        breach_tick = min(
+            int(e["tick"])
+            for e in c.scheduled_events
+            if e.get("type") == "spawn_actors"
+        )
+        assert gate > breach_tick, (
+            f"{lvl}: win gate {gate} must be after the breach tick {breach_tick}"
+        )
+
+
+def test_forward_zone_clause_is_load_bearing():
+    """Every level's win requires a units_in_region_gte forward-zone
+    clause at the south lane intercept point."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        win = c.win_condition.model_dump()["all_of"]
+        region = next(
+            (x["units_in_region_gte"] for x in win if "units_in_region_gte" in x),
+            None,
+        )
+        assert region is not None, f"{lvl}: win needs a units_in_region_gte clause"
+        assert region["y"] == 28, f"{lvl}: forward zone must be the SOUTH lane"
+
+
+def test_every_level_has_reachable_timeout_fail():
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        L = pack.levels[lvl]
+        ceiling = 93 + 90 * (L.max_turns - 1)
+        wt = next(
+            int(c["within_ticks"])
+            for c in L.win_condition.model_dump()["all_of"]
+            if "within_ticks" in c
+        )
+        ft = next(
+            int(c["after_ticks"])
+            for c in L.fail_condition.model_dump()["any_of"]
+            if "after_ticks" in c
+        )
+        assert wt < ceiling, f"{lvl}: within_ticks {wt} >= ceiling {ceiling}"
+        assert ft <= ceiling, f"{lvl}: after_ticks {ft} > ceiling {ceiling}"
+        assert wt + 1 == ft, f"{lvl}: within/after mismatch {wt}/{ft}"
+
+
+def test_every_level_has_a_fail_condition():
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.fail_condition is not None, f"{lvl} needs a fail_condition"
+
+
+def test_hard_has_two_seed_driven_spawn_groups():
+    c = compile_level(load_pack(PACK), "hard")
+    sp = {
+        (a.spawn_point if a.spawn_point is not None else 0)
+        for a in c.scenario.actors
+        if a.owner == "agent"
+    }
+    assert sp == {0, 1}, f"hard must define spawn_point groups {{0,1}}; got {sorted(sp)}"
+
+
+def test_in_bounds_actors_on_every_level():
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        for a in c.scenario.actors:
+            x, y = a.position
+            assert 2 <= x <= 126 and 2 <= y <= 38, (
+                f"{lvl}: actor {a.type} at ({x},{y}) out of bounds"
+            )
+
+
+# ── predicate-level (no engine) ─────────────────────────────────────
+
+
+def _ctx(*, tick=1000, units_xy=()):
+    import types
+
+    sig = types.SimpleNamespace(
+        game_tick=tick,
+        units_killed=0,
+        units_lost=0,
+        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_enforce_forward_zone_and_gate():
+    pm = compile_level(load_pack(PACK), "medium")
+    # 4 tanks in the south zone, after the gate, in time → WIN
+    south4 = [(62, 28), (61, 27), (63, 29), (60, 28)]
+    assert evaluate(pm.win_condition, _ctx(tick=1000, units_xy=south4))
+    # Same 4 tanks but BEFORE the after_ticks gate → not win
+    assert not evaluate(pm.win_condition, _ctx(tick=300, units_xy=south4))
+    # Only 2 tanks in the south zone (wrong-lane) → not win (need 4)
+    assert not evaluate(pm.win_condition, _ctx(tick=1000, units_xy=south4[:2]))
+    # Past the deadline → fail
+    assert evaluate(pm.fail_condition, _ctx(tick=2402, units_xy=south4))
+
+
+# ── engine-driven: every lazy/wrong policy LOSES, intended WINS ──────
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", SEEDS)
+def test_stall_loses_every_tier_and_seed(level, seed):
+    c = compile_level(load_pack(PACK), level)
+    r = run_level(c, _stall, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level}/seed{seed}: stall must LOSE; got {r.outcome} "
+        f"lost={r.signals.units_lost} tick={r.signals.game_tick}"
+    )
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", SEEDS)
+def test_brute_loses_every_tier_and_seed(level, seed):
+    c = compile_level(load_pack(PACK), level)
+    r = run_level(c, _brute, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level}/seed{seed}: brute must LOSE; got {r.outcome} "
+        f"lost={r.signals.units_lost} tick={r.signals.game_tick}"
+    )
+
+
+@pytest.mark.parametrize("level", ("medium", "hard"))
+@pytest.mark.parametrize("seed", SEEDS)
+def test_wrong_lane_loses_on_multi_tank_zone_tiers(level, seed):
+    """Reinforcing the un-breached NORTH lane leaves the south
+    forward zone two tanks short of the n=4 bar → LOSS on
+    medium/hard."""
+    c = compile_level(load_pack(PACK), level)
+    r = run_level(c, _make_reinforce(12), seed=seed)
+    assert r.outcome == "loss", (
+        f"{level}/seed{seed}: reinforce-wrong-lane must LOSE; got {r.outcome} "
+        f"lost={r.signals.units_lost} tick={r.signals.game_tick}"
+    )
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", SEEDS)
+def test_reinforce_the_breach_wins_every_tier_and_seed(level, seed):
+    """The intended capability — shift the reserve into the breached
+    SOUTH lane — WINS every tier and every hard seed."""
+    c = compile_level(load_pack(PACK), level)
+    r = run_level(c, _make_reinforce(28), seed=seed)
+    assert r.outcome == "win", (
+        f"{level}/seed{seed}: reinforce-the-breach must WIN; got {r.outcome} "
+        f"lost={r.signals.units_lost} tick={r.signals.game_tick}"
+    )
+
+
+def test_reinforce_run_is_deterministic_per_seed():
+    c = compile_level(load_pack(PACK), "medium")
+    a = run_level(c, _make_reinforce(28), seed=2)
+    b = run_level(c, _make_reinforce(28), seed=2)
+    assert (a.outcome, a.turns) == (b.outcome, b.turns)

tests/test_hard_tier.py

@@ -1451,6 +1451,7 @@ UPGRADED = [
     "combat-kite-and-pull",  # hard: 2 agent spawn_point groups (Wave-12)
     "econ-tech-vs-expand-decision",  # hard: 2 agent spawn_point groups (Wave-12)
     "scout-deny-enemy-vision",  # hard: 2 agent spawn_point groups (Wave-12)
+    "def-reinforce-the-breach",  # hard: 2 agent spawn_point groups (Wave-12)
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation