no-cheat redesign: build-defensive-tower-line — wide-front LINE topology

Tailor the build-defensive-tower-line pack for the WIDE-FRONT rush
geometry the capability advertises. The previous design had attackers
funnelled through a 4-row corridor (y=18..22) and demanded a 4-pbox
line along that corridor; the rush was concentrated, which made
placement-vs-cluster less discriminating than intended.

New design (per-tier):
* easy — 3-pbox LINE (rungs y=8/20/32), $1800 budget, single rush
wave of 6 e1 (2 per row × 3 rows) at tick 1500. Kill bar 4.
* medium — 5-pbox LINE (rungs y=4/12/20/28/36), $3000 budget, single
rush wave of 10 e1 (2 per row × 5 rows) at tick 2200. Kill bar 7.
* hard — 6-pbox LINE (rungs y=4/10/16/22/28/34), $4800 budget
(= 6 rungs + 2 rebuilds), TWO scheduled rush waves (tick 1800 and
tick 3000) so a rung the first wave razes must be REBUILT before
wave 2 lands — the "attrition over time" mechanic the spec asks
for. Kill bar 8. Hard also flips the agent base latitude per seed
(NORTH y=12 / SOUTH y=28 via spawn_point round-robin) so a memorised
relative-to-base placement plan cannot generalise; the LINE rungs
themselves stay fixed at x=60 since that is map geometry.

Each level spreads attackers across the FULL vertical width of the
playable arena at distinct rows (the spec's WIDE front). The rusher
bot charges the agent fact centroid on the west, so each row's spawn
group walks WEST through x=60 on its starting y — different rows
cross the central column at different y values, forcing a LINE
topology to intercept every row.

The win predicate keeps placement load-bearing: one
`building_in_region` clause per rung at radius 0.5 (cell-exact) so
a cluster on the centre row misses every flank rung, a scatter near
the base misses every rung, and the intended LINE (one pbox per row)
is the only configuration that simultaneously satisfies the count,
all rung clauses, the kill quota, the fact-alive clause and the
within_ticks deadline. `after_ticks` in the fail clause makes
non-winners a real reachable LOSS (no interrupts ⇒ exactly 90 ticks/
step).

Validation (scripted, no model, four-script no-cheat bar):
* stall (observe-only) — LOSS every level + every seed (fact razed by
the rush AND clock runs out with no pbox);
* cluster-on-centre (K pboxes piled on the y=20 row) — LOSS every
level + every seed (count satisfied but flank rungs unmet, flank
rows leak the rush through to the fact);
* scatter-near-base (K pboxes hugging the fact) — LOSS every level +
every seed (every rung region unmet, rush reaches fact past
unguarded front);
* intended LINE (one pbox per rung, with rebuild on hard) — WIN every
level + every seed (count, all rungs, kill quota, fact alive,
within_ticks all satisfied before the deadline).

Pre-existing CLAUDE.md footguns honoured: rusher bot charges centroid;
`place_building` works at arbitrary in-bounds coords (no adjacency);
Building/Defense single-stream queue gives the LINE serial build
time; unarmed enemy fact at (120,20) keeps the engine alive past full
rush elimination so the win/fail check fires (auto-`done`
mitigation); fact-alive uses the present-tense
`building_count_gte:{fact,n:1}` not the one-shot `has_building`;
NO pre-placed agent combat screen, only one non-combatant corner e1
per active spawn group so units_summary is non-empty without leaking
kills.

Tests updated: per-tier rung topology, budget, kill bar, scatter-
near-base policy (replaces the previous random-4-pbox policy), and a
new cluster-on-centre wrong-topology policy. Hard tier has 6 rungs
and TWO scheduled waves; the test_rush_arrives_as_a_scheduled_event
contract now checks the per-tier wave count.

openra_bench/scenarios/packs/build-defensive-tower-line.yaml

@@ -1,64 +1,136 @@
+# build-defensive-tower-line — Build a Defensive Pillbox LINE Across a WIDE Front
+#
+# REASONING focus: when the threat is funnelled along a WIDE front (a
+# rush spread across the full vertical width of the map, not pinched
+# through a single corridor cell), the right defensive architecture is
+# ONE pillbox per row across the FULL width — a LINE that no enemy unit
+# can slip past on an unguarded row. A dense cluster at the centre row
+# wastes overlapping fire on one cell while the flanks stay open; a
+# scatter near the base never engages the rush at all.
+#
+# This pack is the SISTER / INVERSE of `def-tower-line-vs-cluster` (which
+# enforces CLUSTER topology at a single-cell chokepoint, graph min-cut
+# doctrine). Together the two packs discriminate whether the model
+# understands the FORCING GEOMETRY: a chokepoint (single cell on a wide
+# approach → cluster) vs a wide front (full vertical width where every
+# row carries a rush column → line).
+#
+# Real-world anchor:
+#   • military perimeter doctrine — when an attacker can approach across
+#     the full width of a sector, perimeter posts cover EVERY lane
+#     across the front; concentrating the entire garrison at one post
+#     leaves the rest of the front traversable.
+#   • firewall / IDS rule placement — one inspection rule per
+#     protocol/port across the full inspection surface; duplicated rules
+#     on one port leave the rest open.
+#   • MicroRTS defense placement — defending a wide approach demands
+#     spread coverage; concentrating into one cell of an open arena is
+#     known to LOSE to a multi-lane advance.
+#
+# Map: `rush-hour-arena` (128×40, fully open). The agent base sits on
+# the WEST (fact at x=10); the rush wave is injected at the EAST edge
+# (x=100) spread across MULTIPLE distinct y rows that span the full
+# vertical width of the playable area. The `rusher` scripted bot then
+# charges the agent fact centroid, so each row's spawn group walks WEST
+# through the central x=60 column on its way to the fact — different
+# rows cross x=60 at DIFFERENT y values, forcing a LINE topology to
+# intercept every row.
+#
+# pbox is the load-bearing weapon. After the engine pbox-weapon fix
+# (`fix(engine): pbox gets a direct-fire Armament`) a BUILT pbox is an
+# active direct-fire anti-infantry tower (M60mg burst-5; one burst
+# one-shots an e1). With NO pre-placed agent combat screen the pbox
+# LINE is the SOLE source of kill output — a stall / wrong-placement
+# layout kills nothing AND the rush razes the fact.
+#
+# Win predicate (load-bearing decomposition):
+#   • `building_count_gte:{pbox,n:K}` — built the full budget;
+#   • `building_in_region:{pbox, x:60, y:<rung>, radius:0.5, count:1}`
+#     for EACH of the K rung rows across the full front (radius 0.5 ⇒
+#     cell-exact; a cluster on the middle row misses every flank rung,
+#     a scatter near the base misses every rung);
+#   • `units_killed_gte:K` — the pbox LINE must actively KILL the rush,
+#     not just stand (a stall / pure-army layout kills 0);
+#   • `building_count_gte:{fact,n:1}` (PRESENT-TENSE — `has_building`
+#     is the documented CLAUDE.md "ever-seen" footgun);
+#   • `within_ticks` + `after_ticks` fail clause ⇒ a non-finisher is a
+#     real reachable timeout LOSS (no interrupts ⇒ exactly 90 ticks per
+#     step, so `max_turns` is a hard tick budget the `after_ticks`
+#     deadline reliably bites in).
+#
+# Discrimination (four-script bar — scripted, no model needed):
+#   • stall (observe-only): spends nothing; the rush razes the fact →
+#     fact-alive fail clause fires → LOSS. The `after_ticks` deadline is
+#     a backstop so a staller who somehow keeps the fact also times out
+#     (no draw degeneracy).
+#   • cluster-on-centre (K pboxes piled on the y=20 row): satisfies the
+#     count but EVERY flank rung region is empty (radius 0.5 ⇒
+#     cell-exact, the central pile doesn't touch the flanks); the win
+#     never latches and the unguarded flank rows let the rush leak
+#     through → LOSS.
+#   • scatter-near-base (K pboxes hugging the fact west of x=20): every
+#     rung region is empty AND the pboxes are too far west to engage
+#     the rush before it reaches the fact → LOSS.
+#   • intended LINE (one pbox at each of the K corridor rungs at x=60):
+#     every row is covered AND the wave is killed at the central
+#     column AND the fact survives → WIN.
+#
+# Engine footguns honoured:
+#   • `place_building` does NOT enforce build-adjacency (CLAUDE.md) — the
+#     LINE rungs sit deep at x=60 with no nearby agent base; the engine
+#     places them anyway.
+#   • Building / Defense queues feed from the construction yard
+#     (single-stream); the agent must build pboxes serially. The tick
+#     budget on every tier gives the LINE time to assemble BEFORE the
+#     scheduled rush wave hits.
+#   • Hard tier defines TWO agent spawn_point groups (NORTH y=12 / SOUTH
+#     y=28) round-robined by seed (CLAUDE.md hard-tier contract). Enemy
+#     actors do not honour spawn_point, so the rush wave is fixed on the
+#     full-width spawn axis and crosses the LINE rungs identically for
+#     both base latitudes — what flips per seed is the BEARING the rush
+#     approaches the agent fact from, not the rung topology itself.
+#   • An unarmed high-HP enemy `fact` marker at (120,20) keeps the
+#     engine alive past full rush annihilation so the win/fail check
+#     fires (CLAUDE.md auto-`done` mitigation).
+#   • NO pre-placed agent combat screen — one non-combatant e1 in a far
+#     corner per spawn group satisfies the hard-tier env-reset
+#     non-empty-units check while contributing ZERO kills, so a
+#     wrong-placement spend cannot pass the kill clause off it.
+
 meta:
   id: build-defensive-tower-line
-  title: 'Build a Defensive Tower LINE Across the Choke (Not a Cluster, Not a Scatter)'
+  title: 'Build a Defensive Tower LINE Across a WIDE Front (Not a Cluster, Not a Scatter)'
   capability: reasoning
   real_world_meaning: >
-    Where do you commit your defensive structures when the threat is
-    funnelled through a known corridor whose width matters? Military
-    perimeter doctrine and firewall rule design both say: spread the
-    coverage across the full width of the corridor so no enemy unit
-    can slip past on an unguarded row. A single dense cluster wastes
-    overlapping fire on one cell while the corridor edges stay open;
-    a scatter across the map leaves the corridor itself uncovered.
+    Where do you commit your defensive towers when the threat is a rush
+    spread across the FULL WIDTH of the map — not pinched through a
+    single corridor cell, but advancing on every row of a wide front?
+    Military perimeter doctrine and firewall rule design both say:
+    cover EVERY lane across the front, one post per row, so no enemy
+    unit can slip past on an unguarded row. A single dense cluster on
+    one row wastes overlapping fire on one cell while every other row
+    stays open; a scatter near the base never engages the rush at all.
     The win predicate makes the LINE topology load-bearing — total
     pillbox count alone is not enough; ≥1 pillbox must sit on EACH of
-    the corridor's vertical rungs (the four narrow sub-regions that
-    span y=18..22 at the choke column), AND those pillboxes must
-    actually KILL the rush funnelled through the corridor.
+    the front's rung rows (cell-exact via radius 0.5), AND those
+    pillboxes must actually KILL the rush spread across the front.
   robotics_analogue: >
     Network firewall / Web Application Firewall rule placement: when
-    every connection MUST traverse a known ingress (the public WAN
-    edge / the only API gateway), the right architecture is one rule
-    per protocol/port across the FULL inspection surface, not three
-    duplicated rules on one port while the rest stay open. Likewise a
-    physical perimeter patrol covers the WHOLE corridor width — a
-    cluster at one waypoint or a scatter across unrelated nodes both
-    leave the actual approach lane traversable.
+    every protocol/port could be the path of compromise, the right
+    architecture is one rule per port across the full inspection
+    surface, not three duplicated rules on one port while the rest stay
+    open. Likewise a physical perimeter patrol covers EVERY approach
+    lane across the front — a cluster at one waypoint or a scatter
+    across unrelated nodes both leave the actual front lanes
+    traversable. Defense in depth across a wide approach demands one
+    responder per lane, not many responders at one waypoint.
   benchmark_anchor:
     - "ERQA"
     - "MicroRTS defense"
     - "military perimeter"
   author: openra-bench
 
-# rush-hour-arena (128×40). The map has a narrow lane around y≈18..22
-# at mid-map (x≈60); the agent fact sits on the WEST (x=10). The rush
-# arrives as a `scheduled_events: spawn_actors` wave injected EAST of
-# the corridor (x≈80) at a fixed tick — AFTER the agent has had time to
-# build all 4 pillboxes serially. The `rusher` bot charges the agent
-# centroid (the fact on the west), so the wave is forced THROUGH the
-# x=60 corridor on its way to the fact on every seed.
-#
-# pbox is the load-bearing weapon. After the engine pbox-weapon fix
-# (`fix(engine): pbox gets a direct-fire Armament`) a BUILT pbox is an
-# active direct-fire tower (M60mg anti-infantry MG: one burst one-shots
-# an e1). The win predicate now demands a KILL quota the pbox LINE must
-# deliver — there are NO pre-placed agent defenders, so the only source
-# of kill output is the agent's own pillbox LINE. A mis-placed pbox
-# layout (cluster on the centre row, scatter near the base) leaves the
-# corridor rungs open: the rush slips past on an unguarded row, kills
-# nothing, and razes the fact.
-#
-# An unarmed high-HP enemy `fact` far east keeps the engine alive past
-# rush annihilation so the win/fail check actually runs.
-#
-# SISTER PACK: def-tower-line-vs-cluster inverts the topology bar to
-# enforce CLUSTER (graph min-cut doctrine); this pack enforces LINE
-# (corridor-width perimeter doctrine). The two together discriminate
-# whether the model understands the FORCING GEOMETRY: a chokepoint
-# (single cell on a wide approach → cluster) vs a corridor (full
-# vertical width that any one row can leak through → line).
 base_map: rush-hour-arena
-starting_cash: 2400
 
 base:
   agent:
@@ -75,91 +147,87 @@ base:
     - attack_move
     - stop
   planning: true
-  # No interrupts — perimeter design is a STATIC up-front decision
-  # (the corridor is known a priori, the rush composition is fixed).
-  # Dropping interrupts also makes the tick budget deterministic
-  # (each step is exactly 90 ticks ⇒ max_turns is a hard tick
-  # budget that the `after_ticks` fail clause reliably bites in).
+  # No interrupts — perimeter design is a STATIC up-front decision (the
+  # front geometry is known a priori, the rush composition is fixed).
+  # Dropping interrupts also makes the tick budget deterministic (each
+  # step is exactly 90 ticks ⇒ max_turns is a hard tick budget that the
+  # `after_ticks` fail clause reliably bites in).
   interrupts: {}
   termination:
     max_ticks: 12000
   actors: []   # every level supplies its own actor list via overrides.
 
 levels:
-  # ── EASY ── bare LINE skill. Budget covers exactly 4 pbox (2400cr).
-  # Win requires ≥1 pbox in EACH of the 4 corridor rungs (y=18,19,21,22
-  # at x=60, radius 0.5 — only the exact rung cell counts, so a cluster
-  # on y=20 misses ALL FOUR), the full count (4 pbox), a kill quota
-  # (≥4 of the 6-unit rush) AND the fact alive. The rush arrives at
-  # tick 1800 — after the LINE has had time to assemble. A cluster at
-  # (60,20) satisfies the count clause but FAILS each rung AND lets the
-  # rush leak past the open rungs; a random scatter near the base
-  # misses every rung AND kills nothing; a stall loses on the count
-  # clause AND the fact razed by the rush.
+  # ── EASY ── bare LINE skill. Budget covers exactly 3 pbox (1800cr).
+  # Win requires ≥1 pbox in EACH of the 3 front rungs (y=8, 20, 32 at
+  # x=60, radius 0.5 — only the exact rung cell counts, so a cluster on
+  # y=20 misses the y=8 and y=32 flank rungs). The rush arrives at
+  # tick 1500 — after the LINE has had time to assemble. A cluster at
+  # (60,20) satisfies the count clause but FAILS the flank rung clauses
+  # AND lets the flank rush leak through the open rows; a random
+  # scatter near the base misses every rung AND kills nothing; a stall
+  # loses on the count clause AND the fact razed by the rush.
   # max_turns 60 ⇒ reachable tick 93+90·59 = 5403; deadline 5400.
   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 will spawn east of the corridor and must traverse
-    # the narrow corridor at x=60, y=18..22 to reach your base on the
-    # west. Build 4 pillboxes (pbox — 600cr each, budget exactly 2400)
-    # AND place ONE on each of the four corridor rungs (at (60,18),
-    # (60,19), (60,21), (60,22)) so the rusher cannot slip past on any
-    # row. A cluster on the middle of the corridor satisfies the count
-    # but FAILS every rung and lets the rush leak through; a random
-    # scatter near the base fails every rung and kills nothing; a
-    # pure-army layout (no pbox) fails the count and lets the rush
-    # raze the fact. Your pillboxes must kill at least 4 of the rush;
-    # your fact must survive.
-    # 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 rush will funnel through the narrow mid-map corridor at x=60, rows
-    # y=18 to 22. Budget $2400 — build a pillbox on each of those four
-    # rows so nothing slips through. Kill four enemies and keep your
-    # construction yard, within about 60 turns.
+    # A rifle rush will charge across the FULL WIDTH of the front (3
+    # distinct rows: y=8, y=20, y=32 at the east edge). Budget is
+    # exactly $1800 — drop one pillbox on each of those three rows at
+    # x=60 so nothing slips past on any row. A cluster on the centre
+    # row misses both flank rungs and lets the flank rush leak through;
+    # a scatter near the base never engages the rush. Kill at least
+    # four and keep your construction yard standing, within about 60
+    # turns.
     description: >
-      A rifle rush will funnel through the narrow corridor at x=60, rows
-      y=18 to 22, on its way to your base. Budget is exactly $2400 — drop
-      one pillbox on each of those four rows so nothing slips past. Kill
-      at least four and keep your construction yard standing, within about
-      60 turns.
-    starting_cash: 2400
+      A rifle rush charges across the full vertical width of the map —
+      three lanes at y=8, y=20, and y=32 — toward your yard on the west.
+      Budget $1800 — three pillboxes. Drop one on each of those three
+      rows at x=60 so no lane is open. A cluster on the centre row
+      leaves both flanks unguarded; a scatter near the base never meets
+      the rush. Four kills, yard intact, within about 60 turns.
+    starting_cash: 1800
     overrides:
       actors:
+        # Pre-placed agent base on the WEST. NO combat units near the
+        # base — the pbox LINE must be the sole source of kill output.
         - {type: fact, owner: agent, position: [10, 20]}
         - {type: tent, owner: agent, position: [14, 18]}
         - {type: powr, owner: agent, position: [14, 22]}
         # ONE non-combatant agent e1 parked in the far SW corner,
-        # nowhere near the y=20 rush lane. It exists only so
-        # units_summary is non-empty (hard-tier env-reset check); it
-        # never reaches combat and contributes ZERO kills — the pbox
-        # LINE is the sole source of kill output.
+        # nowhere near any rush lane. It exists only so units_summary
+        # is non-empty (hard-tier env-reset check); it never reaches
+        # combat and contributes ZERO kills — the pbox LINE is the sole
+        # source of kill output, so a scatter or stall play cannot pass
+        # the kill clause off it.
         - {type: e1, owner: agent, position: [4, 36], stance: 2}
         # Unarmed high-HP marker (anti-DRAW): keeps the episode alive
         # past full rusher elimination so the win/fail check fires.
         - {type: fact, owner: enemy, position: [120, 20]}
-      # Scheduled rush wave — injected at tick 1800, EAST of the
-      # corridor on the y=20 lane. The rusher bot charges the agent
-      # centroid (the fact at x=10), so the wave is forced WEST through
-      # the x=60 corridor. By tick 1800 all 4 LINE pillboxes are built;
-      # a complete LINE shreds the wave at the corridor.
+      # Scheduled rush wave — 6 e1 spread across the full vertical
+      # width (2 per row × 3 rows: y=8, y=20, y=32), injected at tick
+      # 1500 from the east at x=100. By tick 1500 all 3 LINE pillboxes
+      # are built (the 3rd pbox completes ~tick 1350 from a fresh-cash
+      # tent + serial defense queue). The rusher charges the agent
+      # centroid (fact at (10,20)), so each row's spawn group walks
+      # WEST through x=60 — the y=8 and y=32 flank groups cross x=60 at
+      # their starting y values, demanding a LINE that covers every
+      # row.
       scheduled_events:
-        - tick: 1800
+        - tick: 1500
           type: spawn_actors
           actors:
-            - {type: e1, owner: enemy, position: [80, 20], stance: 3, count: 5}
-            - {type: e3, owner: enemy, position: [82, 20], stance: 3, count: 1}
+            - {type: e1, owner: enemy, position: [100, 8],  stance: 3, count: 2}
+            - {type: e1, owner: enemy, position: [100, 20], stance: 3, count: 2}
+            - {type: e1, owner: enemy, position: [100, 32], stance: 3, count: 2}
     win_condition:
       all_of:
-        - building_count_gte: {type: pbox, n: 4}
-        - building_in_region: {type: pbox, x: 60, y: 18, radius: 0.5, count: 1}
-        - building_in_region: {type: pbox, x: 60, y: 19, radius: 0.5, count: 1}
-        - building_in_region: {type: pbox, x: 60, y: 21, radius: 0.5, count: 1}
-        - building_in_region: {type: pbox, x: 60, y: 22, radius: 0.5, count: 1}
+        - building_count_gte: {type: pbox, n: 3}
+        - building_in_region: {type: pbox, x: 60, y: 8,  radius: 0.5, count: 1}
+        - building_in_region: {type: pbox, x: 60, y: 20, radius: 0.5, count: 1}
+        - building_in_region: {type: pbox, x: 60, y: 32, radius: 0.5, count: 1}
         - units_killed_gte: 4
         - building_count_gte: {type: fact, n: 1}
         - within_ticks: 5400
@@ -169,55 +237,67 @@ levels:
         - not: {building_count_gte: {type: fact, n: 1}}
     max_turns: 60
 
-  # ── MEDIUM ── +1 axis: HEAVIER wave (rusher band ~doubled, +1 e3)
-  # with the SAME tight 4-pbox budget and a higher kill bar (≥7). The
-  # cluster, scatter, and pure-army layouts still all lose the same way
-  # as easy. The LINE must be COMPLETE (all four rungs covered) so the
-  # corridor leaks nothing — a single open rung lets enough of the
-  # heavier wave through to fail the kill bar AND raze the fact.
-  # max_turns 60 ⇒ reachable tick 5403; deadline 5400.
+  # ── MEDIUM ── +1 axis: 5-pbox LINE across the full front (rungs at
+  # y=4, 12, 20, 28, 36 — finer spacing than easy, covering the full
+  # 36-cell playable height). Budget covers exactly 5 pbox (3000cr).
+  # The rush wave is 10 e1 (2 per row × 5 rows), so a complete LINE
+  # must hold every row — a 3-rung easy-style layout leaves 2 rows
+  # unguarded and the flanks leak. A cluster on y=20 misses the y=4 /
+  # y=12 / y=28 / y=36 rungs (radius 0.5 ⇒ cell-exact). max_turns 60
+  # ⇒ reachable tick 5403; deadline 5400.
   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.
     #
-    # Same forced rusher corridor at x=60, y=18..22. Build 4 pillboxes
-    # (budget 2400cr = exactly 4 pbox at 600 each) AND place ONE on
-    # each of the four corridor rungs (at (60,18), (60,19), (60,21),
-    # (60,22)). The rush wave is heavier than easy — the complete LINE
-    # must shred it at the corridor. Your pillboxes must kill at least
-    # 7 of the rush; a cluster, a scatter, and a pure-army layout all
-    # lose; the fact must survive.
+    # The rush widens to 5 distinct rows (y=4, 12, 20, 28, 36). Build 5
+    # pillboxes (budget 3000cr = exactly 5 pbox at 600 each) AND place
+    # ONE on each of those five rows at x=60. The complete 5-rung LINE
+    # is required — any open rung lets the rush slip past on that row.
+    # Kill at least seven and keep your construction yard, within about
+    # 60 turns.
     description: >
-      Same corridor at x=60, y=18 to 22, heavier rush wave. Budget
-      $2400 — build a pillbox on each of those four rows. Kill seven
-      enemies and keep your construction yard, within about 60 turns.
-    starting_cash: 2400
+      A wider rush now: five lanes at y=4, y=12, y=20, y=28, y=36 spread
+      across the full vertical front. Budget $3000 — five pillboxes.
+      One on each of those five rows at x=60; an easy-style three-rung
+      line leaves two flank rows open. Seven kills, yard intact, within
+      about 60 turns.
+    starting_cash: 3000
     overrides:
       actors:
         - {type: fact, owner: agent, position: [10, 20]}
         - {type: tent, owner: agent, position: [14, 18]}
         - {type: powr, owner: agent, position: [14, 22]}
-        # Non-combatant SW-corner e1 (see easy) — non-empty
-        # units_summary, zero kill contribution.
+        # Two powr to cover the 5-pbox power draw (5×-20 = -100; tent
+        # also draws; one powr +100 not enough margin once the rush
+        # damages buildings, so use 2 powr for stability).
+        - {type: powr, owner: agent, position: [14, 16]}
+        # Non-combatant SW-corner e1 (see easy).
         - {type: e1, owner: agent, position: [4, 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 east of
-      # the corridor, injected at tick 1800.
+      # Heavier rush wave: 10 e1 (2 per row × 5 rows), injected at tick
+      # 2200 — after the intended 5-pbox LINE has time to assemble (~
+      # tick 1700 for the 5th from a fresh-cash tent + serial defense
+      # queue). The rusher charges the agent centroid, so each row's
+      # spawn group walks WEST through x=60 on its starting y.
       scheduled_events:
-        - tick: 1800
+        - tick: 2200
           type: spawn_actors
           actors:
-            - {type: e1, owner: enemy, position: [80, 20], stance: 3, count: 8}
-            - {type: e3, owner: enemy, position: [82, 20], stance: 3, count: 2}
+            - {type: e1, owner: enemy, position: [100, 4],  stance: 3, count: 2}
+            - {type: e1, owner: enemy, position: [100, 12], stance: 3, count: 2}
+            - {type: e1, owner: enemy, position: [100, 20], stance: 3, count: 2}
+            - {type: e1, owner: enemy, position: [100, 28], stance: 3, count: 2}
+            - {type: e1, owner: enemy, position: [100, 36], stance: 3, count: 2}
     win_condition:
       all_of:
-        - building_count_gte: {type: pbox, n: 4}
-        - building_in_region: {type: pbox, x: 60, y: 18, radius: 0.5, count: 1}
-        - building_in_region: {type: pbox, x: 60, y: 19, radius: 0.5, count: 1}
-        - building_in_region: {type: pbox, x: 60, y: 21, radius: 0.5, count: 1}
-        - building_in_region: {type: pbox, x: 60, y: 22, radius: 0.5, count: 1}
+        - building_count_gte: {type: pbox, n: 5}
+        - building_in_region: {type: pbox, x: 60, y: 4,  radius: 0.5, count: 1}
+        - building_in_region: {type: pbox, x: 60, y: 12, radius: 0.5, count: 1}
+        - building_in_region: {type: pbox, x: 60, y: 20, radius: 0.5, count: 1}
+        - building_in_region: {type: pbox, x: 60, y: 28, radius: 0.5, count: 1}
+        - building_in_region: {type: pbox, x: 60, y: 36, radius: 0.5, count: 1}
         - units_killed_gte: 7
         - building_count_gte: {type: fact, n: 1}
         - within_ticks: 5400
@@ -227,73 +307,102 @@ levels:
         - not: {building_count_gte: {type: fact, n: 1}}
     max_turns: 60
 
-  # ── HARD ── +1 axis: TWO spawn_point groups so the agent base
-  # latitude flips by seed (NORTH (10,12) vs SOUTH (10,28)). The
-  # rusher band is symmetric across y=20 and ALWAYS places (enemy
-  # actors don't honour spawn_point — CLAUDE.md), so the corridor
-  # column at x=60 remains the choke for both seeds, but the rush
-  # geometry approaches each base from a different bearing. The
-  # corridor is still y=18..22 at x=60 (it's a fixed map feature) so
-  # the LINE topology is identical across seeds — what flips is the
-  # agent's interpretation of "which corridor" to defend (the NORTH
-  # spawn could be tempted to cover y=14..18, the SOUTH spawn to
-  # cover y=22..26; both are WRONG — the corridor itself is at
-  # y=18..22 regardless of base latitude). max_turns 70 ⇒ reachable
-  # tick 93+90·69 = 6303; deadline 6300.
+  # ── HARD ── +2 axes: (1) a 6-rung LINE (y=4, 10, 16, 22, 28, 34 at
+  # x=60) covering the full front with TIGHTER spacing AND (2) ATTRITION
+  # over time via TWO scheduled waves (tick 1800 and tick 3000), so a
+  # pbox damaged in wave 1 may fall to wave 2 — the agent must REBUILD
+  # any rung the first wave razes before the second wave hits. Budget
+  # 4800cr = exactly 8 pbox (6 rungs + 2 rebuilds), so the cash is
+  # tight: there is no slack for a 7th rung OR a pbox parked near the
+  # base. Hard tier also flips the agent base latitude per seed (NORTH
+  # y=12 / SOUTH y=28 round-robined via spawn_point) — the LINE
+  # topology is identical across seeds (the front rungs are fixed map
+  # geometry at x=60) but the agent base bearing flips, so a memorised
+  # relative-to-base placement plan cannot generalise. Enemies don't
+  # honour spawn_point (CLAUDE.md), so the rush waves inject on both
+  # bases' candidate latitudes regardless of seed — but the rush
+  # geometry is the SAME because the rusher charges the agent centroid,
+  # and on either base latitude the LINE rungs at x=60 are what catches
+  # the rush before it reaches the fact. max_turns 70 ⇒ reachable tick
+  # 93+90·69 = 6303; deadline 6300.
   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.
     #
-    # Agent base latitude flips between NORTH (y=12) and SOUTH (y=28)
-    # by seed. Build 4 pillboxes (budget 2400cr = exactly 4 pbox at
-    # 600 each) AND place ONE on each of the four corridor rungs
-    # (at (60,18), (60,19), (60,21), (60,22)). The corridor at x=60
-    # y=18..22 is a fixed map feature — covering the rows next to your
-    # base instead (y=14..18 for NORTH, y=22..26 for SOUTH) FAILS the
-    # rung clauses and lets the rush leak through. Your pillboxes must
-    # kill at least 7 of the rush; the fact must survive.
+    # The full front widens to 6 rungs (y=4, 10, 16, 22, 28, 34) and the
+    # rush arrives in TWO waves (attrition): wave 1 at tick 1800 plus
+    # wave 2 at tick 3000. Budget 4800cr (= 8 pbox) — enough for the 6
+    # rungs PLUS 2 rebuilds for any rung the first wave razes. Your
+    # base latitude flips between NORTH (y=12) and SOUTH (y=28) by seed,
+    # so the bearing the rush approaches the fact from changes per
+    # seed; the LINE rungs themselves stay fixed at x=60. Kill at least
+    # 8, keep the fact, within about 70 turns.
     description: >
-      Same fixed corridor at x=60, rows y=18 to 22 — but your base may sit
-      to its north or south depending on seed. Don't cover the rows next
-      to your own base; the rush still funnels through the mid-map gap.
-      Build one pillbox on each of the four corridor rungs, kill at least
-      seven, and keep your construction yard within about 70 turns.
+      The front widens to six lanes (y=4, 10, 16, 22, 28, 34) and the
+      rush arrives in TWO waves — pbox attrition is real, you must
+      rebuild lost rungs between waves. Budget $4800 = six rungs plus
+      two rebuilds. Your base flips NORTH/SOUTH by seed; the rungs at
+      x=60 don't. Eight kills, yard intact, within about 70 turns.
+    starting_cash: 4800
     overrides:
       actors:
-        # spawn_point 0 — NORTH base at y=12. Fact at (10, 12);
-        # tent/powr offset west so they aren't directly on the
-        # rusher path. Non-combatant corner e1 in the far SW.
+        # spawn_point 0 — NORTH base at y=12. Fact at (10, 12); tent/
+        # powr offset west so they aren't directly on the rusher path.
+        # Two powr for the 8-pbox power draw (8×-20=-160; 2 powr=+200).
+        # Non-combatant corner e1 in the far SW.
         - {type: fact, owner: agent, position: [10, 12], spawn_point: 0}
         - {type: tent, owner: agent, position: [6,  12], spawn_point: 0}
         - {type: powr, owner: agent, position: [6,  14], spawn_point: 0}
+        - {type: powr, owner: agent, position: [6,  10], spawn_point: 0}
         - {type: e1,   owner: agent, position: [4, 36], stance: 2, spawn_point: 0}
         # spawn_point 1 — SOUTH base at y=28 (mirror across y=20).
+        # Non-combatant corner e1 in the far NW.
         - {type: fact, owner: agent, position: [10, 28], spawn_point: 1}
         - {type: tent, owner: agent, position: [6,  28], spawn_point: 1}
         - {type: powr, owner: agent, position: [6,  26], spawn_point: 1}
+        - {type: powr, owner: agent, position: [6,  30], spawn_point: 1}
         - {type: e1,   owner: agent, position: [4,  4], stance: 2, spawn_point: 1}
         # Anti-DRAW marker (enemy fact doesn't honour spawn_point).
         - {type: fact, owner: enemy, position: [120, 20]}
-      # Scheduled rush wave — symmetric on the y=20 lane east of the
-      # corridor, injected at tick 1800. The rusher charges the agent
-      # centroid so its path crosses the x=60 corridor on every seed
-      # regardless of which base latitude was picked. The scheduled
-      # spawn list is not spawn_point-filtered, so it injects once.
+      # Two-wave attrition. Each wave is 6 e1 (1 per row × 6 rows) at
+      # tick 1800 and tick 3000. The first wave finishes ~tick 2500,
+      # giving the agent a ~500-tick window to rebuild any razed rung
+      # before wave 2 lands. The serial defense queue can build 1
+      # pbox per ~270 ticks, so 2 rebuilds in 500 ticks is the budget
+      # the design enforces. A pure-stamp policy that places 6 pboxes
+      # and walks away will lose ANY rung wave 1 razed, then the
+      # surviving line fails to cover that row in wave 2 → rung clause
+      # unmet → LOSS.
       scheduled_events:
         - tick: 1800
           type: spawn_actors
           actors:
-            - {type: e1, owner: enemy, position: [80, 20], stance: 3, count: 8}
-            - {type: e3, owner: enemy, position: [82, 20], stance: 3, count: 2}
+            - {type: e1, owner: enemy, position: [100, 4],  stance: 3, count: 1}
+            - {type: e1, owner: enemy, position: [100, 10], stance: 3, count: 1}
+            - {type: e1, owner: enemy, position: [100, 16], stance: 3, count: 1}
+            - {type: e1, owner: enemy, position: [100, 22], stance: 3, count: 1}
+            - {type: e1, owner: enemy, position: [100, 28], stance: 3, count: 1}
+            - {type: e1, owner: enemy, position: [100, 34], stance: 3, count: 1}
+        - tick: 3000
+          type: spawn_actors
+          actors:
+            - {type: e1, owner: enemy, position: [100, 4],  stance: 3, count: 1}
+            - {type: e1, owner: enemy, position: [100, 10], stance: 3, count: 1}
+            - {type: e1, owner: enemy, position: [100, 16], stance: 3, count: 1}
+            - {type: e1, owner: enemy, position: [100, 22], stance: 3, count: 1}
+            - {type: e1, owner: enemy, position: [100, 28], stance: 3, count: 1}
+            - {type: e1, owner: enemy, position: [100, 34], stance: 3, count: 1}
     win_condition:
       all_of:
-        - building_count_gte: {type: pbox, n: 4}
-        - building_in_region: {type: pbox, x: 60, y: 18, radius: 0.5, count: 1}
-        - building_in_region: {type: pbox, x: 60, y: 19, radius: 0.5, count: 1}
-        - building_in_region: {type: pbox, x: 60, y: 21, radius: 0.5, count: 1}
+        - building_count_gte: {type: pbox, n: 6}
+        - building_in_region: {type: pbox, x: 60, y: 4,  radius: 0.5, count: 1}
+        - building_in_region: {type: pbox, x: 60, y: 10, radius: 0.5, count: 1}
+        - building_in_region: {type: pbox, x: 60, y: 16, radius: 0.5, count: 1}
         - building_in_region: {type: pbox, x: 60, y: 22, radius: 0.5, count: 1}
-        - units_killed_gte: 7
+        - building_in_region: {type: pbox, x: 60, y: 28, radius: 0.5, count: 1}
+        - building_in_region: {type: pbox, x: 60, y: 34, radius: 0.5, count: 1}
+        - units_killed_gte: 8
         - building_count_gte: {type: fact, n: 1}
         - within_ticks: 6300
     fail_condition:

tests/test_build_defensive_tower_line.py

@@ -1,13 +1,15 @@
 """build-defensive-tower-line scenario family, full loop on Rust.
 
-The pack tests DEFENSIVE PERIMETER TOPOLOGY: when the threat is funnelled
-through a known corridor whose WIDTH matters (y=18..22 at x=60), the right
-architecture is one pbox per row across the FULL corridor width (a LINE),
-NOT a cluster on the centre row and NOT a scatter near the base. This is
-the sibling/inverse of `def-tower-line-vs-cluster` (which forces a
-CLUSTER at a single bottleneck cell); together the two packs discriminate
-whether the model understands the FORCING GEOMETRY (single-cell chokepoint
-vs corridor-width approach).
+The pack tests DEFENSIVE PERIMETER TOPOLOGY ACROSS A WIDE FRONT: when
+the threat is a rush spread across the FULL VERTICAL WIDTH of the map
+(multiple distinct rows simultaneously), not pinched through a single
+corridor cell, the right architecture is one pbox per row across the
+FULL width (a LINE). A dense cluster on one row leaves every other row
+unguarded; a scatter near the base never engages the rush. This is the
+sibling/inverse of `def-tower-line-vs-cluster` (which forces a CLUSTER
+at a single bottleneck cell); together the two packs discriminate
+whether the model understands the FORCING GEOMETRY (single-cell
+chokepoint vs wide-front approach).
 
 Anchors: ERQA spatial commit / MicroRTS defense placement / military
 perimeter (firewall rule placement).
@@ -15,23 +17,26 @@ perimeter (firewall rule placement).
 The pbox is the load-bearing weapon. After the engine pbox-weapon fix
 (`fix(engine): pbox gets a direct-fire Armament`) a BUILT pbox is an
 active direct-fire anti-infantry tower. The rush arrives as a
-`scheduled_events: spawn_actors` wave EAST of the corridor at tick 1800
-— AFTER the agent has had time to build all 4 pillboxes serially — and
-the `rusher` bot charges the agent fact on the west, so the wave is
-forced WEST through the x=60 corridor. There are NO pre-placed agent
-defenders, so the pbox LINE is the sole source of kill output.
+`scheduled_events: spawn_actors` wave (or two waves, on hard) EAST of
+the central column spread across multiple distinct rows AFTER the
+agent has had time to build its LINE serially, and the `rusher` bot
+charges the agent fact on the west, so each row's spawn group walks
+WEST through the x=60 column on its starting y. There are NO pre-
+placed agent defenders, so the pbox LINE is the sole source of kill
+output.
 
 The win predicate makes the LINE topology load-bearing — total pbox
 count alone is not enough:
 
-* `building_count_gte:{pbox, n:4}` ⇒ the agent built the full budget;
-* `building_in_region:{pbox, x:60, y:Y, radius:0.5, count:1}` for each
-  of the four corridor rungs Y ∈ {18,19,21,22} ⇒ exactly one pbox per
-  row across the corridor (a tiny radius 0.5 means only the exact cell
-  counts, so a cluster on (60,20) misses ALL FOUR rungs and a scatter
-  near the base misses all four);
+* `building_count_gte:{pbox, n:K}` ⇒ the agent built the full budget
+  (K = 3 easy / 5 medium / 6 hard);
+* `building_in_region:{pbox, x:60, y:Y, radius:0.5, count:1}` for
+  EACH of the K front rungs ⇒ exactly one pbox per row across the
+  front (a tiny radius 0.5 means only the exact cell counts, so a
+  cluster on (60,20) misses all flank rungs and a scatter near the
+  base misses every rung);
 * `units_killed_gte:K` ⇒ the pbox LINE must actively KILL the rush
-  funnelled through the corridor (a stall / pure-army layout kills 0);
+  spread across the front (a stall / pure-army layout kills 0);
 * `building_count_gte:{fact,n:1}` (present-tense — `has_building` is
   the one-shot "ever-seen" set, see CLAUDE.md footgun);
 * `within_ticks` paired with `after_ticks` in the fail clause ⇒ a
@@ -39,13 +44,23 @@ count alone is not enough:
   pack ⇒ each step is exactly 90 ticks, so max_turns is a hard tick
   budget that the `after_ticks` deadline reliably bites in).
 
+Per-tier design:
+* easy   — 3-pbox LINE (rungs y=8/20/32), budget $1800, one wave.
+* medium — 5-pbox LINE (rungs y=4/12/20/28/36), budget $3000, one wave.
+* hard   — 6-pbox LINE (rungs y=4/10/16/22/28/34), budget $4800
+  (= 6 rungs + 2 rebuilds), TWO scheduled waves (tick 1800 + tick
+  3000) so a rung the first wave razes must be REBUILT before wave 2.
+  Hard also flips the agent base latitude per seed (NORTH y=12 /
+  SOUTH y=28 via spawn_point) so a memorised relative-to-base
+  placement cannot generalise.
+
 The scripted-policy validations prove deterministically that:
 
-* the intended LINE policy (one pbox at each of the four corridor rung
-  cells) WINS every level + every hard seed (1..4);
-* stall / random-4-pbox (4 pboxes placed near the base, away from the
-  corridor) both LOSE every level + every hard seed — a real LOSS,
-  not a draw (the rung clauses are never satisfied);
+* the intended LINE policy (one pbox at each front rung, with rebuild
+  on hard) WINS every level + every hard seed (1..4);
+* stall / cluster-on-centre / scatter-near-base all LOSE every level +
+  every hard seed — a real LOSS, not a draw (the rung clauses are
+  never satisfied);
 * the hard tier defines ≥2 spawn_point groups (NORTH base y=12 / SOUTH
   base y=28) so a memorised base-relative placement cannot generalise.
 """
@@ -65,16 +80,36 @@ PACK = PACKS_DIR / "build-defensive-tower-line.yaml"
 LEVELS = ("easy", "medium", "hard")
 SEEDS = (1, 2, 3, 4)
 
-# Required corridor rung cells (the four "rungs" spanning y=18..22 at
-# the choke column x=60; y=20 is the middle that the LINE topology
-# leaves open by construction — placing on y=20 won't satisfy any rung).
-RUNGS = [(60, 18), (60, 19), (60, 21), (60, 22)]
+# Per-tier rung topology (front rows across the full vertical width at
+# x=60). A cluster on the centre row misses every flank rung because the
+# region predicate uses radius 0.5 (cell-exact).
+RUNGS_BY_LEVEL = {
+    "easy":   [(60, 8),  (60, 20), (60, 32)],
+    "medium": [(60, 4),  (60, 12), (60, 20), (60, 28), (60, 36)],
+    "hard":   [(60, 4),  (60, 10), (60, 16), (60, 22), (60, 28), (60, 34)],
+}
+
+CASH_BY_LEVEL = {"easy": 1800, "medium": 3000, "hard": 4800}
 
-# Cells used by the "random-4-pbox" wrong-topology policy: 4 pboxes
-# clustered near the base rather than along the corridor. None of these
+# Cells used by the "scatter near base" wrong-topology policy: pboxes
+# clustered near the base rather than across the front. None of these
 # lie inside ANY rung region (radius 0.5 around the rung cells), so the
 # region clauses are all unsatisfied.
-RANDOM_CELLS_NEAR_BASE = [(20, 18), (22, 20), (24, 22), (26, 19)]
+SCATTER_NEAR_BASE_BY_LEVEL = {
+    "easy":   [(20, 18), (22, 20), (24, 22)],
+    "medium": [(20, 18), (22, 20), (24, 22), (26, 19), (18, 21)],
+    "hard":   [(20, 18), (22, 20), (24, 22), (26, 19), (18, 21), (16, 23)],
+}
+
+# Cells used by the "cluster on centre row" wrong-topology policy:
+# pboxes piled on the centre rung (y=20). Satisfies the count clause
+# (and on hard meets the y=20-adjacent rungs if they exist) but misses
+# every other rung because radius 0.5 is cell-exact.
+CLUSTER_ON_CENTRE_BY_LEVEL = {
+    "easy":   [(60, 19), (60, 20), (60, 21)],
+    "medium": [(60, 18), (60, 19), (60, 20), (60, 21), (60, 22)],
+    "hard":   [(60, 17), (60, 18), (60, 19), (60, 20), (60, 21), (60, 22)],
+}
 
 
 # ── scripted policies ────────────────────────────────────────────────
@@ -86,55 +121,76 @@ def stall(rs, C):
     return [C.observe()]
 
 
-def make_line():
-    """Intended LINE topology: one pbox at EACH of the four corridor
-    rung cells (60,18) (60,19) (60,21) (60,22)."""
+def make_line(level: str):
+    """Intended LINE topology: one pbox at EACH front rung. On hard the
+    policy also REBUILDS any rung the first wave razes (the cash budget
+    has slack for ≤2 rebuilds across the two-wave attrition)."""
+    rungs = RUNGS_BY_LEVEL[level]
 
     def policy(rs, C):
         own_b = rs.get("own_buildings") or []
-        n = sum(1 for b in own_b if b.get("type") == "pbox")
+        pboxes = [b for b in own_b if b.get("type") == "pbox"]
+        present_cells = {
+            (int(b["cell_x"]), int(b["cell_y"])) for b in pboxes
+        }
         prod = rs.get("production") or []
-        prod_items = [p.get("item") for p in prod if isinstance(p, dict)]
-        # Once 4 pboxes are up, idle (the win clause re-evaluates each turn).
-        if n >= len(RUNGS):
-            return [C.observe()]
-        cmds = []
-        if "pbox" not in prod_items:
-            cmds.append(C.build("pbox"))
-        cmds.append(C.place_building("pbox", RUNGS[n][0], RUNGS[n][1]))
-        return cmds
+        prod_items = [
+            p.get("item") for p in prod if isinstance(p, dict)
+        ]
+        # Find the first rung that is currently uncovered (initial
+        # build or post-attrition rebuild) and (build +) place there.
+        for cell in rungs:
+            if cell not in present_cells:
+                cmds = []
+                if "pbox" not in prod_items:
+                    cmds.append(C.build("pbox"))
+                cmds.append(C.place_building("pbox", cell[0], cell[1]))
+                return cmds
+        # All rungs currently covered — idle.
+        return [C.observe()]
 
     return policy
 
 
-def make_random_4_pbox():
-    """WRONG TOPOLOGY: 4 pboxes placed near the base (not at the
-    corridor rungs). Satisfies `building_count_gte:{pbox,n:4}` but
-    FAILS every rung region (none of the cells lie in any rung's
-    radius-0.5 disk), so the win predicate cannot fire."""
+def _wrong_topology_policy(cells):
+    """Pile pboxes at a fixed list of cells (count-only, no rung
+    rebuilding). Used for cluster-on-centre and scatter-near-base."""
+    cells = list(cells)
 
     def policy(rs, C):
         own_b = rs.get("own_buildings") or []
         n = sum(1 for b in own_b if b.get("type") == "pbox")
         prod = rs.get("production") or []
-        prod_items = [p.get("item") for p in prod if isinstance(p, dict)]
-        if n >= len(RANDOM_CELLS_NEAR_BASE):
+        prod_items = [
+            p.get("item") for p in prod if isinstance(p, dict)
+        ]
+        if n >= len(cells):
             return [C.observe()]
         cmds = []
         if "pbox" not in prod_items:
             cmds.append(C.build("pbox"))
-        cmds.append(
-            C.place_building(
-                "pbox",
-                RANDOM_CELLS_NEAR_BASE[n][0],
-                RANDOM_CELLS_NEAR_BASE[n][1],
-            )
-        )
+        cmds.append(C.place_building("pbox", cells[n][0], cells[n][1]))
         return cmds
 
     return policy
 
 
+def make_cluster_on_centre(level: str):
+    """WRONG TOPOLOGY: K pboxes piled on the centre row (y≈20).
+    Satisfies the count and the y=20 rung (if it exists) but misses
+    every flank rung because the rung regions are radius 0.5 (cell-
+    exact). The unguarded flank rows let the rush leak past."""
+    return _wrong_topology_policy(CLUSTER_ON_CENTRE_BY_LEVEL[level])
+
+
+def make_scatter_near_base(level: str):
+    """WRONG TOPOLOGY: K pboxes hugging the fact west of x=20. Misses
+    every front rung AND too far west to engage the rush before it
+    reaches the fact (on harder tiers the flank rows reach the fact
+    without ever encountering the LINE)."""
+    return _wrong_topology_policy(SCATTER_NEAR_BASE_BY_LEVEL[level])
+
+
 # ── scenario-shape invariants ────────────────────────────────────────
 
 
@@ -148,8 +204,9 @@ def test_pack_compiles_with_three_levels_and_rusher_bot():
     assert "ERQA" in anchors, anchors
     assert "MicroRTS defense" in anchors, anchors
     assert "military perimeter" in anchors, anchors
-    # Rusher bot wired through (charges agent centroid → forces the
-    # rush path through the corridor on every seed).
+    # Rusher bot wired through (charges agent centroid → forces each
+    # row's rush column WEST through the central x=60 LINE on every
+    # seed).
     for lvl in LEVELS:
         c = compile_level(pack, lvl)
         assert c.map_supported
@@ -159,14 +216,18 @@ def test_pack_compiles_with_three_levels_and_rusher_bot():
         assert str(bot).lower() == "rusher", (lvl, bot)
 
 
-def test_starting_cash_is_exact_pbox_budget():
-    """The cash is intentionally tight (4 pbox at 600 each = 2400 on
-    every level, zero slack). A model that spends on units OR extra
-    power runs out before the count clause is satisfied."""
+def test_starting_cash_scales_per_tier_for_pbox_budget():
+    """Cash is intentionally tight per tier — exactly K pboxes for
+    easy (K=3) and medium (K=5), plus a 2-pbox rebuild margin for hard
+    (K=6+2 rebuilds for the two-wave attrition) — so a model that
+    spends on units OR extra rebuilds beyond the design cannot pass
+    the count clause."""
     pack = load_pack(PACK)
     for lvl in LEVELS:
         c = compile_level(pack, lvl)
-        assert c.starting_cash == 2400, (lvl, c.starting_cash)
+        assert c.starting_cash == CASH_BY_LEVEL[lvl], (
+            lvl, c.starting_cash, CASH_BY_LEVEL[lvl]
+        )
 
 
 @pytest.mark.parametrize("level", LEVELS)
@@ -208,28 +269,30 @@ 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_one_pbox_per_corridor_rung():
-    """The LINE-enforcement contract: every level's win clause requires
-    exactly one pbox in EACH of the four corridor rungs at x=60
-    y∈{18,19,21,22}. A cluster on the centre row (y=20) misses all four
-    rungs because each rung region has radius 0.5 (cell-exact)."""
-    for lvl in LEVELS:
-        c = compile_level(load_pack(PACK), lvl)
-        wc = c.win_condition.model_dump(exclude_none=True)
-        rungs_seen = set()
-        for clause in wc.get("all_of", []) or []:
-            br = clause.get("building_in_region")
-            if (
-                isinstance(br, dict)
-                and br.get("type") == "pbox"
-                and int(br.get("x", -1)) == 60
-                and int(br.get("count", 0)) == 1
-                and float(br.get("radius", 0)) <= 1.0
-            ):
-                rungs_seen.add(int(br["y"]))
-        assert rungs_seen == {18, 19, 21, 22}, (
-            f"{lvl}: corridor rungs y∈{{18,19,21,22}} required, got {sorted(rungs_seen)}"
-        )
+@pytest.mark.parametrize("level", LEVELS)
+def test_win_requires_one_pbox_per_front_rung(level):
+    """The LINE-enforcement contract: each level's win clause requires
+    exactly one pbox in EACH of the front rungs at x=60 spanning the
+    full vertical width. A cluster on the centre row (y=20) misses
+    every flank rung because each rung region has radius 0.5 (cell-
+    exact). The rungs grow per tier (3 easy / 5 medium / 6 hard)."""
+    expected = {y for (_, y) in RUNGS_BY_LEVEL[level]}
+    c = compile_level(load_pack(PACK), level)
+    wc = c.win_condition.model_dump(exclude_none=True)
+    rungs_seen = set()
+    for clause in wc.get("all_of", []) or []:
+        br = clause.get("building_in_region")
+        if (
+            isinstance(br, dict)
+            and br.get("type") == "pbox"
+            and int(br.get("x", -1)) == 60
+            and int(br.get("count", 0)) == 1
+            and float(br.get("radius", 0)) <= 1.0
+        ):
+            rungs_seen.add(int(br["y"]))
+    assert rungs_seen == expected, (
+        f"{level}: front rungs y∈{sorted(expected)} required, got {sorted(rungs_seen)}"
+    )
 
 
 def test_win_requires_a_kill_quota():
@@ -251,7 +314,9 @@ def test_win_requires_a_kill_quota():
 def test_rush_arrives_as_a_scheduled_event():
     """The rush is injected via `scheduled_events: spawn_actors` AFTER the
     LINE has time to assemble — there is no t=0 enemy band racing the
-    build. This is what makes the build/rush race fair."""
+    build. This is what makes the build/rush race fair. Hard tier has
+    TWO scheduled waves (attrition mechanic)."""
+    expected_wave_counts = {"easy": 1, "medium": 1, "hard": 2}
     for lvl in LEVELS:
         pack = load_pack(PACK)
         raw = pack.levels[lvl]
@@ -260,25 +325,34 @@ def test_rush_arrives_as_a_scheduled_event():
             ov = ov.model_dump(exclude_none=True)
         evts = ov.get("scheduled_events") or []
         assert evts, f"{lvl}: expected a scheduled rush wave"
-        assert any(e.get("type") == "spawn_actors" for e in evts), (lvl, evts)
+        spawn_waves = [e for e in evts if e.get("type") == "spawn_actors"]
+        assert spawn_waves, (lvl, evts)
+        assert len(spawn_waves) == expected_wave_counts[lvl], (
+            f"{lvl}: expected {expected_wave_counts[lvl]} spawn_actors waves, "
+            f"got {len(spawn_waves)} ({evts})"
+        )
 
 
 def test_no_pre_placed_agent_combat_screen():
     """The pbox LINE must be the sole kill source — there is no
     pre-placed agent combat screen ringing the base. Only ONE
-    non-combatant agent e1 is parked in a far corner (so units_summary
-    is non-empty for the hard-tier env-reset check); it never fights."""
+    non-combatant agent e1 is parked in a far corner (per spawn group)
+    so units_summary is non-empty for the hard-tier env-reset check;
+    it never fights."""
     for lvl in LEVELS:
         c = compile_level(load_pack(PACK), lvl)
         agent_units = [
             a for a in c.scenario.actors
             if a.owner == "agent" and a.type == "e1"
         ]
-        # At most one non-combatant marker per active spawn group.
+        # At most one non-combatant marker per active spawn group
+        # (hard has 2 spawn_point groups so up to 2 corner e1s
+        # declared; only the active spawn group's e1 is materialised).
         assert len(agent_units) <= 2, (lvl, [a.position for a in agent_units])
         for a in agent_units:
             x, y = a.position
-            # Parked in a far corner, well clear of the y=18..22 lane.
+            # Parked in a far corner, well clear of the rush lanes
+            # spread across y=4..36 at x=60.
             assert x <= 6 and (y <= 6 or y >= 34), (lvl, a.position)
 
 
@@ -292,7 +366,7 @@ def test_hard_has_two_spawn_point_groups():
         if a.owner == "agent" and a.spawn_point is not None
     }
     assert groups == {0, 1}, groups
-    # In-bounds check (rush-hour-arena playable y ≈ 2..38, x ≈ 2..126):
+    # In-bounds check (rush-hour-arena playable y ≈ 2..38, x ≈ 2..126).
     for a in c.scenario.actors:
         x, y = a.position
         assert 2 <= x <= 126 and 2 <= y <= 38, (a.type, a.position)
@@ -305,7 +379,7 @@ def test_hard_has_two_spawn_point_groups():
 def test_intended_line_wins_every_level_and_seed(level):
     c = compile_level(load_pack(PACK), level)
     for seed in SEEDS:
-        r = run_level(c, make_line(), seed=seed)
+        r = run_level(c, make_line(level), seed=seed)
         assert r.outcome == "win", (
             f"{level} seed{seed}: intended LINE topology must WIN; "
             f"got {r.outcome} (tick={r.signals.game_tick}, "
@@ -322,19 +396,20 @@ def test_intended_line_wins_every_level_and_seed(level):
 @pytest.mark.parametrize(
     "policy_name,policy_factory",
     [
-        ("stall",         lambda: stall),
-        ("random_4_pbox", lambda: make_random_4_pbox()),
+        ("stall",              lambda lvl: stall),
+        ("cluster_on_centre",  lambda lvl: make_cluster_on_centre(lvl)),
+        ("scatter_near_base",  lambda lvl: make_scatter_near_base(lvl)),
     ],
 )
 def test_lazy_and_wrong_topology_policies_lose_every_level_and_seed(
     level, policy_name, policy_factory
 ):
-    """Stall (rush razes fact AND clock runs out with no pbox) and
-    random-4-pbox (count satisfied but every rung region unsatisfied,
-    so the win never fires and the clock runs out) must ALL LOSE on
-    every level + every seed — no draw."""
+    """Stall (rush razes fact AND clock runs out with no pbox), cluster-
+    on-centre (count satisfied but every flank rung unmet), and scatter-
+    near-base (every rung region unmet, rush reaches fact past unguarded
+    front) must ALL LOSE on every level + every seed — no draw."""
     c = compile_level(load_pack(PACK), level)
-    fn = policy_factory()
+    fn = policy_factory(level)
     for seed in SEEDS:
         r = run_level(c, fn, seed=seed)
         assert r.outcome == "loss", (
@@ -349,8 +424,8 @@ def test_lazy_and_wrong_topology_policies_lose_every_level_and_seed(
 
 def test_intended_run_is_deterministic_on_easy():
     c = compile_level(load_pack(PACK), "easy")
-    a = run_level(c, make_line(), seed=3)
-    b = run_level(c, make_line(), seed=3)
+    a = run_level(c, make_line("easy"), seed=3)
+    b = run_level(c, make_line("easy"), seed=3)
     assert (a.outcome, a.turns, a.signals.units_killed) == (
         b.outcome,
         b.turns,