feat(scenario): build-sequence-tech-most-resilient — redundant-prereq tech path survives a strike (PlanBench robust planning anchor)

openra_bench/scenarios/packs/build-sequence-tech-most-resilient.yaml

@@ -0,0 +1,385 @@
+# build-sequence-tech-most-resilient.yaml
+#
+# REASONING capability — Wave-11 robust build-order planning. The
+# agent must REACH a tech capability (a powered war factory) AND
+# KEEP it through a mid-episode strike. The classic resilient-design
+# inversion: a build order that provisions only ONE power plant
+# (`powr`) is a single point of failure — a scheduled enemy strike
+# razes that powr mid-episode and the war factory drops to LOW POWER
+# (the engine's `power_drained > power_provided` gate halves
+# production speed), so the army never completes inside the budget.
+# The resilient build order pre-builds a SECOND, redundant `powr`
+# BEFORE the strike: when the strike razes one plant the other keeps
+# the grid in surplus, production runs at full speed, and the army
+# finishes on the clock.
+#
+# This is the PlanBench "robust planning" idiom — find a plan that
+# achieves the goal AND survives a disturbance — and the classic
+# N+1 resilient-design rule: never run a critical capability on a
+# single point of failure; provision the redundant prerequisite
+# AHEAD of the foreseen failure, not after it.
+#
+# ── ENGINE FACTS verified on the live engine (2026-05-20) ─────────
+#
+#  1. Power model (vendor RA rules, loaded via GameRules::from_ruleset):
+#       POWR  Power +100      PROC  Power -30
+#       WEAP  Power -30       FIX   Power -30      FACT  Power 0
+#     A `World.compute_player_power` recompute sums every live (not
+#     powered-down) building each snapshot. Power budget on the
+#     INTENDED path (pre-placed proc -30, fix -30, exposed powr +100;
+#     agent builds redundant powr +100, weap -30):
+#       before strike:  provided 200, drained 90  → surplus +110
+#       after strike (one powr razed): provided 100, drained 90 → +10
+#     so the resilient base stays in SURPLUS through the strike. On
+#     the SINGLE-powr path (no redundant powr) the strike razes the
+#     only plant: provided 0, drained 90 → drained > provided → LOW
+#     POWER for the rest of the episode.
+#  2. LOW-POWER PRODUCTION SLOWDOWN (world.rs ~L3234): when a player's
+#     `power_drained > power_provided`, the production queue advances
+#     only on odd ticks — 50% speed. This is the load-bearing teeth:
+#     after the strike a single-`powr` base goes low-power and its
+#     `2tnk` queue crawls; a two-`powr` base stays in surplus and
+#     produces at full speed.
+#  3. `2tnk` (medium tank) costs 850; its build prerequisites are
+#     `weap` (war factory) AND `fix` (service depot). `weap`'s
+#     prerequisite is `proc` (ore refinery). `proc` and `fix` are
+#     pre-placed here, so the agent's build task is purely
+#     powr-redundancy + weap + the tank army. (`fix` drains -30
+#     power too — folded into the power budget below.)
+#  4. `scheduled_events: destroy_actors` (Wave-9 engine feature,
+#     oramap.rs::read_scheduled_events / env.rs::fire_scheduled_events)
+#     removes every actor matching `filter:` (owner + optional
+#     circular region) when `world_tick >= tick`. Here it razes the
+#     ONE pre-placed exposed `powr` at tick 1500 — the mid-episode
+#     strike. The region is tight around the exposed powr so it can
+#     never catch the agent's redundant powr in the safe west base.
+#  5. `then:` happened-before composite — clause k latches only after
+#     clause k-1 has been observed true. `[has_building:powr,
+#     has_building:weap]` encodes "power the grid, THEN stand up the
+#     factory" (the engine refuses `weap` before its `proc` prereq;
+#     `powr` is the grid the whole tech path runs on).
+#  6. `building_count_gte` reads the LIVE `own_buildings` list per
+#     frame (NOT the accumulating `own_building_types` set used by
+#     `has_building`). `building_count_gte:{powr,1}` toggles FALSE
+#     the instant the last live `powr` is razed and only re-satisfies
+#     if a redundant `powr` is still standing — this is the redundancy
+#     teeth the win predicate hangs on.
+#  7. `place_building` does NOT enforce build-adjacency (CLAUDE.md);
+#     a `build('powr') + place_building` chain works at arbitrary
+#     in-bounds coords — the redundant powr goes in the safe west
+#     base next to the Construction Yard.
+#  8. The persistent unarmed enemy `fact` marker far east keeps the
+#     engine all-enemies-eliminated auto-`done` path gated, so a
+#     non-winner reaches the deadline as a real LOSS, not a DRAW
+#     (CLAUDE.md engine auto-`done` footgun).
+#  9. Tick alignment (CLAUDE.md): max tick ≈ 93 + 90·(max_turns−1).
+#     easy max_turns 60 → ceiling 5403 ≥ within_ticks 5400, fail
+#     after_ticks 5401 ✓. medium/hard max_turns 50 → ceiling 4503 ≥
+#     within_ticks 4500, fail after_ticks 4501 ✓.
+# 10. Hard `spawn_point` rule (CLAUDE.md oramap.rs): ANY agent actor
+#     with a spawn_point causes agent actors WITHOUT one to be
+#     filtered out — the FULL base (fact + proc + fix + harv +
+#     exposed powr) is DUPLICATED across both spawn groups at
+#     spawn-matched cells. Enemy / neutral actors do NOT honour
+#     spawn_point; the
+#     exposed-powr strike region and the strike geometry are
+#     duplicated per latitude.
+#
+# ── THE BAR (CLAUDE.md "no defect, no cheat") ─────────────────────
+#
+#   • stall (observe only) — builds nothing; the exposed powr is
+#     razed at tick 1500, `weap` is never built, `2tnk` count stays
+#     0 → after_ticks LOSS.
+#   • single-powr (build weap + spam `2tnk`, never a redundant powr)
+#     — relies on the lone exposed powr. The strike razes it at tick
+#     1500; the base drops to low power (drained 60 > provided 0) and
+#     the `2tnk` queue runs at 50% for the rest of the episode.
+#     `building_count_gte:{powr,1}` is FALSE (no live powr) AND the
+#     tank army cannot finish before the deadline → after_ticks
+#     LOSS. This is the single-point-of-failure inversion the pack
+#     is built to catch.
+#   • intended resilient (build a redundant 2nd `powr` in the safe
+#     west base BEFORE the strike, build `weap`, produce 3× `2tnk`)
+#     — the strike razes the exposed powr but the redundant one
+#     survives; the grid stays in surplus, production runs at full
+#     speed, the army finishes on the clock. WIN.
+#
+# Real LOSS not DRAW: `fail after_ticks: T+1` is reachable inside
+# max_turns and the enemy `fact` marker blocks the auto-done path.
+#
+# Validate (no model / no network):
+#   cd /Users/berta/Projects/OpenRA-Bench && \
+#   python3 -m pytest tests/test_build_sequence_tech_most_resilient.py -q
+
+meta:
+  id: build-sequence-tech-most-resilient
+  title: 'Resilient War Factory — Redundant Power Survives a Strike (N+1 Build Order)'
+  capability: reasoning
+  real_world_meaning: >
+    Robust build-order planning: reach a tech capability AND keep it
+    through a foreseeable disturbance. The agent must bring a war
+    factory online and field an armoured force, but a mid-episode
+    enemy strike razes one power plant. A build order that provisions
+    only a single power plant is a single point of failure — when the
+    strike lands the factory drops to low power and the army never
+    completes in time. The resilient build order pre-builds a second,
+    redundant power plant before the strike, so the grid stays in
+    surplus and production never slows. Tests whether the model plans
+    for the disturbance (N+1 redundancy on the critical prerequisite)
+    rather than merely planning the shortest path to the goal.
+  robotics_analogue: >
+    N+1 redundancy on a critical utility. An autonomous production
+    cell depends on a power feed to run its assembly machine; a known
+    hazard will knock out one feed mid-shift. Resilient planning
+    commissions a second, independent feed BEFORE the outage, so the
+    assembly machine never drops below rated throughput. Provisioning
+    only one feed — the shortest plan to first article — halts the
+    line the moment the hazard strikes and blows the delivery
+    deadline.
+  benchmark_anchor:
+    - "PlanBench robust planning"
+    - "N+1 resilient design"
+    - "redundancy"
+  author: openra-bench-wave-11
+
+# rush-hour-arena: 128×40, playable bounds (2,2,124,36). Agent base
+# at the WEST (x≈8..20). The inherited exposed `powr` sits forward at
+# the EAST edge of the base; a scheduled strike razes it at tick 1500.
+# The redundant `powr` belongs in the safe west base next to `fact`.
+base_map: rush-hour-arena
+
+base:
+  agent: {faction: allies}
+  # No scripted bot — the only threat is the scripted `destroy_actors`
+  # strike on the exposed powr. A hunt bot would turn an N+1 build-
+  # order test into a combat-survival test.
+  enemy: {faction: soviet, bot_type: ''}
+  # Build palette: build + place_building drive the redundant powr
+  # and the war factory + tank army; harvest keeps income credible;
+  # move_units + stop allow repositioning. No offensive verbs — this
+  # is a build-order planning pack.
+  tools: [observe, build, place_building, harvest, move_units, stop]
+  spawn_mcvs: false
+  planning: true
+  termination: {max_ticks: 8000}
+  actors: []
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Bare skill: recognise that the inherited exposed power plant is a
+  # single point of failure that WILL be razed, pre-build a redundant
+  # `powr` in the safe west base, build the war factory, field 3
+  # tanks. Generous clock (within_ticks 5400, max_turns 60 → ceiling
+  # 5403 ✓). The strike fires at tick 1500.
+  easy:
+    description: >
+      You inherit a partial base — a Construction Yard ('fact'), an
+      Ore Refinery ('proc'), a Service Depot ('fix'), an Ore Truck
+      ('harv') with an ore patch, and ONE Power Plant ('powr'). That
+      power plant sits FORWARD at the east edge of your base and is
+      EXPOSED: an enemy strike will RAZE it at tick 1500. It is your
+      only power. If it is your only power when the strike lands,
+      your grid goes negative, your war factory drops to half
+      production speed, and your tank army cannot finish in time. To
+      stay resilient: build a SECOND Power Plant ('build' "powr",
+      cost 300) and place it next to your Construction Yard in the
+      safe west base BEFORE tick 1500, build a War Factory ('build'
+      "weap", cost 2000), then produce three medium tanks ('build'
+      "2tnk", cost 850 each). WIN = you brought power then a war
+      factory online, you still own a Power Plant, you have 3 medium
+      tanks, and you still own your Construction Yard, before tick
+      5400. Stalling, or relying on the single exposed power plant
+      with no redundant backup, misses the bar.
+    starting_cash: 6000
+    overrides:
+      actors:
+        # ── Safe WEST base ─────────────────────────────────────────
+        - {type: fact, owner: agent, position: [8, 18]}
+        - {type: proc, owner: agent, position: [12, 18]}
+        # Service Depot — the `2tnk` build prerequisite (alongside
+        # `weap`). Pre-placed so the agent's build task is purely the
+        # redundant powr + war factory + tank army.
+        - {type: fix,  owner: agent, position: [16, 18]}
+        # Income (credible, not load-bearing for the win predicate).
+        - {type: harv, owner: agent, position: [12, 22]}
+        - {type: mine, owner: neutral, position: [20, 22]}
+        # ── The EXPOSED single-point-of-failure Power Plant ────────
+        # Forward at the east edge of the base. Razed by the tick-1500
+        # `destroy_actors` strike. Far enough from the west base that
+        # the strike region can never catch a redundant powr placed
+        # next to the Construction Yard.
+        - {type: powr, owner: agent, position: [40, 18]}
+        # Persistent far enemy marker — LOSS-not-DRAW guarantee.
+        - {type: fact, owner: enemy, position: [115, 30]}
+      scheduled_events:
+        # Mid-episode strike: raze the exposed forward Power Plant at
+        # tick 1500. The region is a tight circle around (40,18); the
+        # safe west base (x≈8..16) is ~24 cells away, well outside
+        # radius 6, so a redundant powr there is never caught.
+        - tick: 1500
+          type: destroy_actors
+          filter:
+            owner: agent
+            region: {x: 40, y: 18, radius: 6}
+    win_condition:
+      all_of:
+        # Reach the tech capability IN ORDER: power the grid, then
+        # stand up the war factory.
+        - then:
+            id: bsr-easy
+            clauses:
+              - {has_building: powr}
+              - {has_building: weap}
+        # ≥1 Power Plant ALIVE at end — FALSE after the strike unless
+        # a redundant powr was built (the redundancy teeth).
+        - building_count_gte: {type: powr, n: 1}
+        # 3 medium tanks — only reachable at FULL production speed,
+        # i.e. with the grid kept in surplus through the strike.
+        - unit_type_count_gte: {type: '2tnk', n: 3}
+        # Construction Yard alive (mirrors the fail clause).
+        - building_count_gte: {type: fact, n: 1}
+        - within_ticks: 5400
+    fail_condition:
+      any_of:
+        - after_ticks: 5401
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 60
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 controlled variable: the clock tightens (within_ticks 4500,
+  # max_turns 50 → ceiling 4503 ✓). The resilient N+1 build order
+  # still wins comfortably, but a hesitant opening that dallies
+  # before committing the redundant powr now risks the deadline. The
+  # single-point-of-failure failure modes lose exactly as on easy.
+  medium:
+    description: >
+      Same inherited base as easy — a Construction Yard, an Ore
+      Refinery, a Service Depot, an Ore Truck with an ore patch, and
+      ONE EXPOSED Power Plant forward at the east edge that an enemy
+      strike will RAZE at tick 1500. Build a SECOND Power Plant
+      ('build' "powr", 300) in the safe west base next to your
+      Construction Yard BEFORE tick 1500, build a War Factory
+      ('build' "weap", 2000), then produce three medium tanks
+      ('build' "2tnk", 850 each).
+      The deadline is tighter — tick 4500 — so commit the redundant
+      power plant early; do not wait for the exposed one to fall. If
+      the strike leaves you with no power, the war factory halves its
+      output and the army misses the clock. WIN = you brought power
+      then a war factory online, you still own a Power Plant, you
+      have 3 medium tanks, and you still own your Construction Yard,
+      before tick 4500. Stalling, or relying on the single exposed
+      power plant, misses the bar.
+    starting_cash: 6000
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [8, 18]}
+        - {type: proc, owner: agent, position: [12, 18]}
+        - {type: fix,  owner: agent, position: [16, 18]}
+        - {type: harv, owner: agent, position: [12, 22]}
+        - {type: mine, owner: neutral, position: [20, 22]}
+        - {type: powr, owner: agent, position: [40, 18]}
+        - {type: fact, owner: enemy, position: [115, 30]}
+      scheduled_events:
+        - tick: 1500
+          type: destroy_actors
+          filter:
+            owner: agent
+            region: {x: 40, y: 18, radius: 6}
+    win_condition:
+      all_of:
+        - then:
+            id: bsr-medium
+            clauses:
+              - {has_building: powr}
+              - {has_building: weap}
+        - building_count_gte: {type: powr, n: 1}
+        - unit_type_count_gte: {type: '2tnk', n: 3}
+        - building_count_gte: {type: fact, n: 1}
+        - within_ticks: 4500
+    fail_condition:
+      any_of:
+        - after_ticks: 4501
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 50
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 controlled variable on top of medium: TWO seed-driven AGENT
+  # spawn_point groups (NORTH base y=12 / SOUTH base y=26) round-
+  # robined by seed. Per CLAUDE.md `spawn_point` rules: ANY agent
+  # actor with spawn_point ⇒ agent actors WITHOUT one are filtered
+  # out, so the FULL base (fact + proc + fix + harv + exposed powr)
+  # is DUPLICATED across both spawn groups at spawn-matched cells.
+  # Enemy / neutral actors do NOT honour spawn_point; the strike
+  # region is duplicated per latitude (a `destroy_actors` whose
+  # region misses the active base simply removes nothing). A
+  # memorised "place the redundant powr at (11,18)" opening cannot
+  # generalise — the agent must read the actual Construction Yard
+  # latitude and place the redundant power plant beside it.
+  hard:
+    description: >
+      Same N+1 build-order task as medium (one EXPOSED Power Plant
+      forward at the east edge that an enemy strike razes at tick
+      1500, $6000, tick 4500 deadline) but your base may begin in
+      the NORTH band (y≈12) OR the SOUTH band (y≈26) of the map
+      depending on the seed. Read the Construction Yard's actual
+      position from the observation and place the redundant Power
+      Plant beside it in the safe west base BEFORE tick 1500; build a
+      War Factory; then produce three medium tanks. A memorised
+      placement cell will mis-place out of build radius on one of the
+      two spawns. WIN = you brought power then a war factory online,
+      you still own a Power Plant, you have 3 medium tanks, and you
+      still own your Construction Yard, before tick 4500. The same
+      single-point-of-failure plays — stalling, or relying on the
+      lone exposed power plant — lose as on medium.
+    starting_cash: 6000
+    overrides:
+      actors:
+        # ── SPAWN 0 (NORTH base, y=12) ─────────────────────────────
+        - {type: fact, owner: agent, position: [8, 12],  spawn_point: 0}
+        - {type: proc, owner: agent, position: [12, 12], spawn_point: 0}
+        - {type: fix,  owner: agent, position: [16, 12], spawn_point: 0}
+        - {type: harv, owner: agent, position: [12, 16], spawn_point: 0}
+        - {type: powr, owner: agent, position: [40, 12], spawn_point: 0}
+        # ── SPAWN 1 (SOUTH base, y=26) ─────────────────────────────
+        - {type: fact, owner: agent, position: [8, 26],  spawn_point: 1}
+        - {type: proc, owner: agent, position: [12, 26], spawn_point: 1}
+        - {type: fix,  owner: agent, position: [16, 26], spawn_point: 1}
+        - {type: harv, owner: agent, position: [12, 30], spawn_point: 1}
+        - {type: powr, owner: agent, position: [40, 26], spawn_point: 1}
+        # Neutral ore patches — one per latitude (neutral actors
+        # ignore the spawn_point filter, like enemy actors).
+        - {type: mine, owner: neutral, position: [20, 16]}
+        - {type: mine, owner: neutral, position: [20, 30]}
+        # Persistent far enemy marker — LOSS-not-DRAW guarantee.
+        - {type: fact, owner: enemy, position: [115, 33]}
+      scheduled_events:
+        # Strike regions DUPLICATED per latitude (enemy/neutral and
+        # scheduled events do not honour spawn_point). The region
+        # matching the dormant latitude removes nothing; the one
+        # matching the active base razes its exposed powr.
+        - tick: 1500
+          type: destroy_actors
+          filter:
+            owner: agent
+            region: {x: 40, y: 12, radius: 6}
+        - tick: 1500
+          type: destroy_actors
+          filter:
+            owner: agent
+            region: {x: 40, y: 26, radius: 6}
+    win_condition:
+      all_of:
+        - then:
+            id: bsr-hard
+            clauses:
+              - {has_building: powr}
+              - {has_building: weap}
+        - building_count_gte: {type: powr, n: 1}
+        - unit_type_count_gte: {type: '2tnk', n: 3}
+        - building_count_gte: {type: fact, n: 1}
+        - within_ticks: 4500
+    fail_condition:
+      any_of:
+        - after_ticks: 4501
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 50

tests/test_build_sequence_tech_most_resilient.py

@@ -0,0 +1,352 @@
+"""build-sequence-tech-most-resilient pack — full no-cheat validation.
+
+Wave-11 REASONING — robust build-order planning. The agent must REACH
+a tech capability (a powered war factory) AND KEEP it through a
+mid-episode strike. A scheduled `destroy_actors` event razes the one
+exposed power plant at tick 1500. A build order that provisions only
+ONE `powr` is a single point of failure — when the strike lands the
+grid goes negative, the war factory drops to 50% production speed
+(engine low-power slowdown) and `building_count_gte:{powr,1}` is
+FALSE for the rest of the episode. The resilient build order
+pre-builds a SECOND, redundant `powr` in the safe west base BEFORE
+the strike: one plant survives, the grid stays in surplus, the army
+finishes on the clock.
+
+Bar (CLAUDE.md "no defect, no cheat"):
+  - stall (observe only)            ⇒ LOSS on every (level, seed)
+  - single-powr (no redundant powr) ⇒ LOSS on every (level, seed)
+  - intended resilient (redundant   ⇒ WIN  on every (level, seed)
+    2nd powr, then weap, then 3×2tnk)
+Real LOSS not DRAW: `fail after_ticks:T+1` reachable inside
+max_turns; the persistent far enemy `fact` blocks the engine
+auto-done path.
+
+Scenario shape:
+  - rush-hour-arena, allies vs soviet (bot disabled).
+  - easy:   within_ticks 5400, max_turns 60 — generous.
+  - medium: within_ticks 4500, max_turns 50 — tighter clock.
+  - hard:   within_ticks 4500, max_turns 50 — +2 spawn_point groups
+            (NORTH base y=12 / SOUTH base y=26, round-robined).
+
+Measured (seed 1, scripted policies): the intended resilient policy
+WINS at ~tick 3243 on every level; stall and single-powr LOSE on the
+deadline.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+
+from openra_bench.eval_core import run_level
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+
+PACK = PACKS_DIR / "build-sequence-tech-most-resilient.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+
+# ── Policies ──────────────────────────────────────────────────────
+
+
+def _stall_policy():
+    """Do nothing — must LOSE on the clock on every level/seed."""
+    def pol(obs, Cmd):
+        return [Cmd.observe()]
+    return pol
+
+
+def _single_powr_policy():
+    """Single-point-of-failure play: build the war factory and spam
+    `2tnk`, but NEVER build a redundant power plant. The lone exposed
+    `powr` is razed at tick 1500 → the grid goes negative → 50%
+    production AND `building_count_gte:{powr,1}` is false → LOSS."""
+    ms = {"weap": False}
+
+    def pol(obs, Cmd):
+        ob = obs.get("own_buildings", []) or []
+        own = {b["type"] for b in ob}
+        prod = obs.get("production", []) or []
+        base = [b for b in ob if b["type"] == "fact"]
+        cmds = []
+        if "weap" in own:
+            ms["weap"] = True
+        if not ms["weap"]:
+            if "weap" not in prod:
+                cmds.append(Cmd.build("weap"))
+            if base:
+                cmds.append(Cmd.place_building(
+                    "weap", base[0]["cell_x"] + 5, base[0]["cell_y"]
+                ))
+        else:
+            if "2tnk" not in prod:
+                cmds.append(Cmd.build("2tnk"))
+        return cmds or [Cmd.observe()]
+    return pol
+
+
+def _intended_policy():
+    """Resilient N+1 build order: build a redundant `powr` in the safe
+    west base (placed relative to the actual Construction Yard so it
+    generalises across the hard-tier spawn variation), then the war
+    factory, then 3× `2tnk`. Must WIN on every (level, seed)."""
+    ms = {"powr2": False, "weap": False}
+
+    def pol(obs, Cmd):
+        ob = obs.get("own_buildings", []) or []
+        prod = obs.get("production", []) or []
+        base = [b for b in ob if b["type"] == "fact"]
+        # The redundant powr lives in the safe west base (x<30);
+        # the exposed inherited powr sits forward at x=40.
+        safe_powr = [
+            b for b in ob if b["type"] == "powr" and b["cell_x"] < 30
+        ]
+        weap_b = [b for b in ob if b["type"] == "weap"]
+        cmds = []
+        if safe_powr:
+            ms["powr2"] = True
+        if weap_b:
+            ms["weap"] = True
+        if not ms["powr2"]:
+            if "powr" not in prod:
+                cmds.append(Cmd.build("powr"))
+            if base:
+                cmds.append(Cmd.place_building(
+                    "powr", base[0]["cell_x"] + 3, base[0]["cell_y"] + 4
+                ))
+        elif not ms["weap"]:
+            if "weap" not in prod:
+                cmds.append(Cmd.build("weap"))
+            if base:
+                cmds.append(Cmd.place_building(
+                    "weap", base[0]["cell_x"] + 6, base[0]["cell_y"]
+                ))
+        else:
+            if "2tnk" not in prod:
+                cmds.append(Cmd.build("2tnk"))
+        return cmds or [Cmd.observe()]
+    return pol
+
+
+# ── Pack-shape tests (cheap; do not run the engine) ──────────────
+
+
+def test_pack_compiles_with_three_levels():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "build-sequence-tech-most-resilient"
+    assert pack.meta.capability == "reasoning"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+
+
+def test_meta_benchmark_anchor_set():
+    """meta.benchmark_anchor must cite PlanBench robust planning,
+    N+1 resilient design and redundancy (the seed taxonomy)."""
+    pack = load_pack(PACK)
+    anchors = pack.meta.benchmark_anchor or []
+    assert any("PlanBench" in a for a in anchors), anchors
+    assert any("N+1" in a or "resilient" in a for a in anchors), anchors
+    assert any("redundancy" in a.lower() for a in anchors), anchors
+
+
+def test_every_level_has_fail_condition():
+    """No silent draws — every level must be able to emit a LOSS."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.fail_condition is not None, f"{lvl} missing fail_condition"
+
+
+def test_then_composite_used_in_win():
+    """The win must wire the powr→weap happened-before chain — the
+    'reach the tech capability in order' clause."""
+    for lvl in LEVELS:
+        c = compile_level(load_pack(PACK), lvl)
+        win = c.win_condition.model_dump(exclude_none=True)
+        inner = win.get("all_of") or []
+        then = next((cl["then"] for cl in inner if "then" in cl), None)
+        assert then is not None, f"{lvl} win missing then-chain: {win}"
+        clauses = then.get("clauses") or []
+        assert len(clauses) == 2, (
+            f"{lvl} then-chain must be powr→weap (2 clauses); got {clauses}"
+        )
+        assert clauses[0].get("has_building") == "powr"
+        assert clauses[1].get("has_building") == "weap"
+
+
+def test_win_requires_surviving_powr_three_tanks_and_fact():
+    """Structural: the win clause must require a LIVE Power Plant
+    (`building_count_gte:{powr,1}` — the redundancy teeth that toggle
+    FALSE when the exposed powr is razed), three medium tanks
+    (`unit_type_count_gte:{2tnk,3}`), a live Construction Yard, and a
+    `within_ticks` deadline. `building_count_gte` (live-list) — NOT
+    `has_building` (accumulating set) — is mandatory for the powr
+    clause so it toggles false on the strike."""
+    for lvl in LEVELS:
+        c = compile_level(load_pack(PACK), lvl)
+        all_of = c.win_condition.model_dump(exclude_none=True).get("all_of", [])
+        powr = next(
+            (x["building_count_gte"] for x in all_of
+             if "building_count_gte" in x
+             and (x["building_count_gte"] or {}).get("type") == "powr"),
+            None,
+        )
+        assert powr is not None and int(powr.get("n", 0)) >= 1, (
+            f"{lvl}: win must require building_count_gte powr>=1 "
+            f"(a live power plant survives the strike)"
+        )
+        tanks = next(
+            (x["unit_type_count_gte"] for x in all_of
+             if "unit_type_count_gte" in x
+             and (x["unit_type_count_gte"] or {}).get("type") == "2tnk"),
+            None,
+        )
+        assert tanks is not None and int(tanks.get("n", 0)) >= 3, (
+            f"{lvl}: win must require unit_type_count_gte 2tnk>=3"
+        )
+        fact = next(
+            (x["building_count_gte"] for x in all_of
+             if "building_count_gte" in x
+             and (x["building_count_gte"] or {}).get("type") == "fact"),
+            None,
+        )
+        assert fact is not None and int(fact.get("n", 0)) >= 1, (
+            f"{lvl}: win must require building_count_gte fact>=1"
+        )
+        assert any("within_ticks" in x for x in all_of), (
+            f"{lvl}: win must include a within_ticks deadline"
+        )
+
+
+def test_tick_budget_aligned_with_max_turns():
+    """within_ticks must be reachable inside max_turns and the fail
+    `after_ticks` must equal within_ticks+1 (real LOSS, no draw, no
+    overlap). Engine advances ~90 ticks/turn → reachable = 93 +
+    90·(max_turns-1)."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        reachable = 93 + 90 * (c.max_turns - 1)
+        all_of = c.win_condition.model_dump(exclude_none=True).get("all_of", [])
+        wt = next(int(x["within_ticks"]) for x in all_of if "within_ticks" in x)
+        assert wt <= reachable, (
+            f"{lvl}: within_ticks={wt} > reachable={reachable} "
+            f"(max_turns={c.max_turns}) — deadline never bites"
+        )
+        fail = c.fail_condition.model_dump(exclude_none=True)
+        after = next(
+            int(x["after_ticks"]) for x in fail["any_of"] if "after_ticks" in x
+        )
+        assert after <= reachable, (
+            f"{lvl}: fail after_ticks {after} unreachable within "
+            f"{c.max_turns} turns (max {reachable}) — draw degeneracy"
+        )
+        assert after == wt + 1, (
+            f"{lvl}: after_ticks {after} must equal within_ticks+1 ({wt+1})"
+        )
+
+
+def test_exactly_one_exposed_powr_pre_placed():
+    """The single-point-of-failure premise: each tier pre-places
+    EXACTLY ONE agent `powr` (the exposed forward plant). The
+    redundant second power plant must be BUILT by the agent — it is
+    not given. Hard duplicates the base across two spawn groups, so
+    each spawn group still ships exactly one exposed powr."""
+    for lvl in LEVELS:
+        c = compile_level(load_pack(PACK), lvl)
+        powrs = [
+            a for a in c.scenario.actors
+            if a.owner == "agent" and a.type == "powr"
+        ]
+        if lvl == "hard":
+            per_spawn = {}
+            for a in powrs:
+                sp = a.spawn_point if a.spawn_point is not None else 0
+                per_spawn[sp] = per_spawn.get(sp, 0) + 1
+            assert per_spawn and all(v == 1 for v in per_spawn.values()), (
+                f"hard: each spawn group must pre-place exactly one "
+                f"exposed powr; got {per_spawn}"
+            )
+        else:
+            assert len(powrs) == 1, (
+                f"{lvl}: must pre-place exactly one exposed agent powr; "
+                f"got {len(powrs)}"
+            )
+
+
+def test_scheduled_destroy_event_razes_the_exposed_powr():
+    """Each tier must declare a `scheduled_events: destroy_actors`
+    that fires mid-episode (before the deadline) on the agent, with a
+    region tight around the exposed forward powr (x≈40) so it can
+    never catch a redundant powr placed in the safe west base."""
+    for lvl in LEVELS:
+        c = compile_level(load_pack(PACK), lvl)
+        evs = c.scheduled_events or []
+        destroys = [e for e in evs if e.get("type") == "destroy_actors"]
+        assert destroys, f"{lvl}: needs a destroy_actors scheduled event"
+        for e in destroys:
+            assert e["filter"]["owner"] == "agent"
+            reg = e["filter"]["region"]
+            assert reg["x"] == 40, (
+                f"{lvl}: strike region must be centred on the exposed "
+                f"forward powr at x=40; got {reg}"
+            )
+            assert e["tick"] < 4500, (
+                f"{lvl}: strike must fire mid-episode (before the "
+                f"deadline); got tick {e['tick']}"
+            )
+
+
+def test_hard_tier_has_seed_driven_spawn_groups():
+    """Hard must define >=2 agent spawn_point groups so the seed
+    varies the start base (tests/test_hard_tier.py::UPGRADED)."""
+    c = compile_level(load_pack(PACK), "hard")
+    sp = {a.spawn_point for a in c.scenario.actors if a.owner == "agent"}
+    assert len(sp) >= 2, f"hard needs >=2 spawn groups, got {sp}"
+
+
+# ── Engine-bound tests (parameterised over seeds 1..4) ────────────
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_intended_resilient_policy_wins(level, seed):
+    """The intended resilient play (redundant 2nd powr → weap → 3×
+    2tnk) must WIN on every (level, seed). The load-bearing test that
+    the pack is solvable inside the budget by the advertised
+    robust-planning capability."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _intended_policy(), seed=seed)
+    assert res.outcome == "win", (
+        f"intended resilient must WIN on {level} s={seed}; got "
+        f"{res.outcome} (tick={res.signals.game_tick}, "
+        f"buildings={sorted(res.signals.own_building_types)})"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_stall_policy_loses(level, seed):
+    """A stall (observe-only) builds nothing — the exposed powr is
+    razed, no weap, no tanks → must LOSE on every (level, seed)."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _stall_policy(), seed=seed)
+    assert res.outcome == "loss", (
+        f"stall must LOSE on {level} s={seed}; got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_single_powr_policy_loses(level, seed):
+    """The single-point-of-failure play — build the war factory and
+    produce tanks but NEVER a redundant power plant — must LOSE on
+    every (level, seed): the strike razes the lone powr, so
+    `building_count_gte:{powr,1}` is false at the deadline."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _single_powr_policy(), seed=seed)
+    assert res.outcome == "loss", (
+        f"single-powr (no redundancy) must LOSE on {level} s={seed}; "
+        f"got {res.outcome} (tick={res.signals.game_tick})"
+    )