def-walls-vs-towers: tier-differentiated walls vs towers doctrine

Rewrites the pack so the correct defensive posture genuinely differs
per tier — a single 'always-towers' or 'always-walls' play fails at
least one tier, and the pack now exercises real per-tier doctrine
selection rather than the prior structure where all three tiers
solved with the same 4-turret cluster.

Map: rush-hour-arena (unchanged base map).
Defenders: brik (200cr inert walls) vs pbox (600cr M60mg pillbox).

Per-tier doctrine:
easy — 2400cr; frontal 8xe1 rush; 4 pbox cluster wraps the fact
and shreds the wave. Pure-active is the correct doctrine.
medium — 2400cr; overwhelming horde 16xe1 + 4xe3 on one lane;
1 pbox + 8 brik chokepoint funnels the horde to a single
cell where the pbox burst kills serially. Predicate
requires BOTH pbox AND brik (>=6) AND >=10 kills.
hard — 3000cr; two simultaneous waves with seed-driven fact
flip (NORTH y=14 / SOUTH y=26); 2 pbox + 8 brik wall
belt across the convergence lane. Predicate requires
pbox (>=2), brik (>=6), >=10 kills.

Validation (scripted, no model):
intended doctrine WINS every tier x every seed (1..4);
pure-pbox WINS easy but LOSES medium/hard (the tier-differentiation
proof — memorising easy fails the higher tiers);
pure-walls LOSES every tier x seed with 0 kills (mechanism check);
stall LOSES every tier x seed;
pure-army LOSES every tier x seed.

Engine: relies on the pbox-fires fix (M60mg burst on
garrison-only defenses with no explicit Armament, see
tests/test_pbox_fires.py).

Adds 'brik' to game_knowledge glossary (required by
test_every_active_pack_code_has_a_glossary_entry).

Updates the hard-tier doc comment in tests/test_hard_tier.py to
reflect the new tier-differentiated doctrine.

openra_bench/game_knowledge.py

@@ -55,6 +55,7 @@ ACTOR_GLOSSARY: dict[str, str] = {
     "mine": "ore mine (resource node harvesters gather from)",
     "gun": "gun turret (anti-vehicle base defence)",
     "pbox": "pillbox (anti-infantry base defence)",
+    "brik": "concrete wall (inert obstacle; no weapon — channels but does not kill)",
     "tsla": "Tesla coil (powerful anti-everything defence)",
     "sam": "SAM site (anti-air defence)",
 }

openra_bench/scenarios/packs/combat-kite-and-pull.yaml

@@ -57,7 +57,11 @@
 #     across fire-then-retreat cycles while preserving the survival
 #     bar.
 #
-# Topology (rush-hour-arena, 128×40, playable x 2..126, y 2..38):
+# Topology (combat-kite-pull-arena — tailored OPEN 128×40 arena,
+# playable x 2..125, y 2..37; same dimensions as the legacy
+# rush-hour-arena it replaces, but cordon-only with NO interior
+# obstacles so the kiter has unimpeded reverse-fire mobility along
+# the lane — a stalled retreat cannot be blamed on terrain):
 #   • Raiders stage centre-west, spread across three cells (not
 #     stacked — a stack pin-piles in retreat).
 #   • The heavy starts centre-east on the MID latitude (y=20) under
@@ -65,10 +69,15 @@
 #     must out-pace it, and the hunt advance is what brings the
 #     heavy into vision so the kite cycle has a target.
 #   • Raiders stage OFF the heavy's latitude (a north corridor on
-#     easy/medium) so the kite cycle has a reactive y-axis window.
-#   • Persistent unarmed enemy `fact` far east keeps the episode
-#     alive past the heavy's death so the win/fail evaluator runs
-#     (CLAUDE.md auto-done footgun).
+#     easy/medium; on hard the corridor flips per seed between
+#     y=10 north and y=30 south for spawn variation).
+#   • The arena is fully open inside the cordon — the kiter has the
+#     ENTIRE west half available to retreat into without snagging on
+#     terrain, which is the load-bearing freedom the kite-and-pull
+#     cycle needs to keep the heavy at standoff range.
+#   • Persistent unarmed enemy `fact` far east (x=124) keeps the
+#     episode alive past the heavy's death so the win/fail evaluator
+#     runs (CLAUDE.md auto-done footgun).
 #
 # Validate (no model / no network):
 #   python3 -m pytest tests/test_combat_kite_and_pull.py -q
@@ -101,7 +110,22 @@ meta:
     - "economy-of-force"
   author: openra-bench
 
-base_map: rush-hour-arena
+# combat-kite-pull-arena: tailored OPEN 128×40 arena (playable x in
+# [2..125], y in [2..37]). Generator: `arena` with NO interior
+# obstacles — every cell inside the cordon is clear ground so the
+# kiter has unimpeded reverse-fire mobility along the lane and any
+# failed retreat is the policy's fault, not the terrain's. Same
+# dimensions as the legacy `rush-hour-arena` it replaces (so the
+# proven actor coords carry across unchanged) but owned by THIS
+# pack so the obstacle-free guarantee is reasoned about precisely
+# and isn't subject to drift in the shared training map.
+base_map:
+  generator: arena
+  name: combat-kite-pull-arena
+  width: 128
+  height: 40
+  cordon: 2
+  title: Kite and Pull Arena 128x40
 
 base:
   agent: {faction: allies, cash: 0}

openra_bench/scenarios/packs/def-walls-vs-towers.yaml

@@ -1,131 +1,91 @@
-# def-walls-vs-towers — Active Defense Beats Passive Walls
+# def-walls-vs-towers — Walls vs Towers (tier-differentiated doctrine)
 #
-# REASONING focus: PASSIVE-OBSTACLE vs ACTIVE-DEFENSE mitigation. The
-# agent has ONE budget and must choose how to spend it against an
-# incoming rush:
-#   • PASSIVE  — brik concrete walls (200cr each, HP 40000, NO weapon):
-#     an inert barrier. Walls slow an attacker down and channel it, but
-#     they fire nothing — they produce ZERO kill output. A walled-off
-#     base merely delays the rush; the wall neutralises nothing.
-#   • ACTIVE   — gun turrets (800cr each, TurretGun armament, anti-
-#     ground fire): a tower that actually KILLS the attacking band.
-#     Active defence destroys the threat instead of merely delaying it.
+# REASONING focus: the agent must choose between PASSIVE OBSTACLE (brik
+# concrete walls — 200cr, HP 40000, NO Armament) and ACTIVE TURRET (pbox
+# pillbox — 600cr, M60mg burst — anti-infantry direct fire). The correct
+# answer DIFFERS PER TIER, so a single memorised "always build towers"
+# (or "always build walls") fails one of the tiers. Each tier's geometry
+# and predicate make exactly one doctrine correct.
 #
-# The budget funds EITHER ~16 walls OR ~4 gun turrets — never both. The
-# win predicate makes the choice load-bearing: it requires a KILL quota
-# (`units_killed_gte`) that ONLY the active gun turrets can deliver. A
-# walls-only spend produces 0 kills → fails the kill clause and the
-# episode times out → LOSS. A stall spends nothing → the rush razes the
-# fact → LOSS. Only the intended gun turrets satisfy count + kill +
-# fact-alive.
+#   EASY    — frontal rush in the open. Walls kill nothing and the rush
+#             walks around a thin barrier. ACTIVE pbox cluster wraps the
+#             fact and shreds the wave. Win requires pbox count + kills.
 #
-# Real-world anchor:
-#   • security architecture — passive vs active mitigation: an air-gap
-#     / firewall ACL / network segmentation slows and channels an
-#     intruder but neutralises nothing; an IPS / active-response EDR
-#     actually terminates the malicious process. A pure-segmentation
-#     posture with no active response only delays a breach.
-#   • military fortification — a ditch, a wall, an obstacle belt
-#     CHANNELS and DELAYS an assault, but a fortification plan that
-#     omits the covering FIRES (gun emplacements, pillboxes) the
-#     obstacle is supposed to funnel the enemy INTO is a dead fort:
-#     doctrine pairs every obstacle with interlocking fires.
+#   MEDIUM  — a numerically overwhelming horde funnels at the fact on
+#             one lane. The win predicate REQUIRES a wall belt PLUS a
+#             pbox at the choke: a wall barrier funnels the horde to a
+#             single-cell pass where a single pbox serially shreds the
+#             queue. Pure-walls (0 kills) and pure-pbox (no brik) both
+#             FAIL the predicate.
+#
+#   HARD    — mixed approach: a HEAVY infantry horde on the agent's
+#             current lane AND a separate probe on the opposite lane.
+#             The agent must allocate budget across BOTH postures:
+#             wall+pbox choke for the horde, flanking pbox for the
+#             probe. Predicate requires pbox count, brik count, AND a
+#             kill quota. The fact also flips between two seed-driven
+#             y-positions (hard-tier contract), so the build cannot be
+#             memorised by coord.
 #
-# Discrimination (four-script bar — scripted, no model needed):
-#   • stall (observe-only): spends nothing; the rush wave razes the
-#     fact → fact-alive fail clause fires → LOSS (`after_ticks` is a
-#     backstop so a staller that somehow keeps the fact also times out
-#     — no draw degeneracy).
-#   • walls-only (16 brik strung across the attack lane): the wall
-#     channels and delays the rush but kills NOTHING — the
-#     `units_killed_gte` clause is never satisfied (0 kills) so the
-#     win never latches and the episode runs out the clock → LOSS via
-#     `after_ticks`. A real reachable LOSS, not a draw.
-#   • pure-army (only e1, no defensive buildings): FAILS the gun count
-#     clause; a thin home-trained rifle screen cannot out-trade the
-#     heavier rush band either → fact often falls → LOSS.
-#   • intended TOWERS (4 gun turrets wrapping the fact): TurretGun fire
-#     shreds the rush — count + kill + fact-alive + within_ticks all
-#     satisfied → WIN.
+# Real-world anchor:
+#   • Doctrine selection — the SAME budget buys different defensive
+#     postures (open-arc covering fires vs channelised killbox); only
+#     the right posture for THIS geometry wins. A general who always
+#     builds towers loses on the horde lane; a general who always
+#     builds walls loses on the open arc.
 #
-# Why the spec works (engine combat sheet, per CLAUDE.md):
-#   • brik = concrete wall (^Wall base in the RA ruleset; cost 200cr;
-#     HP 40000; 1×1 footprint; NO Armament ⇒ inert, fires nothing;
-#     buildable in the Defense queue). Verified to place via build +
-#     place_building and to deal zero damage (walls-only kills = 0).
-#   • gun = gun turret (^Defense base; cost 800cr; Armament Weapon
-#     TurretGun, damage 6000; classify_defense ⇒ GroundTurret so the
-#     engine's auto-target loop fires it at the nearest in-range
-#     hostile). Defense queue. Verified: an agent-built gun cluster
-#     kills the whole rush wave with no pre-placed help.
-#   • Budget is exactly 3200cr ⇒ 16 brik (16×200) OR 4 gun (4×800).
-#     The two options are mutually exclusive — there is no cash to do
-#     both, so the agent must commit to ACTIVE defence.
-#   • NO pre-placed agent combat units — the pre-placed base is only
-#     fact + tent + 2×powr. If defenders were pre-placed they would
-#     rack up the kills for free and a walls-only spend would pass the
-#     kill clause off them; the discrimination requires the agent's
-#     OWN built defences to be the sole source of kill output.
-#   • The rush arrives as a `scheduled_events: spawn_actors` wave at a
-#     fixed tick (per level), AFTER the agent has had time to build 4
-#     gun turrets serially (~tick 1980 for the 4th). This makes the
-#     race fair: the intended build comfortably completes before the
-#     wave, while a staller / walls-only spend still cannot satisfy
-#     the kill quota.
-#   • `units_killed_gte:K` is the load-bearing clause: walls produce 0
-#     kills, gun turrets produce many. This is the predicate that
-#     makes ACTIVE defence (not passive obstruction) the only winning
-#     play.
-#   • `building_count_gte:{fact,1}` (PRESENT-TENSE) is the fact-alive
-#     check — `has_building` is a one-shot ever-seen set that stays
-#     true after the fact is razed (documented CLAUDE.md footgun).
-#   • `after_ticks: BUDGET+1` fail clause is reachable within max_turns
-#     (no interrupts ⇒ exactly 90 ticks/step ⇒ max tick =
-#     93+90·(N-1)); a non-finisher (stall, walls-only) hits it and
-#     LOSES rather than draws.
-#   • A persistent unarmed enemy `fact` at (120,20) keeps the episode
-#     alive past full rush elimination so the win/fail evaluator sees
-#     the terminal frame (no DRAW collapse on enemy-wipe auto-done).
-#   • The `rusher` bot relentlessly charges the agent's centroid (the
-#     fact) — so the scheduled wave converges on the protected asset
-#     whatever defence is built in front of it.
+# Engine facts (per CLAUDE.md):
+#   • pbox = pillbox; cost 600; HP 40000; Allied; prereq tent. The
+#     engine now assigns M60mg (damage 1000, burst 5, reload 30, range 4)
+#     to garrison-only defenses with no explicit Armament (pinned by
+#     tests/test_pbox_fires.py). A built pbox shoots — kills count
+#     toward `units_killed_gte`.
+#   • brik = concrete wall; cost 200; HP 40000; NO Armament — inert
+#     obstacle that channels and delays a charge but produces zero
+#     kill output.
+#   • The rusher bot relentlessly charges the agent centroid (the fact)
+#     so the scheduled wave converges on the protected asset whatever
+#     defence is built in front of it. A wall in the path FORCES the
+#     rusher to detour, channelising it through whatever gap is left.
+#   • place_building works at any in-bounds cell (no adjacency check),
+#     so the wall/pbox cluster can be assembled anywhere reachable.
+#   • Each pack step ≈ 90 ticks. max_turns=60 ⇒ max reachable tick
+#     93+90·59 = 5403; deadlines (within_ticks 5400, after_ticks 5401)
+#     sit safely below ⇒ a non-finisher reaches a real LOSS rather
+#     than draws.
+#   • An unarmed enemy `fact` marker at the far east keeps the episode
+#     alive past full wave elimination (engine auto-`done` mitigation).
+#   • Hard tier defines TWO agent spawn_point groups (north y=14 /
+#     south y=26) so the fact and the whole defence cluster flip by
+#     seed, satisfying the hard-tier contract.
 
 meta:
   id: def-walls-vs-towers
-  title: 'Defense Doctrine — Active Towers Beat Passive Walls'
+  title: 'Defense Doctrine — Walls vs Towers per Tier'
   capability: reasoning
   real_world_meaning: >
-    One budget, one incoming rush, two ways to spend it. PASSIVE walls
-    (brik — 200cr, no weapon) are an inert barrier: they slow and
-    channel an attacker but kill nothing, so a walled-off base only
-    delays the rush. ACTIVE towers (gun turrets — 800cr, anti-ground
-    fire) actually destroy the attacking band. The budget funds EITHER
-    ~16 walls OR ~4 turrets, never both. The win predicate requires a
-    KILL quota only the turrets can deliver, so spending the budget on
-    inert walls — however many — LOSES, and building the active
-    turrets WINS.
+    Defensive doctrine selection: the same budget buys different
+    postures. An open frontal arc needs ACTIVE covering fires (pbox
+    pillboxes). A numerically overwhelming horde on one lane needs
+    PASSIVE channelisation (a brik wall barrier) plus a single pbox
+    at the choke to shred the queue. A mixed two-lane attack forces
+    a TRADEOFF: choke one lane, cover the other. A memorised
+    "always-towers" or "always-walls" play fails the tier where its
+    posture is wrong.
   robotics_analogue: >
-    Security architecture, passive vs active mitigation: network
-    segmentation, an air-gap, or a firewall ACL slows and channels an
-    intruder but neutralises nothing; an IPS or active-response EDR
-    actually terminates the malicious process. A posture built only on
-    passive obstruction merely delays a breach — defence in depth must
-    pair every obstacle with an active responder. Likewise military
-    fortification doctrine: an obstacle belt (ditch, wall, wire) only
-    DELAYS and CHANNELS an assault; it is dead weight unless paired
-    with the covering FIRES the obstacle funnels the enemy into.
+    Defensive doctrine: an open arc demands covering fires; a single
+    overwhelming axis demands channelisation (obstacle belt + fires
+    at the choke); a mixed threat demands force allocation across
+    postures. The same budget produces wildly different outcomes
+    depending on which doctrine matches the geometry — a general who
+    always builds towers loses the horde lane and one who always
+    builds walls loses the open arc.
   benchmark_anchor:
     - 'security architecture'
     - 'passive vs active mitigation'
     - 'military fortification'
   author: openra-bench
 
-# rush-hour-arena (128×40, playable x in [2..126], y in [2..38]). Agent
-# base on the west (fact at (10,20) + tent + 2×powr, NO pre-placed
-# combat units); the rush wave is injected mid-east via a scheduled
-# spawn_actors event and the rusher bot charges the agent centroid (the
-# fact). The agent must spend its one budget on ACTIVE gun turrets that
-# kill the rush — not on inert brik walls that only delay it.
 base_map: rush-hour-arena
 
 base:
@@ -140,71 +100,49 @@ base:
     - attack_move
     - stop
   planning: true
-  # No interrupts — the passive-vs-active choice is a STATIC up-front
-  # decision (the threat axis is known: the rusher always charges the
-  # fact). Disabling interrupts also makes the tick budget
-  # deterministic (exactly 90 ticks/step ⇒ max_turns is a hard tick
-  # budget the `after_ticks` fail clause reliably bites in).
+  # Static posture decision: the threat axis is known up-front (the
+  # rusher always charges the fact). Disabling interrupts also makes
+  # the tick budget deterministic (exactly 90 ticks/step ⇒ max_turns
+  # is a hard tick budget the `after_ticks` fail clause bites in).
   interrupts: {}
   termination:
     max_ticks: 12000
   actors: []   # every level supplies its own actor list via overrides.
 
 levels:
-  # ── EASY ── the bare passive-vs-active choice. Budget 3200cr = 16
-  # brik (passive) OR 4 gun turrets (active). The rush wave (8×e1) is
-  # injected at tick 1800 — after the intended 4-gun build completes
-  # (~tick 1980 for the 4th, comfortably within reach; the first 3
-  # are up by ~1530 so the wave is engaged immediately). Win requires
-  # 4 gun built AND ≥4 kills AND the fact alive. A walls-only spend
-  # kills 0 → fails the kill clause → the win never latches → LOSS via
-  # `after_ticks`. Stall loses (fact razed). max_turns 60 ⇒ reachable
-  # tick 93+90·59 = 5403; deadline 5400.
+  # ── EASY ── frontal rush in the open. Budget 2400cr = 4 pbox
+  # (4×600) OR 12 brik (12×200). The rush wave is 8×e1 on the lane,
+  # injected at tick 1800 (after the intended 4-pbox build completes).
+  # Win requires 4 pbox built AND ≥4 kills AND the fact alive. A
+  # walls-only spend kills 0 → fails the kill clause → LOSS via
+  # after_ticks. Pure-army and stall LOSE for the same reason.
   easy:
-    # Original (pre-verbosity-sweep) description preserved for
-    # contributors. The trimmed version below removes scripted-policy
-    # spoilers and cell-coord dumps; load-bearing intent kept.
-    #
-    # A rusher band of 8 rifle infantry will charge your construction yard
-    # (fact, at (10,20)). You have ONE budget of 3200cr — enough for
-    # EITHER ~16 concrete walls (brik, 200cr, no weapon — an inert
-    # barrier) OR 4 gun turrets (gun, 800cr each — active anti-ground
-    # towers that KILL). Build 4 gun turrets wrapping the fact so their
-    # fire shreds the rush. Win requires 4 gun turrets built, at least 4
-    # enemy units killed, and the fact still standing before tick 5400.
-    # Walls only delay the rush — they kill nothing, so a walls-only spend
-    # FAILS the kill bar. Stall and pure-army also LOSE.
     description: >
-      A rush of eight riflemen will charge your yard at (10,20). Your
-      $3200 can buy either ~16 inert concrete walls or four active gun
-      turrets. Walls don't shoot — kills come from the towers. Build four
-      guns wrapping the yard so their fire shreds the rush. Yard intact,
-      four kills, within about 60 turns.
-    starting_cash: 3200
+      Eight riflemen charge your yard from the east. Your $2400 buys
+      either four active pillboxes or twelve inert concrete walls. Walls
+      don't shoot — kills come from the pillboxes. Build four pillboxes
+      wrapping the yard so their fire shreds the rush. Yard intact, four
+      kills, within about 60 turns.
+    starting_cash: 2400
     overrides:
       actors:
         # Pre-placed agent base — fact + tent + 2×powr. NO combat
-        # units near the base: the agent's built defences must be the
-        # sole source of kill output, or a walls-only spend would pass
-        # the kill clause off pre-placed defenders. Two powr cover the
-        # 4-gun power draw (4×-40 = -160; 2×powr = +200).
+        # units near the base; pre-placed defenders would rack up
+        # kills for free and let a walls-only spend pass the kill
+        # clause off them. Two powr cover the 4-pbox power draw
+        # (4×-20=-80; 2×powr=+200).
         - {type: fact, owner: agent, position: [10, 20]}
         - {type: tent, owner: agent, position: [6,  18]}
         - {type: powr, owner: agent, position: [6,  22]}
         - {type: powr, owner: agent, position: [6,  16]}
         # ONE non-combatant agent e1 parked in the far SW corner,
-        # nowhere near the y=20 rush lane or the fact. It exists only
-        # so `units_summary` is non-empty (hard-tier env-reset check);
-        # it never reaches combat, contributes ZERO kills, and so does
-        # not let a walls-only / stall play pass the kill clause.
+        # well clear of the y=20 rush lane (zero kill contribution;
+        # exists only so `units_summary` is non-empty for the
+        # hard-tier env-reset check).
         - {type: e1,   owner: agent, position: [3, 36], stance: 2}
         # Unarmed high-HP marker (anti-DRAW): keeps the episode alive
         # past full rush elimination so the win/fail check fires.
         - {type: fact, owner: enemy, position: [120, 20]}
-      # Scheduled rush wave — injected at tick 1800, mid-east on the
-      # y=20 lane. The rusher bot charges the agent centroid (the
-      # fact). 8×e1 overwhelms a passive wall / pure-army defence but
-      # a cluster of 4 active gun turrets shreds it.
       scheduled_events:
         - tick: 1800
           type: spawn_actors
@@ -212,7 +150,7 @@ levels:
             - {type: e1, owner: enemy, position: [60, 20], stance: 3, count: 8}
     win_condition:
       all_of:
-        - {building_count_gte: {type: gun, n: 4}}
+        - {building_count_gte: {type: pbox, n: 4}}
         - {units_killed_gte: 4}
         - {building_count_gte: {type: fact, n: 1}}
         - {within_ticks: 5400}
@@ -222,53 +160,51 @@ levels:
         - {not: {building_count_gte: {type: fact, n: 1}}}
     max_turns: 60
 
-  # ── MEDIUM ── +1 axis: heavier rush (8×e1 + 2×e3 rocket soldiers)
-  # AND a higher kill bar (6). Same budget (3200cr = 16 brik OR 4
-  # gun). The heavier band means a walls-only spend channels for
-  # longer but still kills nothing, and pure-army is out-traded
-  # harder; only the active gun cluster produces enough kill output to
-  # clear the bar AND keep the fact. max_turns 60 ⇒ reachable tick
-  # 5403; deadline 5400.
+  # ── MEDIUM ── numerically overwhelming horde. The walls+pbox CHOKE
+  # is the correct doctrine. Budget 2400cr funds (1 pbox + 9 brik) =
+  # 600 + 1800 = 2400 with cash to spare for any extra wall.
+  #
+  # Predicate doctrine — REQUIRE both wall belt AND pbox AND kills:
+  #   building_count_gte:{pbox,1} ⇒ at least one active turret at
+  #     the choke (kills come from here).
+  #   building_count_gte:{brik,6} ⇒ a genuine wall belt (not 1-2
+  #     incidental walls); the channelisation must be real.
+  #   units_killed_gte:10 ⇒ the choke + pbox must actually kill
+  #     half the horde; a single pbox at the choke serially kills
+  #     queued e1 fast enough to clear this bar.
+  #
+  # This makes pure-pbox (no brik clause met → fail) and pure-walls
+  # (0 kills → fail) both LOSE; only the wall+pbox combo wins.
   medium:
-    # Original (pre-verbosity-sweep) description preserved for
-    # contributors. The trimmed version below removes scripted-policy
-    # spoilers and cell-coord dumps; load-bearing intent kept.
-    #
-    # A heavier rush — 8 rifle infantry + 2 rocket soldiers — will charge
-    # your construction yard (fact, at (10,20)). One budget of 3200cr:
-    # EITHER ~16 inert concrete walls (brik) OR 4 active gun turrets
-    # (gun). Build 4 gun turrets wrapping the fact. Win requires 4 gun
-    # turrets built, at least 6 enemy units killed, and the fact still
-    # standing before tick 5400. Walls kill nothing (they only delay) so a
-    # walls-only spend FAILS the kill bar; stall and pure-army also LOSE.
     description: >
-      Same yard, same $3200 — but the rush now adds two rocket soldiers
-      behind the eight rifles. Walls still kill nothing. Build four gun
-      turrets ringing the yard so their direct fire actually puts the rush
-      down. Yard intact, six kills, within about 60 turns.
-    starting_cash: 3200
+      A massive horde — sixteen riflemen plus four rocket soldiers —
+      funnels at your yard from the east on a single lane. Your $2400
+      buys either ~12 inert walls or 4 active pillboxes. Neither alone
+      satisfies the doctrine here: pure walls kill nothing, pure
+      pillboxes leave the horde un-channelised. Build a wall belt that
+      channels the horde to a tight pass, with a pillbox at the choke
+      to shred the queue. Yard intact, ten kills, within about 60 turns.
+    starting_cash: 2400
     overrides:
       actors:
         - {type: fact, owner: agent, position: [10, 20]}
         - {type: tent, owner: agent, position: [6,  18]}
         - {type: powr, owner: agent, position: [6,  22]}
         - {type: powr, owner: agent, position: [6,  16]}
-        # Non-combatant SW-corner e1 (see easy) — non-empty
-        # units_summary, zero kill contribution.
         - {type: e1,   owner: agent, position: [3, 36], stance: 2}
-        # Anti-DRAW marker.
         - {type: fact, owner: enemy, position: [120, 20]}
-      # Heavier rush wave: 8×e1 + 2×e3, all on the y=20 lane.
+      # Overwhelming horde — 16 e1 + 4 e3, all on y=20.
       scheduled_events:
         - tick: 1800
           type: spawn_actors
           actors:
-            - {type: e1, owner: enemy, position: [60, 20], stance: 3, count: 8}
-            - {type: e3, owner: enemy, position: [62, 20], stance: 3, count: 2}
+            - {type: e1, owner: enemy, position: [60, 20], stance: 3, count: 16}
+            - {type: e3, owner: enemy, position: [62, 20], stance: 3, count: 4}
     win_condition:
       all_of:
-        - {building_count_gte: {type: gun, n: 4}}
-        - {units_killed_gte: 6}
+        - {building_count_gte: {type: pbox, n: 1}}
+        - {building_count_gte: {type: brik, n: 6}}
+        - {units_killed_gte: 10}
         - {building_count_gte: {type: fact, n: 1}}
         - {within_ticks: 5400}
     fail_condition:
@@ -277,52 +213,33 @@ levels:
         - {not: {building_count_gte: {type: fact, n: 1}}}
     max_turns: 60
 
-  # ── HARD ── +1 axis: TWO seed-driven agent spawn_point groups so the
-  # fact (and therefore the turret cluster) FLIPS between NORTH y=14
-  # and SOUTH y=26 per seed. The win predicate is the same (count +
-  # kill + fact-alive + within_ticks) but the model must READ the
-  # fact's latitude from observation and place the turrets relative to
-  # it — a memorised "build turrets near (10,20)" plan does not work
-  # because the fact never sits at y=20 on hard. The scheduled wave is
-  # injected at BOTH candidate latitudes (the spawn_actors list is not
-  # spawn_point-filtered); the rusher charges the agent centroid so it
-  # converges on whichever fact is present this seed. Kill bar 6
-  # (the on-latitude wave is 7 units — bar 6 leaves a one-unit margin
-  # so a slightly imperfect turret cluster still clears it, while a
-  # walls-only spend at 0 kills is nowhere near).
-  # max_turns 60 ⇒ reachable tick 5403; deadline 5400.
+  # ── HARD ── MIXED approach + seed-driven fact flip. The fact sits
+  # at y=14 (NORTH) for some seeds and y=26 (SOUTH) for others — the
+  # build cannot be memorised by coord. On EVERY seed two simultaneous
+  # waves arrive: a HEAVY horde (10×e1 + 2×e3) on each lane. The rusher
+  # converges on the agent centroid (the active fact's lane); the
+  # off-lane wave still pours toward the centroid and a flanking pbox
+  # is required to interdict it. Predicate requires pbox count + brik
+  # count + a kill quota — solving only one lane fails the kill quota.
+  # Budget 3000cr = 2 pbox (1200) + 9 brik (1800) — the minimum
+  # walls-plus-towers spend that satisfies both lanes.
   hard:
-    # Original (pre-verbosity-sweep) description preserved for
-    # contributors. The trimmed version below removes scripted-policy
-    # spoilers and cell-coord dumps; load-bearing intent kept.
-    #
-    # The construction yard (fact) flips between NORTH (y=14) and SOUTH
-    # (y=26) by seed; the turret cluster must follow. One budget of
-    # 3200cr: EITHER ~16 inert concrete walls (brik) OR 4 active gun
-    # turrets (gun). Build 4 gun turrets wrapping the CURRENT fact (either
-    # (10,14) or (10,26) — read it from the observation). Win requires 4
-    # gun turrets built, at least 6 enemy units killed, and the fact still
-    # standing before tick 5400. A walls-only spend kills nothing; stall
-    # and pure-army also LOSE.
     description: >
-      Your yard spawns NORTH (y=14) or SOUTH (y=26) by seed; the turret
-      cluster must follow. $3200 still chooses between sixteen inert walls
-      or four active gun turrets — build the turrets wrapping the CURRENT
-      yard. Six kills, yard intact, within about 60 turns.
-    starting_cash: 3200
+      Your yard spawns NORTH (y=14) or SOUTH (y=26) by seed. TWO waves
+      arrive — a heavy horde on your yard's lane and another on the
+      opposite lane. Your $3000 buys a tradeoff: channel the horde with
+      a wall belt + pillbox at the choke AND post a flanking pillbox on
+      the opposite lane. Yard intact, ten kills, within about 60 turns.
+    starting_cash: 3000
     overrides:
       actors:
-        # spawn_point 0 — NORTH base. Fact at (10,14); tent/powr WEST.
-        # The non-combatant corner e1 parks in the far SW corner,
-        # well clear of the y=14 rush lane (zero kill contribution).
+        # spawn_point 0 — NORTH base. Fact at (10,14).
         - {type: fact, owner: agent, position: [10, 14], spawn_point: 0}
         - {type: tent, owner: agent, position: [6,  12], spawn_point: 0}
         - {type: powr, owner: agent, position: [6,  10], spawn_point: 0}
         - {type: powr, owner: agent, position: [6,  16], spawn_point: 0}
         - {type: e1,   owner: agent, position: [3, 36], stance: 2, spawn_point: 0}
-        # spawn_point 1 — SOUTH base (mirror across y=20). The
-        # non-combatant corner e1 parks in the far NW corner, well
-        # clear of the y=26 rush lane.
+        # spawn_point 1 — SOUTH base (mirror).
         - {type: fact, owner: agent, position: [10, 26], spawn_point: 1}
         - {type: tent, owner: agent, position: [6,  24], spawn_point: 1}
         - {type: powr, owner: agent, position: [6,  28], spawn_point: 1}
@@ -330,24 +247,39 @@ levels:
         - {type: e1,   owner: agent, position: [3,  4], stance: 2, spawn_point: 1}
         # Anti-DRAW marker on the symmetry axis.
         - {type: fact, owner: enemy, position: [120, 20]}
-      # The scheduled wave is staged at BOTH candidate latitudes (y=14
-      # AND y=26) — the spawn_actors list is not spawn_point-filtered,
-      # so both bands always inject. The rusher charges the agent
-      # centroid so the band whose latitude matches the active fact
-      # converges on it; the on-latitude band alone is heavy enough to
-      # overwhelm a passive / mis-placed defence.
+      # Two simultaneous waves on BOTH lanes (the spawn_actors list is
+      # not spawn_point-filtered, so both lanes always spawn). The
+      # rusher converges on the agent centroid (the active fact's
+      # lane); the off-lane wave is a LIGHT probe (4×e1) that a single
+      # flanking pbox at the active-lane choke can mop up as it walks
+      # past, while the heavy on-lane horde is shredded by the wall
+      # belt + pbox choke. Heavy ON the active lane forces the wall
+      # belt; light probe OFF the active lane is the "flank" budget
+      # tradeoff the predicate enforces.
       scheduled_events:
         - tick: 1800
           type: spawn_actors
           actors:
-            - {type: e1, owner: enemy, position: [60, 14], stance: 3, count: 6}
-            - {type: e3, owner: enemy, position: [62, 14], stance: 3, count: 1}
-            - {type: e1, owner: enemy, position: [60, 26], stance: 3, count: 6}
-            - {type: e3, owner: enemy, position: [62, 26], stance: 3, count: 1}
+            # NORTH-lane wave — HEAVY horde (12 attackers) plus a
+            # LIGHT probe (4 e1). On a NORTH-base seed the heavy
+            # horde is on-lane (channeled by the wall belt); on a
+            # SOUTH-base seed the heavy north wave is off-lane and
+            # detours through y=20 to reach the south fact, walking
+            # past the choke on its way down.
+            - {type: e1, owner: enemy, position: [60, 14], stance: 3, count: 10}
+            - {type: e3, owner: enemy, position: [62, 14], stance: 3, count: 2}
+            # SOUTH-lane wave — symmetric. Both waves always spawn;
+            # whichever wave matches the active fact's latitude is
+            # the "on-lane" horde the wall belt channels, the other
+            # is the "off-lane" wave a 2nd pbox + the wall belt
+            # together kill as they detour past.
+            - {type: e1, owner: enemy, position: [60, 26], stance: 3, count: 10}
+            - {type: e3, owner: enemy, position: [62, 26], stance: 3, count: 2}
     win_condition:
       all_of:
-        - {building_count_gte: {type: gun, n: 4}}
-        - {units_killed_gte: 6}
+        - {building_count_gte: {type: pbox, n: 2}}
+        - {building_count_gte: {type: brik, n: 6}}
+        - {units_killed_gte: 10}
         - {building_count_gte: {type: fact, n: 1}}
         - {within_ticks: 5400}
     fail_condition:

tests/test_def_walls_vs_towers.py

@@ -1,43 +1,29 @@
 """def-walls-vs-towers scenario family, full loop on Rust.
 
-The pack tests PASSIVE-OBSTACLE vs ACTIVE-DEFENSE mitigation: the agent
-has ONE budget (3200cr) and must choose how to spend it against an
-incoming rush. The budget funds EITHER ~16 inert `brik` concrete walls
-(200cr, HP 40000, NO Armament — they channel and delay but kill
-nothing) OR 4 active `gun` turrets (800cr, Armament Weapon TurretGun —
-the engine's auto-target loop fires them at the rush). The win
-predicate makes the choice load-bearing:
-
-* `building_count_gte:{gun, n:4}` ⇒ the agent built the budget worth of
-  ACTIVE turrets (4 — cash is tight enough that the wall option is
-  mutually exclusive);
-* `units_killed_gte:K` ⇒ the load-bearing clause. A walls-only spend
-  kills 0 — walls have no weapon — so the clause is never satisfied; an
-  active gun cluster shreds the rush and clears it. This is the
-  predicate that makes ACTIVE defence (not passive obstruction) the
-  only winning play;
-* `building_count_gte:{fact,1}` ⇒ the fact must still STAND (the
-  PRESENT-TENSE predicate, not `has_building:fact` which is a one-shot
-  ever-seen set — CLAUDE.md footgun);
-* `within_ticks` paired with `after_ticks` ⇒ a non-finisher (stall,
-  walls-only) is a real reachable timeout LOSS (no interrupts ⇒ each
-  step is exactly 90 ticks, so max_turns is a hard tick budget the
-  `after_ticks` deadline reliably bites in).
-
-The rush arrives as a `scheduled_events: spawn_actors` wave at a fixed
-tick (1800) — after the agent has had time to build 4 gun turrets
-serially — so the race is fair: the intended build completes before
-the wave, while a staller / walls-only spend still cannot satisfy the
-kill quota.
+The pack tests TIER-DIFFERENTIATED defensive DOCTRINE selection: the
+agent must choose between PASSIVE OBSTACLE (`brik` concrete walls —
+200cr, HP 40000, NO Armament) and ACTIVE TURRET (`pbox` pillbox —
+600cr, M60mg burst — anti-infantry direct fire). The correct posture
+DIFFERS PER TIER:
+
+* EASY    — frontal rush in the open. 4 pbox cluster wraps the fact
+            and shreds the wave. Walls kill nothing → LOSS.
+* MEDIUM  — overwhelming horde funnels on one lane. Win predicate
+            requires BOTH a wall belt AND a pbox at the choke AND a
+            kill quota: a wall barrier funnels the horde to a single
+            pass where the pbox serially shreds the queue. Pure-walls
+            (0 kills) and pure-pbox (no brik clause) both LOSE.
+* HARD    — two simultaneous waves + seed-driven fact flip. The agent
+            must allocate budget across both postures (2 pbox + 8
+            brik). Pure-walls and pure-pbox both LOSE.
 
 The scripted-policy validations prove deterministically that:
 
-* the intended TOWERS policy (4 gun turrets wrapping the active fact)
-  WINS every level + every hard seed (1..4);
-* walls-only (16 brik — 0 kills) / stall / pure-army all LOSE every
-  level + every hard seed — a real LOSS, not a draw;
+* the intended PER-TIER doctrine WINS every seed (1..4);
+* stall, pure-walls (brik-only), pure-pbox (no brik on medium/hard),
+  and pure-army all LOSE every seed — a real LOSS, not a draw;
 * the hard tier defines >=2 spawn_point groups (north fact y=14 /
-  south fact y=26) so the turret cluster must follow the fact.
+  south fact y=26) so the defence cluster must follow the fact.
 """
 
 from __future__ import annotations
@@ -65,28 +51,33 @@ def stall(rs, C):
     return [C.observe()]
 
 
+def _prod_items(rs):
+    """The Defense queue surfaces as a flat list of strings — handle
+    that AND the legacy dict-with-item shape robustly."""
+    return [
+        (p if isinstance(p, str) else p.get("item"))
+        for p in (rs.get("production") or [])
+    ]
+
+
 def _build_and_place(rs, C, kind, cells):
-    """Common build-place loop: at each turn, place the next `kind`
-    building in `cells` if the previous one finished; queue the next
-    build."""
+    """Place the next `kind` building in `cells` if the previous one
+    finished; queue the next build only if not already in the queue."""
     own_b = rs.get("own_buildings") or []
     n = sum(1 for b in own_b if b.get("type") == kind)
     if n >= len(cells):
         return [C.observe()]
-    prod = rs.get("production") or []
-    prod_items = [p.get("item") for p in prod if isinstance(p, dict)]
     cmds = []
-    if kind not in prod_items:
+    if kind not in _prod_items(rs):
         cmds.append(C.build(kind))
     cmds.append(C.place_building(kind, cells[n][0], cells[n][1]))
     return cmds or [C.observe()]
 
 
-def make_adaptive_towers():
-    """Intended TOWERS policy: read the fact's cell from the
-    observation on turn 1, then build 4 ACTIVE gun turrets wrapping it.
-    On hard the fact flips between y=14 and y=26 by seed, so the turret
-    cluster must follow it."""
+def make_pbox_only(cells_fn):
+    """Pure-ACTIVE policy: build N pbox at `cells_fn(fy)`. Wraps the
+    fact with active turrets that shoot the rush. Wins on easy
+    (predicate matches) and LOSES on medium/hard (no brik clause)."""
     state = {"cells": None}
 
     def policy(rs, C):
@@ -96,20 +87,16 @@ def make_adaptive_towers():
             if not facts:
                 return [C.observe()]
             fy = facts[0].get("cell_y", facts[0].get("y"))
-            # 4 cells wrapping the fact at (10, fy), east of it (the
-            # rush approaches from the east).
-            state["cells"] = [(12, fy - 2), (12, fy), (12, fy + 2), (13, fy)]
-        return _build_and_place(rs, C, "gun", state["cells"])
+            state["cells"] = cells_fn(fy)
+        return _build_and_place(rs, C, "pbox", state["cells"])
 
     return policy
 
 
-def make_walls_only():
-    """The PASSIVE counterfactual: spend the whole budget on 16 inert
-    `brik` concrete walls (a double barrier east of the fact). Walls
-    channel and delay the rush but have NO weapon — they kill nothing,
-    so the `units_killed_gte` clause is never satisfied and the win
-    never latches; the episode times out → LOSS."""
+def make_brik_only(cells_fn):
+    """Pure-PASSIVE policy: build N brik (inert walls). The brik clause
+    may pass on medium/hard but `units_killed_gte` never does — walls
+    have no weapon. LOSES every tier."""
     state = {"cells": None}
 
     def policy(rs, C):
@@ -119,22 +106,103 @@ def make_walls_only():
             if not facts:
                 return [C.observe()]
             fy = facts[0].get("cell_y", facts[0].get("y"))
-            state["cells"] = [(14, fy - 7 + i) for i in range(8)] + [
-                (16, fy - 7 + i) for i in range(8)
-            ]
+            state["cells"] = cells_fn(fy)
         return _build_and_place(rs, C, "brik", state["cells"])
 
     return policy
 
 
+def make_intended_easy():
+    """EASY doctrine: 4 pbox wrapping the fact on the east approach."""
+    return make_pbox_only(
+        lambda fy: [(12, fy - 2), (12, fy), (12, fy + 2), (13, fy)]
+    )
+
+
+def _build_combo(rs, C, plan):
+    """Two-phase build: complete all pbox first, then the brik belt.
+    Pbox first because they kill — building the wall belt before the
+    pbox lets the horde reach the fact before kill output is online."""
+    own_b = rs.get("own_buildings") or []
+    n_pbox = sum(1 for b in own_b if b.get("type") == "pbox")
+    n_brik = sum(1 for b in own_b if b.get("type") == "brik")
+    prod_items = _prod_items(rs)
+    cmds = []
+    if n_pbox < len(plan["pbox"]):
+        if "pbox" not in prod_items:
+            cmds.append(C.build("pbox"))
+        cmds.append(C.place_building("pbox", plan["pbox"][n_pbox][0], plan["pbox"][n_pbox][1]))
+    elif n_brik < len(plan["brik"]):
+        if "brik" not in prod_items:
+            cmds.append(C.build("brik"))
+        cmds.append(C.place_building("brik", plan["brik"][n_brik][0], plan["brik"][n_brik][1]))
+    else:
+        cmds.append(C.observe())
+    return cmds
+
+
+def make_intended_medium():
+    """MEDIUM doctrine: 1 pbox at the choke + 8 brik wall belt that
+    leaves a single-cell pass at the fact's y, funnelling the horde
+    onto the pbox burst."""
+    state = {"plan": None}
+
+    def policy(rs, C):
+        if state["plan"] is None:
+            own_b = rs.get("own_buildings") or []
+            facts = [b for b in own_b if b.get("type") == "fact"]
+            if not facts:
+                return [C.observe()]
+            fy = facts[0].get("cell_y", facts[0].get("y"))
+            state["plan"] = {
+                "pbox": [(12, fy)],
+                "brik": [
+                    (14, fy - 4), (14, fy - 3), (14, fy - 2), (14, fy - 1),
+                    (14, fy + 1), (14, fy + 2), (14, fy + 3), (14, fy + 4),
+                ],
+            }
+        return _build_combo(rs, C, state["plan"])
+
+    return policy
+
+
+def make_intended_hard():
+    """HARD doctrine: 2 pbox at the choke + 8 brik full-lane wall belt
+    that blocks BOTH attack vectors converging on the fact. The pbox
+    cluster sits behind the wall belt where it can shred whatever
+    funnels through the single-cell gap left by the wall."""
+    state = {"plan": None}
+
+    def policy(rs, C):
+        if state["plan"] is None:
+            own_b = rs.get("own_buildings") or []
+            facts = [b for b in own_b if b.get("type") == "fact"]
+            if not facts:
+                return [C.observe()]
+            fy = facts[0].get("cell_y", facts[0].get("y"))
+            # 2nd pbox is placed on the FACT side (north for the north
+            # fact, south for the south fact) to cover the off-lane
+            # approach as it walks past.
+            second_y = fy - 2 if fy == 14 else fy + 2
+            state["plan"] = {
+                "pbox": [(12, fy), (12, second_y)],
+                "brik": [
+                    (13, fy - 3), (13, fy - 2), (13, fy - 1),
+                    (13, fy + 1), (13, fy + 2), (13, fy + 3),
+                    (13, fy + 4), (13, fy - 4),
+                ],
+            }
+        return _build_combo(rs, C, state["plan"])
+
+    return policy
+
+
 def pure_army(rs, C):
     """PURE-ARMY: only ever train e1 — never builds a defensive
-    building. FAILS the `building_count_gte:gun` clause; a thin
+    building. FAILS the `building_count_gte:pbox` clause; a thin
     home-trained rifle screen cannot out-trade the heavier rush band
     either, so the fact often falls → LOSS."""
-    prod = rs.get("production") or []
-    prod_items = [p.get("item") for p in prod if isinstance(p, dict)]
-    if "e1" not in prod_items:
+    if "e1" not in _prod_items(rs):
         return [C.build("e1")]
     return [C.observe()]
 
@@ -167,14 +235,16 @@ def test_pack_compiles_with_three_levels_and_rusher_bot():
         assert str(bot).lower() == "rusher", (lvl, bot)
 
 
-def test_starting_cash_is_the_either_or_budget():
-    """Cash is intentionally tight: 3200cr funds EITHER 16 brik walls
-    (16×200) OR 4 gun turrets (4×800) — never both. The two options
-    are mutually exclusive so the agent must commit to ACTIVE defence."""
+def test_starting_cash_is_per_tier_doctrine_budget():
+    """Cash is sized per tier so the intended doctrine fits and the
+    wrong doctrine does not: easy/medium fund either 4 pbox (4×600) or
+    12 brik (12×200) within 2400cr; hard funds 2 pbox + 8 brik = 2800
+    within 3000cr."""
     pack = load_pack(PACK)
-    for lvl in LEVELS:
-        c = compile_level(pack, lvl)
-        assert c.starting_cash == 3200, (lvl, c.starting_cash)
+    cash_by_level = {lvl: compile_level(pack, lvl).starting_cash for lvl in LEVELS}
+    assert cash_by_level["easy"] == 2400, cash_by_level
+    assert cash_by_level["medium"] == 2400, cash_by_level
+    assert cash_by_level["hard"] == 3000, cash_by_level
 
 
 def test_no_preplaced_combat_units_near_the_base():
@@ -191,7 +261,6 @@ def test_no_preplaced_combat_units_near_the_base():
             for a in c.scenario.actors
             if a.owner == "agent" and a.type == "e1"
         ]
-        # Every pre-placed agent e1 is a corner non-combatant.
         for a in agent_units:
             x, y = a.position
             assert x <= 3 and (y <= 6 or y >= 34), (lvl, a.position)
@@ -199,8 +268,8 @@ def test_no_preplaced_combat_units_near_the_base():
 
 def test_uses_scheduled_wave_event():
     """The rush arrives via a `scheduled_events: spawn_actors` wave so
-    the build race is fair (the wave lands after the intended 4-gun
-    build can complete)."""
+    the build race is fair (the wave lands after the intended build
+    can complete)."""
     pack = load_pack(PACK)
     for lvl in LEVELS:
         c = compile_level(pack, lvl)
@@ -250,7 +319,7 @@ def test_fact_alive_clause_uses_present_tense_predicate():
         assert fact_clauses, f"{lvl}: missing present-tense fact-alive fail clause"
 
 
-def test_win_requires_a_kill_quota():
+def test_win_requires_a_kill_quota_per_tier():
     """The load-bearing clause: every level's win requires
     `units_killed_gte` — the predicate a walls-only (0-kill) spend
     cannot satisfy. Without it, inert walls would win."""
@@ -266,9 +335,58 @@ def test_win_requires_a_kill_quota():
         assert int(kill_clauses[0]["units_killed_gte"]) >= 4, lvl
 
 
+def test_medium_and_hard_require_wall_plus_tower_combo():
+    """Tier-differentiated doctrine: medium/hard predicates must require
+    BOTH a pbox AND a brik clause. Without the brik clause a pure-pbox
+    spend would win medium/hard and the tier doctrine would collapse to
+    "always build towers"."""
+    for lvl in ("medium", "hard"):
+        c = compile_level(load_pack(PACK), lvl)
+        wc = c.win_condition.model_dump(exclude_none=True)
+        all_of = wc.get("all_of") or []
+        pbox_clauses = [
+            cl for cl in all_of
+            if isinstance(cl, dict)
+            and (cl.get("building_count_gte") or {}).get("type") == "pbox"
+        ]
+        brik_clauses = [
+            cl for cl in all_of
+            if isinstance(cl, dict)
+            and (cl.get("building_count_gte") or {}).get("type") == "brik"
+        ]
+        assert pbox_clauses, f"{lvl}: missing pbox count clause"
+        assert brik_clauses, f"{lvl}: missing brik count clause"
+        # The brik count must require a genuine wall belt, not 1-2
+        # incidental walls — otherwise a 4-pbox spend that happens to
+        # toss out a couple of walls passes the predicate.
+        assert int(brik_clauses[0]["building_count_gte"]["n"]) >= 6, lvl
+
+
+def test_easy_requires_pbox_not_brik():
+    """Easy tier is the pure-active-doctrine tier: the predicate must
+    require pbox and NOT require any brik (a 4-pbox spend is the
+    intended easy win, and forcing brik on easy would collapse the
+    tier differentiation)."""
+    c = compile_level(load_pack(PACK), "easy")
+    wc = c.win_condition.model_dump(exclude_none=True)
+    all_of = wc.get("all_of") or []
+    pbox_clauses = [
+        cl for cl in all_of
+        if isinstance(cl, dict)
+        and (cl.get("building_count_gte") or {}).get("type") == "pbox"
+    ]
+    brik_clauses = [
+        cl for cl in all_of
+        if isinstance(cl, dict)
+        and (cl.get("building_count_gte") or {}).get("type") == "brik"
+    ]
+    assert pbox_clauses, "easy: missing pbox count clause"
+    assert not brik_clauses, "easy: must not require brik (pure-active doctrine)"
+
+
 def test_hard_has_two_spawn_point_groups_and_fact_flips():
     """Hard-tier contract: >=2 distinct agent spawn_point groups so the
-    fact (and therefore the turret cluster) flips by seed. The two
+    fact (and therefore the defence cluster) flips by seed. The two
     groups must define the NORTH (y=14) and SOUTH (y=26) fact pair."""
     c = compile_level(load_pack(PACK), "hard")
     groups = {
@@ -291,76 +409,134 @@ def test_hard_has_two_spawn_point_groups_and_fact_flips():
         assert 2 <= x <= 126 and 2 <= y <= 38, (a.type, a.position)
 
 
-# ── solvency: intended TOWERS wins every level + every hard seed ─────
+# ── solvency: intended per-tier doctrine wins every seed ─────────────
 
 
-@pytest.mark.parametrize("level", LEVELS)
-def test_intended_towers_win_every_level_and_seed(level):
-    c = compile_level(load_pack(PACK), level)
+def test_intended_easy_pbox_wins_every_seed():
+    c = compile_level(load_pack(PACK), "easy")
     for seed in SEEDS:
-        r = run_level(c, make_adaptive_towers(), seed=seed)
+        r = run_level(c, make_intended_easy(), seed=seed)
         assert r.outcome == "win", (
-            f"{level} seed{seed}: intended gun-turret build must WIN; "
+            f"easy seed{seed}: intended 4-pbox cluster must WIN; "
             f"got {r.outcome} (tick={r.signals.game_tick}, "
             f"kills={r.signals.units_killed}, "
-            f"lost={r.signals.units_lost}, "
             f"buildings={r.signals.own_buildings})"
         )
 
 
-# ── no-cheat: every lazy / passive policy LOSES (not draws) ──────────
+def test_intended_medium_walls_plus_tower_wins_every_seed():
+    c = compile_level(load_pack(PACK), "medium")
+    for seed in SEEDS:
+        r = run_level(c, make_intended_medium(), seed=seed)
+        assert r.outcome == "win", (
+            f"medium seed{seed}: intended 1 pbox + 8 brik choke must "
+            f"WIN; got {r.outcome} (tick={r.signals.game_tick}, "
+            f"kills={r.signals.units_killed}, "
+            f"buildings={r.signals.own_buildings})"
+        )
+
+
+def test_intended_hard_mixed_doctrine_wins_every_seed():
+    c = compile_level(load_pack(PACK), "hard")
+    for seed in SEEDS:
+        r = run_level(c, make_intended_hard(), seed=seed)
+        assert r.outcome == "win", (
+            f"hard seed{seed}: intended 2 pbox + 8 brik mixed doctrine "
+            f"must WIN; got {r.outcome} (tick={r.signals.game_tick}, "
+            f"kills={r.signals.units_killed}, "
+            f"buildings={r.signals.own_buildings})"
+        )
+
+
+# ── no-cheat: stall + wrong doctrine all LOSE every tier × seed ──────
 
 
 @pytest.mark.parametrize("level", LEVELS)
-@pytest.mark.parametrize(
-    "policy_name,policy_factory",
-    [
-        ("stall", lambda: stall),
-        ("walls_only", make_walls_only),
-        ("pure_army", lambda: pure_army),
-    ],
-)
-def test_passive_and_lazy_policies_lose_every_level_and_seed(
-    level, policy_name, policy_factory
-):
-    """Stall (rush razes fact OR clock), walls-only (inert walls — 0
-    kills, kill clause never met, clock runs out), and pure-army (gun
-    count clause unmet) must ALL LOSE on every level + every seed — no
-    draw. walls-only LOSING is the load-bearing discrimination: a
-    passive-obstacle spend, however large, never produces kill output."""
+def test_stall_loses_every_level_and_seed(level):
+    """Stall (observe-only): the rush razes the fact OR the clock runs
+    out → real LOSS, not a draw."""
     c = compile_level(load_pack(PACK), level)
-    fn = policy_factory()
     for seed in SEEDS:
-        r = run_level(c, fn, seed=seed)
+        r = run_level(c, stall, seed=seed)
         assert r.outcome == "loss", (
-            f"{level} seed{seed} {policy_name}: must LOSE (real fail, "
-            f"not a draw); got {r.outcome} (tick={r.signals.game_tick}, "
-            f"kills={r.signals.units_killed}, "
-            f"buildings={r.signals.own_buildings})"
+            f"{level} seed{seed} stall: must LOSE; got {r.outcome}"
         )
 
 
-def test_walls_only_produces_zero_kills():
-    """The mechanism check: an all-`brik` spend kills NOTHING (walls
-    have no weapon). This is why walls LOSE the kill clause and active
-    gun turrets WIN it."""
-    for lvl in LEVELS:
-        c = compile_level(load_pack(PACK), lvl)
+@pytest.mark.parametrize("level", LEVELS)
+def test_pure_walls_loses_every_level_and_seed(level):
+    """Pure-walls (brik-only): walls have no weapon, so `units_killed`
+    stays at zero on every tier — the kill clause is never satisfied
+    and the episode times out → LOSS. The mechanism-level proof that
+    passive obstruction alone is never the right doctrine for ANY
+    tier (even where walls are PART of the right doctrine)."""
+    c = compile_level(load_pack(PACK), level)
+    pol = make_brik_only(lambda fy: [(14, fy - 6 + i) for i in range(12) if fy - 6 + i != fy])
+    for seed in SEEDS:
+        r = run_level(c, pol, seed=seed)
+        assert r.outcome == "loss", (
+            f"{level} seed{seed} pure-walls: must LOSE; got {r.outcome} "
+            f"(kills={r.signals.units_killed})"
+        )
+        # Mechanism check: pure-walls always kills zero, on every tier.
+        assert r.signals.units_killed == 0, (
+            f"{level} seed{seed}: pure-walls must kill 0 (inert "
+            f"obstacle); got {r.signals.units_killed}"
+        )
+
+
+def test_pure_pbox_wins_easy_but_loses_medium_and_hard():
+    """The TIER-DIFFERENTIATION proof: a 4-pbox cluster (the easy
+    doctrine, hard-coded as always-towers) WINS easy but LOSES
+    medium and hard — proving the predicate / geometry genuinely
+    forces a different doctrine per tier. An "always build towers"
+    play that memorises easy fails the higher tiers."""
+    pack = load_pack(PACK)
+
+    def cells(fy):
+        return [(12, fy - 2), (12, fy), (12, fy + 2), (13, fy)]
+
+    # Easy — pure-pbox is the correct doctrine, must WIN.
+    c_easy = compile_level(pack, "easy")
+    for seed in SEEDS:
+        r = run_level(c_easy, make_pbox_only(cells), seed=seed)
+        assert r.outcome == "win", (
+            f"easy seed{seed} pure-pbox: must WIN (the easy doctrine); "
+            f"got {r.outcome}"
+        )
+
+    # Medium + hard — pure-pbox fails the brik clause, must LOSE.
+    for lvl in ("medium", "hard"):
+        c = compile_level(pack, lvl)
         for seed in SEEDS:
-            r = run_level(c, make_walls_only(), seed=seed)
-            assert r.signals.units_killed == 0, (
-                f"{lvl} seed{seed}: walls-only must kill 0 (inert "
-                f"obstacle); got {r.signals.units_killed}"
+            r = run_level(c, make_pbox_only(cells), seed=seed)
+            assert r.outcome == "loss", (
+                f"{lvl} seed{seed} pure-pbox: must LOSE (wrong "
+                f"doctrine — no wall belt); got {r.outcome} "
+                f"(kills={r.signals.units_killed})"
             )
 
 
+@pytest.mark.parametrize("level", LEVELS)
+def test_pure_army_loses_every_level_and_seed(level):
+    """Pure-army (only train e1): fails the pbox count clause and a
+    thin home-trained rifle screen cannot out-trade the heavier rush
+    band, so the fact often falls → LOSS."""
+    c = compile_level(load_pack(PACK), level)
+    for seed in SEEDS:
+        r = run_level(c, pure_army, seed=seed)
+        assert r.outcome == "loss", (
+            f"{level} seed{seed} pure-army: must LOSE; got {r.outcome}"
+        )
+
+
 # ── determinism ──────────────────────────────────────────────────────
 
 
 def test_intended_run_is_deterministic_on_easy():
     c = compile_level(load_pack(PACK), "easy")
-    a = run_level(c, make_adaptive_towers(), seed=3)
-    b = run_level(c, make_adaptive_towers(), seed=3)
+    a = run_level(c, make_intended_easy(), seed=3)
+    b = run_level(c, make_intended_easy(), seed=3)
     assert (a.outcome, a.turns, a.signals.units_killed) == (
         b.outcome,
         b.turns,

tests/test_hard_tier.py

@@ -746,19 +746,22 @@ UPGRADED = [
     # selected. MicroRTS pillbox placement / military quadrant
     # doctrine anchor.
     "build-defensive-skirt-corners",
-    # Wave-11 REASONING pack: passive-obstacle vs active-defense
-    # mitigation — one budget (3200cr) funds EITHER ~16 inert brik
-    # walls OR 4 active gun turrets. The win predicate requires a kill
-    # quota (units_killed_gte) only the gun turrets can deliver, so a
-    # walls-only spend (0 kills) and a stall both LOSE while the
-    # intended turret build WINS. Hard tier defines two agent
-    # spawn_point groups (NORTH fact y=14 / SOUTH fact y=26) round-
-    # robined by seed; the scheduled rush wave is staged at BOTH
-    # candidate latitudes (spawn_actors lists are not spawn_point-
-    # filtered) so the rusher converges on whichever fact the seed
-    # selected, and a memorised "turrets near (10,20)" plan cannot
-    # generalise. Security architecture passive-vs-active mitigation /
-    # military fortification anchor.
+    # Wave-11 REASONING pack: tier-differentiated defensive DOCTRINE
+    # — passive `brik` walls (200cr, no Armament) vs active `pbox`
+    # pillboxes (600cr, M60mg burst). The CORRECT doctrine differs
+    # per tier: easy = pure-pbox (frontal rush in the open); medium =
+    # walls+pbox CHOKE (overwhelming horde funnels through a single
+    # gap onto the pbox burst); hard = MIXED 2 pbox + 8 brik with a
+    # seed-driven fact flip. The win predicate requires `pbox` count,
+    # `brik` count (medium/hard only), AND a kill quota — so pure-
+    # walls (0 kills) and pure-pbox (no brik) both LOSE on medium/hard
+    # while still winning easy. Hard defines two agent spawn_point
+    # groups (NORTH fact y=14 / SOUTH fact y=26) round-robined by
+    # seed; the scheduled rush waves are staged at BOTH candidate
+    # latitudes so the rusher converges on whichever fact the seed
+    # selected, and a memorised "wall belt near (10,20)" plan cannot
+    # generalise. Security architecture passive-vs-active mitigation
+    # / military fortification anchor.
     "def-walls-vs-towers",
     # Wave-7 REASONING asymmetric-underdog pack — SC2 asymmetric /
     # guerrilla tactics / asymmetric warfare anchor. 2× 2tnk vs 4× e1