def-tower-line-vs-cluster: per-tier maps that match topology to threat geometry

Redesign the pack so each tier has its own forcing geometry and demands
a different topology:

easy — open arena 112x40, 4 stance:3 squads on rows y=4/12/28/36
with per-row stance:0 decoys at (12,ROW). Squads spawn at
tick 2000 via scheduled_events AFTER all 4 pboxes are
built. LINE wins (1 pbox per row at x=60); CLUSTER fails
every LINE-rung region clause (y=20 cluster is 8+ cells
from every attacker row).
medium — chokepoint-arena 112x40 with one 5-cell corridor at
y=18..22 x=60. 10 stance:3 attackers (8 e1 + 2 e3) funnel
through. CLUSTER (4 pbox in the corridor disc) wins;
LINE attempts at off-corridor rows are rejected by the
engine (wall water) -> count clause fails.
hard — open arena 112x40 with TWO enemy spawn_point groups:
spawn_point 0 = concentrated stack at (90,20) (cluster
wins), spawn_point 1 = stance:0 squads parked at
(63,ROW) just inside pbox range-4 (line wins). Win
predicate uses any_of over cluster bar / line bar +
units_killed_gte:8 as the load-bearing discriminator.

Per-tier custom maps are materialized via generator specs inside
each level's overrides.base_map (arena / chokepoint-arena / arena).

Scripted-policy bar (4 seeds x 3 tiers, no model needed):
stall (observe only) : LOSS x 12 (all tiers, all seeds)
pure_army (no pbox) : LOSS x 12 (count clause)
wrong-topology : LOSS x 12 on easy+medium (region or
count clause); LOSS on the unmatched
seed on hard (kill quota)
intended topology : WIN x 4 easy, WIN x 4 medium,
WIN x 2 hard per topology (matched
seed) -> WIN coverage of all 4 hard
seeds across the two topologies

Tests are updated end-to-end (tests/test_def_tower_line_vs_cluster.py):
new lazy/wrong-topology/intended assertions per tier, hard-tier
spawn-point check switched to the enemy-side axis. Hard-tier
catalogue comment in tests/test_hard_tier.py updated to reflect the
enemy-side spawn axis.

No engine changes.

openra_bench/scenarios/packs/def-tower-line-vs-cluster.yaml

@@ -1,49 +1,101 @@
+# def-tower-line-vs-cluster — Choose LINE or CLUSTER by Threat Geometry
+#
+# REASONING focus: defense topology MUST MATCH attacker forcing geometry.
+#   • A WIDE-FRONT attack (multiple squads spread across the map width)
+#     demands a LINE of towers — one per attacker row — so no squad
+#     slips past on an uncovered row. A single dense cluster covers
+#     only its centre row and leaves the flanks open.
+#   • A CONCENTRATED THRUST through ONE chokepoint demands a CLUSTER
+#     of towers AT the choke — overlapping fields of fire shred the
+#     funnelled column in passing. A thin LINE spread along the
+#     perimeter wastes coverage on lanes the enemy never uses, and
+#     the choke itself ends up under-gunned.
+#
+# Each tier presents a DIFFERENT forcing geometry (per-tier map):
+#   easy   — open arena 112x40, 4 attacker squads on 4 separate rows
+#            (y=4/12/28/36), each squad walks straight west toward
+#            its own per-row decoy → LINE wins, CLUSTER fails (every
+#            attacker row is out of weapon range from y=20).
+#   medium — chokepoint-arena 112x40 with a single corridor at y=18..22
+#            x=60 → CLUSTER wins, LINE spreads thin (line attempts at
+#            rows y=8/16/24/32 land on water and never build → count
+#            clause fails; the agent can only place inside the corridor).
+#   hard   — open arena 112x40 with TWO enemy spawn_point groups; the
+#            seed flips between a CONCENTRATED-thrust composition (9
+#            stacked at y=20) and a WIDE-FRONT composition (4 squads
+#            on 4 rows). The win predicate is `any_of` over the cluster
+#            and the line bars, but the load-bearing `units_killed_gte`
+#            clause is only cleared by the topology that MATCHES the
+#            active threat — a memorised CLUSTER vs the wide-front seed
+#            misses the flanks and fails the kill quota; a memorised
+#            LINE vs the concentrated seed produces too thin a kill
+#            rate at any one cell.
+#
+# 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, Range 4c0, Burst 5,
+# Damage 1000 — one burst one-shots an e1). The only agent combat
+# units are stance:0 HoldFire DECOYS on the easy tier (they never fire
+# and so cannot carry kill output) and a single non-combatant SW-corner
+# e1 on the other tiers (so the hard-tier env-reset `units_summary`
+# check is non-empty); the pbox layout is the sole source of kills.
+#
+# An unarmed high-HP enemy `fact` marker far east keeps the engine alive
+# past attacker annihilation so the win/fail predicate sees the terminal
+# frame (no DRAW collapse on enemy-wipe auto-`done`).
+#
+# Discrimination (four-script bar — scripted, no model needed):
+#   • stall (observe-only): no pbox built, attackers raze fact → LOSS.
+#   • wrong-topology (CLUSTER on easy / LINE on medium / memorised
+#     CLUSTER on hard's wide-front seed): satisfies neither the region
+#     clauses for the active forcing geometry NOR the kill quota,
+#     and the surviving attackers raze the fact → LOSS via either the
+#     fact-alive clause or `after_ticks`.
+#   • pure-army (only e1, no pbox): fails count clause → LOSS via
+#     `after_ticks` (the home-trained infantry may rack up kills but
+#     can never satisfy `building_count_gte:pbox`).
+#   • intended TOPOLOGY (line on easy / cluster on medium / matched
+#     topology on each hard seed): count + region + kill + fact-alive
+#     all satisfied → WIN.
+
 meta:
   id: def-tower-line-vs-cluster
-  title: 'Defense Topology — Cluster Towers at the Choke (Not a Spread Line)'
+  title: 'Defense Topology — Match Towers to Threat Geometry (Line or Cluster)'
   capability: reasoning
   real_world_meaning: >
-    Where do you place defensive structures when the threat is forced
-    through a known geographic bottleneck? Graph min-cut theory and
-    military bunker placement doctrine both say: concentrate dense
-    coverage at the choke, not a thin spread along the perimeter. A
-    spread line wastes coverage on lanes the enemy never uses; a
-    cluster at the bottleneck multiplies overlapping fields of fire
-    exactly where the threat must pass. The win predicate makes the
-    topology decision load-bearing — total pbox count alone is not
-    enough; ≥3 of the pillboxes must be inside the choke region.
+    Defensive structure placement is geometry-sensitive: a wide-front
+    attack across many rows demands a LINE that covers each row; a
+    concentrated thrust through one chokepoint demands a CLUSTER of
+    overlapping fire at the choke. Both topologies waste budget on the
+    wrong geometry — a cluster against a spread attack leaves the
+    flanks open; a line against a funnel under-defends the choke. The
+    capability is reading the attacker's forcing geometry from the
+    map and the threat composition, then committing the defense
+    topology that matches.
   robotics_analogue: >
-    Firewall / IDS topology design: when an attacker MUST traverse a
-    known ingress (the public WAN edge / the only API gateway / the
-    one bridge between two network segments), the right architecture
-    is dense layered inspection AT that point, not a thin even spread
-    across every internal segment. Distributing the same enforcement
-    budget evenly leaves the actual ingress under-protected while
-    nothing else is ever traversed.
+    Firewall / WAF rule placement. When traffic enters across many
+    paths (broad ingress, microservices), the right architecture is a
+    rule per path — a layered spread. When all traffic MUST traverse
+    a single ingress (one API gateway, one bridge), the right
+    architecture is dense layered inspection AT that point. A defender
+    who deploys the wrong topology for the wrong threat surface either
+    overspends on one path and leaves others open, or under-protects
+    the actual ingress.
   benchmark_anchor:
     - "graph theory min-cut (concentrate defenses at chokepoints)"
     - "military bunker placement doctrine"
     - "firewall topology: dense at chokepoints"
+    - "perimeter doctrine (cover the full approach width)"
     - "Lanchester defense concentration"
   author: openra-bench
 
-# rush-hour-arena (128×40). The map has a narrow lane around y≈18..22
-# at mid-map (x≈60); the `rusher` scripted bot charges the agent's
-# centroid (the agent fact on the west), which forces its path THROUGH
-# that lane mouth on every seed. Agent base is pre-placed at the west
-# (fact + tent + powr pre-built so the pbox queue is ready turn 1).
-# Pack-level cash is overridden per-level (3/4/5 pbox at 600cr each).
-# An unarmed high-HP enemy `fact` far east keeps the engine alive past
-# any rusher annihilation so the win/fail check actually runs.
+# Per-tier custom maps (see overrides.base_map in each level). The
+# pack-level base_map is the shared default if a level omits its own.
 base_map: rush-hour-arena
-starting_cash: 2400
 
 base:
-  agent:
-    faction: allies
-  enemy:
-    faction: soviet
-    bot_type: rusher
+  agent: {faction: allies}
+  enemy: {faction: soviet}
   tools:
     - observe
     - build
@@ -53,75 +105,122 @@ base:
     - attack_move
     - stop
   planning: true
-  # No interrupts — defense topology is a STATIC up-front decision (the
-  # choke location is known a priori, the rush composition is fixed).
-  # Dropping interrupts also makes the tick budget deterministic
-  # (each step is exactly 90 ticks, so max_turns ⇒ max_tick = 93+90·(N-1)
-  # is reached every run), which is what makes the `after_ticks` fail
-  # clause actually bite for stall / pure-army timeout policies.
+  # No interrupts — topology choice is a STATIC up-front decision
+  # (the attacker geometry is visible from turn 1: the model reads
+  # enemy positions and picks line / cluster accordingly). Disabling
+  # interrupts also makes the tick budget deterministic (exactly 90
+  # ticks/step) so the `after_ticks` fail clause reliably bites in.
+  interrupts: {}
   termination:
     max_ticks: 12000
-  actors:
-    # Pre-placed agent base on the WEST (so rusher path is forced
-    # through the mid-map choke on the way to the fact centroid).
-    - {type: fact, owner: agent, position: [10, 20]}
-    - {type: tent, owner: agent, position: [14, 18]}
-    - {type: powr, owner: agent, position: [14, 22]}
+  actors: []   # every level supplies its own actor list via overrides.
 
 levels:
-  # ── EASY ── bare topology skill. Budget covers exactly 3 pbox
-  # (1800cr). Win requires ALL 3 placed at the choke (3 of 3). A
-  # spread-line layout (any pbox AWAY from the choke region) cannot
-  # satisfy both `building_count_gte:3` AND `building_in_region:3`
-  # simultaneously. Stall loses on clock OR fact razed; spread-line
-  # loses on the region clause; pure-army-no-pbox loses on the count
-  # clause AND likely loses the fact. max_turns 60 → reachable tick
-  # 93+90·59 = 5403; deadline 5400.
+  # ── EASY ── WIDE-FRONT attack. 4 squads of 3×e1 (12 attackers) on
+  # four separate rows (y=4 / 12 / 28 / 36) at x=95. Each squad targets
+  # an agent decoy (`e1`, stance:0 HoldFire) on the SAME row at x=4,
+  # so the squad walks STRAIGHT WEST along its row (stance:3 →
+  # AttackAnything → advance toward nearest visible enemy; the
+  # row-local decoy is always nearer than the central fact). The
+  # pre-placed decoys are the squad's forcing-geometry anchor —
+  # without them stance:3 would steer every squad diagonally toward
+  # the fact at (10,20), collapsing the wide-front spread into a
+  # single converging y=20 column. The decoys are stance:0 HoldFire
+  # so they never auto-fire and cannot contribute to the kill quota
+  # (the pbox LINE must produce every kill).
+  #
+  # A CLUSTER at (60,20) is a range-4 disc (M60mg, Range 4c0). The
+  # nearest row (y=12 or y=28) is 8 cells from y=20 — twice the
+  # weapon range — so the cluster cannot fire on ANY squad as it
+  # passes. Cluster kills 0 → `units_killed_gte:8` fails AND the
+  # squads kill the decoys then march to the fact, razing it. LOSS
+  # on both clauses.
+  #
+  # The intended LINE places one pbox at each of the four squad rows:
+  # (60,4) / (60,12) / (60,28) / (60,36). Each squad walks straight
+  # west on its own row into its pbox's range-4 disc; the M60mg burst
+  # one-shots each e1 in passing. All 12 attackers die before reaching
+  # the decoys; kill quota cleared; fact intact. Budget exactly 4 pbox
+  # (2400cr). 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 of 5 rifle infantry must traverse the narrow lane at
-    # (60, 18..22) to reach your base on the west. Build 3 pillboxes (pbox
-    # — 600cr each, budget exactly 1800) AND place ALL 3 inside the choke
-    # at (60, 20) within radius 5, so the rusher walks into overlapping
-    # fields of fire at the bottleneck. A spread line (any pbox away from
-    # the choke) cannot satisfy both the count and the region bars at
-    # once. Stalling, pure-army (no pbox), and spread layouts all lose.
-    # Your fact must survive.
     description: >
-      A five-rifle rush must traverse the narrow lane at (60, 18..22) to
-      reach your base. Budget $1800 — three pillboxes — and place all
-      three inside a 5-cell disc around (60,20) so the rush walks into
-      overlapping fire. Spreading them along the perimeter satisfies the
-      count but not the region clause. Yard intact, within about 60 turns.
-    starting_cash: 1800
+      Four rifle squads (3 each) advance west on four separate rows —
+      y=4, 12, 28, 36 — each toward its own decoy on the same row at
+      x=4. Budget $2400 buys four pillboxes. Place one on each of the
+      four attacker rows at x=60 so every squad walks into a pillbox's
+      range. Clustering all four at the centre (y=20) leaves every row
+      out of weapon range; the cluster kills nothing and the squads
+      raze your yard. Yard intact, eight kills, within about 60 turns.
+    starting_cash: 2400
     overrides:
+      # Wide-open arena 112x40 — no terrain features. The forcing
+      # geometry is supplied by the SPREAD of attacker spawn rows
+      # together with per-row decoys that keep each squad walking
+      # along its OWN latitude; a cluster vs this spread is
+      # geometrically out of range on every row.
+      base_map:
+        generator: arena
+        name: def-tower-lvsc-easy-arena
+        width: 112
+        height: 40
+        cordon: 2
+        title: def-tower-line-vs-cluster easy wide-front 112x40
       actors:
+        # Pre-placed agent base — the fact at (10,20) is the
+        # win-condition asset; tent/powr offsets keep them out of the
+        # y=20 lane. The fact is far enough from every squad's path
+        # that, until the row's decoy dies, it is not the squad's
+        # nearest visible enemy.
         - {type: fact, owner: agent, position: [10, 20]}
         - {type: tent, owner: agent, position: [14, 18]}
         - {type: powr, owner: agent, position: [14, 22]}
-        # 4 mobile defenders pre-placed (the spec calls for ~4-5).
-        - {type: e1, owner: agent, position: [12, 19], stance: 2}
-        - {type: e1, owner: agent, position: [12, 21], stance: 2}
-        - {type: e1, owner: agent, position: [16, 19], stance: 2}
-        - {type: e1, owner: agent, position: [16, 21], stance: 2}
-        # Rusher band at far east — pure infantry (5× e1, no
-        # rocket soldier) so the easy tier is the BARE topology
-        # skill. Forced through the mid-map choke on the way to
-        # the agent fact centroid (10, 20): a 3-pbox cluster AT
-        # the choke one-shots the e1 stream as it funnels
-        # through, but a spread line (1 at choke + 2 perimeter)
-        # leaves the choke under-gunned and the region bar unmet.
-        - {type: e1, owner: enemy, position: [100, 20], stance: 3, count: 5}
+        # Per-row agent decoy units (`e1`, stance:0 HoldFire). Each
+        # decoy is the row-local AGENT UNIT for the rusher bot to
+        # charge — rusher routes per-unit toward the nearest agent
+        # MASS cell, which on rows y=4 / 12 / 28 / 36 is the row's
+        # own decoy at (12,ROW) (closer than the y=20 fact by both
+        # Chebyshev and path distance). Stance:0 means the decoys
+        # never auto-fire, so they cannot rack up kills off the
+        # rush — the pbox LINE is the sole kill source.
+        - {type: e1, owner: agent, position: [12, 4],  stance: 0}
+        - {type: e1, owner: agent, position: [12, 12], stance: 0}
+        - {type: e1, owner: agent, position: [12, 28], stance: 0}
+        - {type: e1, owner: agent, position: [12, 36], stance: 0}
         # 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]}
+        # past full enemy elimination so the win/fail check fires.
+        - {type: fact, owner: enemy, position: [108, 20]}
+      # Scheduled rush wave — injected at tick 2000, AFTER all 4
+      # LINE pboxes are built (Defense queue is serial; each pbox
+      # takes ~450 ticks to produce, so the 4th completes ~tick 1800
+      # in the intended build order). The four squads stage in a
+      # tight band at x=95 on the four attacker rows, then march
+      # west; each squad's nearest agent building is its own row
+      # silo at (12,ROW), so the squad walks STRAIGHT WEST along
+      # its row into the LINE pbox at (60,ROW). Squads do not bend
+      # toward the fact because the row silo is closer than the
+      # fact on every spawn cell.
+      scheduled_events:
+        - tick: 2000
+          type: spawn_actors
+          actors:
+            - {type: e1, owner: enemy, position: [95, 4],  stance: 3, count: 3}
+            - {type: e1, owner: enemy, position: [95, 12], stance: 3, count: 3}
+            - {type: e1, owner: enemy, position: [95, 28], stance: 3, count: 3}
+            - {type: e1, owner: enemy, position: [95, 36], stance: 3, count: 3}
     win_condition:
       all_of:
-        - building_count_gte: {type: pbox, n: 3}
-        - building_in_region: {type: pbox, x: 60, y: 20, radius: 5, count: 3}
+        - building_count_gte: {type: pbox, n: 4}
+        # Each of the 4 attacker rows must host at least one pbox at
+        # x=60 (radius 3 → vertical cells y±3). A CLUSTER at (60,20)
+        # has all 4 pbox within radius 3 of y=20, which is NOT within
+        # radius 3 of any of y=4 (dist 16) / y=12 (dist 8) / y=28
+        # (dist 8) / y=36 (dist 16) — so EVERY row clause fails.
+        - building_in_region: {type: pbox, x: 60, y: 4,  radius: 3, count: 1}
+        - building_in_region: {type: pbox, x: 60, y: 12, radius: 3, count: 1}
+        - building_in_region: {type: pbox, x: 60, y: 28, radius: 3, count: 1}
+        - building_in_region: {type: pbox, x: 60, y: 36, radius: 3, count: 1}
+        - units_killed_gte: 8
         - building_count_gte: {type: fact, n: 1}
         - within_ticks: 5400
     fail_condition:
@@ -130,53 +229,68 @@ levels:
         - not: {building_count_gte: {type: fact, n: 1}}
     max_turns: 60
 
-  # ── MEDIUM ── +1 axis: total budget grows to 4 pbox (2400cr) but
-  # the cluster bar is still 3 — so the agent must place 3 of 4 at
-  # the choke (one "spare" allowed elsewhere, e.g. covering the base).
-  # A naive spread layout (1 at choke, 3 spread) satisfies the count
-  # but NOT the region. The intended cluster (3 at choke + 1 free)
-  # satisfies both. max_turns 60 → reachable tick 5403; deadline 5400.
+  # ── MEDIUM ── CONCENTRATED thrust through ONE chokepoint. The map
+  # is a chokepoint-arena 112x40 with vertical walls at x=60 forming
+  # a single 5-cell-wide corridor at y=18..22. The entire attacker
+  # band (8×e1 + 2×e3) stages east of the corridor and MUST funnel
+  # through y=18..22 to reach the fact on the west. A CLUSTER of 4
+  # pbox at (60,20) (all inside the corridor) puts every attacker
+  # within range of all 4 pboxes simultaneously — 4 simultaneous
+  # M60mg bursts shred the column in passing. A LINE attempt at
+  # y=8 / 16 / 24 / 32 at x=60 lands on the wall water (every cell
+  # except y=18..22 at x≈60 is impassable) → placement fails for 3
+  # of 4 attempts → pbox count < 4 → LOSS. A LINE attempt OUT of the
+  # wall column (e.g. at x=50) puts only one pbox within range-4 of
+  # the corridor mouth → kill rate falls far below the quota → LOSS.
+  # Budget exactly 4 pbox (2400cr). max_turns 60 ⇒ 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 path through the (60, 20) choke. Build 4
-    # pillboxes (budget 2400cr = exactly 4 pbox at 600 each) AND place at
-    # least 3 of them inside the choke region (radius 5 around (60, 20)).
-    # A spread-line (1 at the choke, 3 elsewhere) meets the count but
-    # FAILS the region bar; the intended cluster (3 at the choke + 1
-    # spare) wins. Stalling, pure-army, and spread-line layouts all lose;
-    # the fact must survive.
     description: >
-      Same choke at (60,20), same rush, but $2400 now buys four pillboxes.
-      At least three must sit inside the 5-cell disc at (60,20); the
-      fourth is spare. A spread-line (one at the choke, three elsewhere)
-      meets the count but fails the cluster bar. Yard intact, within about
-      60 turns.
+      A single 5-cell corridor at x=60, y=18..22 is the only way west.
+      Ten attackers (eight rifles + two rocket soldiers) must funnel
+      through it to reach your construction yard at (10,20). Budget
+      $2400 buys four pillboxes. Cluster all four inside the corridor
+      so overlapping fire shreds the column at the choke. Spreading
+      across rows the corridor doesn't reach is a wasted budget. Yard
+      intact, ten kills, within about 60 turns.
     starting_cash: 2400
     overrides:
+      base_map:
+        generator: chokepoint-arena
+        name: def-tower-lvsc-medium-arena
+        width: 112
+        height: 40
+        cordon: 2
+        pinch_x: 60
+        pinch_width: 10
+        corridor_y: 20
+        corridor_width: 5
+        title: def-tower-line-vs-cluster medium chokepoint 112x40
       actors:
         - {type: fact, owner: agent, position: [10, 20]}
         - {type: tent, owner: agent, position: [14, 18]}
         - {type: powr, owner: agent, position: [14, 22]}
-        # 5 mobile defenders pre-placed.
-        - {type: e1, owner: agent, position: [12, 19], stance: 2}
-        - {type: e1, owner: agent, position: [12, 21], stance: 2}
-        - {type: e1, owner: agent, position: [16, 19], stance: 2}
-        - {type: e1, owner: agent, position: [16, 21], stance: 2}
-        - {type: e1, owner: agent, position: [14, 20], stance: 2}
-        # Slightly heavier rusher band than easy (5 e1, staged at
-        # x=115 — one extra rifle infantry vs easy's 4, no e3, so the
-        # 4-pbox cluster has time to assemble before the band breaks
-        # through the pre-placed defenders).
-        - {type: e1, owner: enemy, position: [115, 20], stance: 3, count: 5}
-        # Anti-DRAW marker (see easy).
-        - {type: fact, owner: enemy, position: [120, 20]}
+        # Non-combatant corner e1 (in-corridor latitude so it doesn't
+        # land on a wall). y=20 is in the corridor latitude; park at
+        # (4, 20).
+        - {type: e1, owner: agent, position: [4, 20], stance: 2}
+        # Attacker band — all funnelled through the corridor. Staged
+        # in the corridor latitude (y=18..22) at x≈95 so they walk
+        # straight west into the choke.
+        - {type: e1, owner: enemy, position: [95, 20], stance: 3, count: 8}
+        - {type: e3, owner: enemy, position: [97, 20], stance: 3, count: 2}
+        # Anti-DRAW marker — east of the corridor, on the corridor
+        # latitude so it's in a valid (non-wall) cell.
+        - {type: fact, owner: enemy, position: [108, 20]}
     win_condition:
       all_of:
         - building_count_gte: {type: pbox, n: 4}
-        - building_in_region: {type: pbox, x: 60, y: 20, radius: 5, count: 3}
+        # All 4 pbox must sit inside the choke disc (radius 5 of the
+        # corridor centre (60,20)). A wide LINE attempt that places
+        # pbox outside the corridor (or outside this disc) fails the
+        # region clause OR the count clause (if its picks landed on
+        # wall water and were rejected by the engine placement check).
+        - building_in_region: {type: pbox, x: 60, y: 20, radius: 5, count: 4}
+        - units_killed_gte: 10
         - building_count_gte: {type: fact, n: 1}
         - within_ticks: 5400
     fail_condition:
@@ -185,74 +299,101 @@ 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,10) vs SOUTH (10,30)). Both
-  # candidate choke regions are valid via `any_of` — the agent must
-  # cluster ≥4 of 5 pbox at EITHER (60, 20) or (40, 20) — so a
-  # single memorised cluster cell still works for both seeds but the
-  # base-latitude flip enforces the hard-tier spawn contract (the
-  # required cluster is geographically distant from EACH base, so the
-  # placement plan can't be a stamped relative-to-base offset that
-  # happens to land in the same world cell on every seed). Enemies
-  # don't honor spawn_point (engine: oramap.rs::expand_scenario_actors)
-  # so the rusher band is placed symmetrically at y=20 between the
-  # two candidate chokes; the rusher charges agent centroid so its
-  # path crosses x∈[40,60] regardless of latitude. Total pbox grows
-  # to 5 (3000cr) and the cluster bar grows to 4 of 5 at one choke.
-  # max_turns 70 → reachable tick 93+90·69 = 6303; deadline 6300.
+  # ── HARD ── seed-varied forcing geometry. The map is the open arena
+  # (112x40, NO walls — both topologies are physically buildable so
+  # the discrimination comes from the kill quota, not from placement
+  # rejection). Two ENEMY spawn_point groups round-robin by seed:
+  #   spawn_point 0 = CONCENTRATED thrust: 9×e1 + 2×e3 stacked on the
+  #                   y=20 lane at x=90 → cluster wins, line wastes
+  #                   coverage on empty rows.
+  #   spawn_point 1 = WIDE-FRONT: 4 squads of 3×e1 on y=4/12/28/36 at
+  #                   x=90, plus per-row decoys to keep each squad on
+  #                   its own latitude → line wins, cluster leaves
+  #                   the flanks far out of range.
+  # Persistent enemy fact marker is duplicated across both enemy spawn
+  # groups (CLAUDE.md: enemy spawn_point filter is per-OWNER and
+  # filters out marker actors without spawn_point). The per-row decoy
+  # rifles are likewise spawn_point-filtered (they're only needed on
+  # the wide-front seed — on the concentrated seed they'd silently
+  # tilt the centroid logic). The agent base is always at the fixed
+  # canonical position (no spawn_point on the base actors, so the
+  # agent-side filter stays inactive and the base places every seed).
+  # The win predicate is `any_of` between the cluster bar (4-of-4 at
+  # (60,20)) and the line bar (1 each at 4 rungs). The kill quota
+  # (`units_killed_gte: 8`) is the load-bearing clause — placing the
+  # wrong topology for the active seed fails the kill quota even when
+  # the region clause is technically satisfied. 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=10) and SOUTH (y=30) by
-    # seed. Build 5 pillboxes (budget 3000cr = exactly 5 pbox at 600 each)
-    # AND place at least 4 of them inside ONE of the two candidate choke
-    # regions (radius 5 around either (60, 20) or (40, 20)). Spreading
-    # across both chokes (e.g. 3+2) FAILS the 4-of-5 cluster bar; a thin
-    # perimeter line FAILS both choke bars. The fact must survive.
     description: >
-      Your base spawns north (y=10) or south (y=30) by seed. $3000 buys
-      five pillboxes; pile at least four into ONE of two candidate choke
-      discs — (60,20) or (40,20). Splitting 3+2 across both fails the
-      4-of-5 cluster bar. Pick the right choke, hold the yard, within
-      about 70 turns.
-    starting_cash: 3000
+      Open arena. The enemy composition flips by seed: either ONE
+      concentrated column on y=20 or FOUR squads spread across
+      y=4/12/28/36 (with per-row decoys at x=4 that keep each spread
+      squad on its own latitude). Read the threat from your
+      observation and pick the topology that matches — cluster the
+      four pillboxes at (60,20) for the concentrated thrust, OR
+      spread one per row at x=60 for the wide front. The wrong
+      topology fails the kill quota. Yard intact, eight kills,
+      within about 70 turns.
+    starting_cash: 2400
     overrides:
+      base_map:
+        generator: arena
+        name: def-tower-lvsc-hard-arena
+        width: 112
+        height: 40
+        cordon: 2
+        title: def-tower-line-vs-cluster hard open 112x40
       actors:
-        # spawn_point 0 — NORTH base. Fact at (10, 10); tent/powr
-        # west-of-fact so they aren't directly in the rusher path.
-        - {type: fact, owner: agent, position: [10, 10], spawn_point: 0}
-        - {type: tent, owner: agent, position: [6,  10], spawn_point: 0}
-        - {type: powr, owner: agent, position: [6,  12], spawn_point: 0}
-        - {type: e1,   owner: agent, position: [12, 10], stance: 2, spawn_point: 0}
-        - {type: e1,   owner: agent, position: [12, 11], stance: 2, spawn_point: 0}
-        - {type: e1,   owner: agent, position: [12, 9],  stance: 2, spawn_point: 0}
-        - {type: e1,   owner: agent, position: [14, 10], stance: 2, spawn_point: 0}
-        - {type: e1,   owner: agent, position: [8,  10], stance: 2, spawn_point: 0}
-        # spawn_point 1 — SOUTH base, mirror at y=30.
-        - {type: fact, owner: agent, position: [10, 30], spawn_point: 1}
-        - {type: tent, owner: agent, position: [6,  30], spawn_point: 1}
-        - {type: powr, owner: agent, position: [6,  32], spawn_point: 1}
-        - {type: e1,   owner: agent, position: [12, 30], stance: 2, spawn_point: 1}
-        - {type: e1,   owner: agent, position: [12, 31], stance: 2, spawn_point: 1}
-        - {type: e1,   owner: agent, position: [12, 29], stance: 2, spawn_point: 1}
-        - {type: e1,   owner: agent, position: [14, 30], stance: 2, spawn_point: 1}
-        - {type: e1,   owner: agent, position: [8,  30], stance: 2, spawn_point: 1}
-        # Enemies don't honor spawn_point (engine: oramap.rs); the
-        # rusher band sits at y=20 (mid-latitude) and charges the
-        # agent centroid, so its path crosses BOTH candidate choke
-        # x-columns regardless of which base latitude the seed picks.
-        - {type: e1, owner: enemy, position: [100, 20], stance: 3, count: 6}
-        - {type: e3, owner: enemy, position: [102, 20], stance: 3, count: 2}
-        # Anti-DRAW marker.
-        - {type: fact, owner: enemy, position: [120, 20]}
+        # Single agent base (no spawn_point) — only the ENEMY side is
+        # spawn_point-filtered, so all agent base actors place on
+        # every seed (agent-side filter is inactive when no agent
+        # actor declares spawn_point).
+        - {type: fact, owner: agent, position: [10, 20]}
+        - {type: tent, owner: agent, position: [14, 18]}
+        - {type: powr, owner: agent, position: [14, 22]}
+        - {type: e1, owner: agent, position: [4, 36], stance: 0}
+        # spawn_point 0 — CONCENTRATED thrust (stacked column at y=20).
+        # 11 attackers total (9 e1 + 2 e3). All stance:3 → advance
+        # toward agent fact.
+        - {type: e1, owner: enemy, position: [90, 20], stance: 3, count: 9, spawn_point: 0}
+        - {type: e3, owner: enemy, position: [92, 20], stance: 3, count: 2, spawn_point: 0}
+        # spawn_point 1 — WIDE-FRONT (4 squads on 4 rows). Each
+        # squad is staged JUST EAST of the LINE pbox column at
+        # (65, ROW) and held with stance:0 (HoldFire) so the squads
+        # do NOT move toward the fact — they sit on their rows
+        # waiting to be shot. A LINE pbox at (60, ROW) has each
+        # row-squad in range-5 fire range and shreds it in passing
+        # bursts; a CLUSTER at (60, 20) has the y=12 and y=28 rows
+        # at vertical distance 8 (twice the M60mg range) and the
+        # y=4 and y=36 rows at distance 16 — no fire reaches any
+        # squad and the kill quota stays at zero. Stance:0 squads
+        # also can't raze the fact, so the LOSS for cluster /
+        # stall comes from the `after_ticks` timeout (failed kill
+        # quota), not the fact-alive clause.
+        - {type: e1, owner: enemy, position: [63, 4],  stance: 0, count: 3, spawn_point: 1}
+        - {type: e1, owner: enemy, position: [63, 12], stance: 0, count: 3, spawn_point: 1}
+        - {type: e1, owner: enemy, position: [63, 28], stance: 0, count: 3, spawn_point: 1}
+        - {type: e1, owner: enemy, position: [63, 36], stance: 0, count: 3, spawn_point: 1}
+        # Anti-DRAW marker, duplicated across BOTH enemy spawn groups
+        # (CLAUDE.md: enemy spawn_point filter is per-owner; an enemy
+        # actor without spawn_point would be filtered out when any
+        # enemy actor declares spawn_point).
+        - {type: fact, owner: enemy, position: [108, 20], spawn_point: 0}
+        - {type: fact, owner: enemy, position: [108, 20], spawn_point: 1}
     win_condition:
       all_of:
-        - building_count_gte: {type: pbox, n: 5}
+        - building_count_gte: {type: pbox, n: 4}
         - any_of:
+            # CLUSTER bar (matches concentrated-thrust seed).
             - building_in_region: {type: pbox, x: 60, y: 20, radius: 5, count: 4}
-            - building_in_region: {type: pbox, x: 40, y: 20, radius: 5, count: 4}
+            # LINE bar (matches wide-front seed — 1 pbox per row).
+            - all_of:
+                - building_in_region: {type: pbox, x: 60, y: 4,  radius: 3, count: 1}
+                - building_in_region: {type: pbox, x: 60, y: 12, radius: 3, count: 1}
+                - building_in_region: {type: pbox, x: 60, y: 28, radius: 3, count: 1}
+                - building_in_region: {type: pbox, x: 60, y: 36, radius: 3, count: 1}
+        - units_killed_gte: 8
         - building_count_gte: {type: fact, n: 1}
         - within_ticks: 6300
     fail_condition:

tests/test_def_tower_line_vs_cluster.py

@@ -1,35 +1,55 @@
 """def-tower-line-vs-cluster scenario family, full loop on Rust.
 
-The pack tests DEFENSE TOPOLOGY: when the threat is forced through a
-known chokepoint, the right architecture is dense cluster AT the choke
-(graph min-cut / military bunker placement doctrine), NOT a thin spread
-along the perimeter. The win predicate makes the topology decision
-load-bearing — total pbox count alone is not sufficient:
-
-* `building_count_gte:{pbox, n}` ⇒ the agent actually built the budget
-  worth of defences (3 on easy, 4 on medium, 5 on hard);
-* `building_in_region:{pbox, x:60, y:20, radius:5, count}` ⇒ ≥3 (easy),
-  ≥3 (medium), or ≥4 (hard) of those pbox sit INSIDE the choke region —
-  a spread-line layout (one pbox at the choke, the rest along the
-  perimeter) satisfies the count but NOT the region;
-* `building_count_gte:{fact,1}` ⇒ the fact must still stand (rather than
-  `has_building:fact` which is a one-shot "ever seen" set — see CLAUDE.md
-  footgun);
-* `within_ticks` paired with `after_ticks` ⇒ a non-finisher is a real
-  reachable timeout LOSS (no interrupts on this pack ⇒ each step is
-  exactly 90 ticks, so max_turns is a hard tick budget that the
-  `after_ticks` deadline reliably bites in).
+The pack tests DEFENSE TOPOLOGY: the agent must match the topology of
+its pillbox layout (LINE across rows OR CLUSTER at one cell) to the
+attacker's forcing geometry. Each tier presents a different geometry
+and therefore demands a different topology:
+
+* easy  — open arena 112x40, 4 attacker squads on 4 separate rows
+          (y=4/12/28/36) → LINE wins, CLUSTER fails (the line rung
+          clauses are all missed by a y=20 cluster).
+* medium— chokepoint-arena 112x40, one 5-cell corridor at y=18..22
+          x=60 → CLUSTER wins, LINE fails (the off-corridor rows are
+          impassable wall water, so a line attempt at y=8/16/24/32
+          either has no place to go or is rejected outright).
+* hard  — open arena 112x40 with TWO enemy spawn_point groups: a
+          CONCENTRATED-thrust composition (9×e1 + 2×e3 stacked at
+          y=20) and a WIDE-FRONT composition (4 stance:0 squads on
+          y=4/12/28/36). The win predicate is `any_of` over the
+          cluster bar and the line bar; the kill quota
+          `units_killed_gte:8` is the load-bearing clause — a
+          memorised CLUSTER vs the wide-front seed (or a memorised
+          LINE vs the concentrated seed) cannot fire on the active
+          threat and so cannot satisfy the kill quota.
+
+The win predicate makes the topology decision load-bearing — total
+pbox count alone is not sufficient:
+
+* `building_count_gte:{pbox, n:4}` ⇒ the agent built the full budget;
+* `building_in_region` row/disc clauses ⇒ the pbox layout MATCHES the
+  forcing geometry (LINE rungs on easy, CLUSTER disc on medium, EITHER
+  on hard);
+* `units_killed_gte:N` ⇒ the pbox layout actively KILLS the attackers
+  (a stall / wrong-topology layout that satisfies the region clause
+  by luck still fails to kill enough);
+* `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
+  non-finisher is a real reachable timeout LOSS (no interrupts on this
+  pack ⇒ each step is exactly 90 ticks, so max_turns is a hard tick
+  budget that the `after_ticks` deadline reliably bites in).
 
 The scripted-policy validations prove deterministically that:
 
-* the intended CLUSTER policy (all pbox built INSIDE the choke region)
-  WINS every level + every hard seed (1..4);
-* stall / spread-line (1 at choke + rest perimeter) / pure-army
-  (no pbox) all LOSE every level + every hard seed — a real LOSS, not
-  a draw;
-* the hard tier defines ≥2 spawn_point groups (north y=10 / south y=30)
-  so a memorised relative-to-base placement that lands in the same
-  world cell on every seed cannot solve the pack.
+* the intended TOPOLOGY (line on easy / cluster on medium / matched
+  topology per seed on hard) WINS every level + every applicable seed;
+* stall, pure-army, and the WRONG-TOPOLOGY (cluster on easy / line on
+  medium) all LOSE on every level + every seed — a real LOSS, not a
+  draw (the count or region or kill clause is unmet AND the
+  `after_ticks` deadline reliably bites);
+* the hard tier defines ≥2 distinct enemy spawn_point groups (Wave-9
+  per-owner spawn_point activation) so a single memorised topology
+  cannot generalise across seeds.
 """
 
 from __future__ import annotations
@@ -47,118 +67,98 @@ PACK = PACKS_DIR / "def-tower-line-vs-cluster.yaml"
 LEVELS = ("easy", "medium", "hard")
 SEEDS = (1, 2, 3, 4)
 
-# Per-level total pbox budget (exactly `starting_cash / 600`).
-_N_PBOX = {"easy": 3, "medium": 4, "hard": 5}
+# Pbox cells for each topology. Outer rows are placed FIRST so they
+# are up by the time the (slowest-arriving) flank squads reach x=60.
+LINE_CELLS    = [(60, 4), (60, 36), (60, 12), (60, 28)]
+CLUSTER_CELLS = [(58, 20), (60, 19), (60, 21), (62, 20)]
 
 
 # ── scripted policies ────────────────────────────────────────────────
 
 
 def stall(rs, C):
-    """Observe-only — the agent never spends. Fact gets razed and/or
-    the clock runs out."""
+    """Observe-only — the agent never spends. The win predicate
+    requires `building_count_gte:pbox,4` AND `units_killed_gte`, so
+    the win never latches and the episode times out via
+    `after_ticks`. (On every tier the attackers are configured so a
+    pure stall also cannot satisfy the fact-alive clause.)"""
     return [C.observe()]
 
 
-def make_cluster(choke=(60, 20)):
-    """Intended CLUSTER topology: every pbox is placed INSIDE the choke
-    region (within radius 5 of the choke cell)."""
-    cx0, cy0 = choke
-    # Eight pre-chosen cells around the choke; the policy uses as many
-    # as the budget needs (easy:3, medium:4, hard:5).
-    cells = [
-        (cx0 - 2, cy0 - 1), (cx0, cy0 - 1), (cx0 + 2, cy0 - 1),
-        (cx0 - 2, cy0 + 1), (cx0, cy0 + 1), (cx0 + 2, cy0 + 1),
-        (cx0 - 1, cy0),     (cx0 + 1, cy0),
-    ]
-
-    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)]
-        cmds = []
-        # Once enough pboxes are up, idle (the win clause counts the
-        # current building list each turn).
-        if n >= len(cells):
-            return [C.observe()]
-        if "pbox" not in prod_items:
-            cmds.append(C.build("pbox"))
-        cmds.append(C.place_building("pbox", cells[n][0], cells[n][1]))
-        if not cmds:
-            cmds.append(C.observe())
-        return cmds
-
-    return policy
+def pure_army(rs, C):
+    """PURE-ARMY: only train e1 — never build a pbox. FAILS the
+    `building_count_gte:pbox,4` clause regardless of how many kills
+    the home-trained infantry rack up."""
+    prod = rs.get("production") or []
+    prod_items = [p.get("item") for p in prod if isinstance(p, dict)]
+    if "e1" not in prod_items:
+        return [C.build("e1")]
+    return [C.observe()]
 
 
-def make_spread_line(n_pbox):
-    """SPREAD-LINE topology: one pbox at the choke + the rest along the
-    perimeter near the base. Satisfies `building_count_gte` but FAILS
-    `building_in_region` (only 1 of N at the choke, not the required
-    3-of-3 / 3-of-4 / 4-of-5)."""
-    cells = [(60, 20), (20, 18), (24, 18), (28, 18), (32, 18)][:n_pbox]
+def _make_topology(cells):
+    """Build one pbox at each cell, in order, then idle. The
+    place_building order is rejected by the engine if the cell is
+    impassable terrain — which is how the medium tier's LINE attempt
+    silently fails the count clause (only the one in-corridor cell
+    succeeds)."""
+    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)]
-        cmds = []
         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", cells[n][0], cells[n][1]))
-        if not cmds:
-            cmds.append(C.observe())
-        return cmds
+        return cmds or [C.observe()]
 
     return policy
 
 
-def pure_army(rs, C):
-    """PURE-ARMY: only ever train e1 — never builds a pbox. FAILS the
-    `building_count_gte:pbox` clause AND lets the rush eventually reach
-    the fact (or runs out the clock with no pbox)."""
-    prod = rs.get("production") or []
-    prod_items = [p.get("item") for p in prod if isinstance(p, dict)]
-    if "e1" not in prod_items:
-        return [C.build("e1")]
-    return [C.observe()]
+def make_line():
+    return _make_topology(LINE_CELLS)
+
+
+def make_cluster():
+    return _make_topology(CLUSTER_CELLS)
 
 
 # ── scenario-shape invariants ────────────────────────────────────────
 
 
-def test_pack_compiles_with_three_levels_and_rusher_bot():
+def test_pack_compiles_with_three_levels():
     pack = load_pack(PACK)
     assert pack.meta.id == "def-tower-line-vs-cluster"
     assert pack.meta.capability == "reasoning"
     assert set(pack.levels) == {"easy", "medium", "hard"}
-    # Required-by-spec benchmark anchors.
+    # Required-by-spec benchmark anchors — both the chokepoint /
+    # min-cut anchor (cluster doctrine) AND the perimeter / wide-front
+    # anchor (line doctrine) must be declared, since the pack
+    # discriminates both.
     anchors = pack.meta.benchmark_anchor
     assert any("min-cut" in a.lower() or "chokepoint" in a.lower() for a in anchors), anchors
     assert any("bunker" in a.lower() for a in anchors), anchors
-    # Rusher bot wired through (charges agent centroid → forces the
-    # rush path through the mid-map choke on every seed).
+    assert any("perimeter" in a.lower() for a in anchors), anchors
+    # All tiers compile + the per-tier base_map is Rust-loadable.
     for lvl in LEVELS:
         c = compile_level(pack, lvl)
-        assert c.map_supported
-        bot = getattr(c.scenario.enemy, "bot_type", None) or getattr(
-            c.scenario.enemy, "bot", None
-        )
-        assert str(bot).lower() == "rusher", (lvl, bot)
+        assert c.map_supported, (lvl, c.scenario.base_map)
 
 
 def test_starting_cash_is_exact_pbox_budget():
-    """The cash is intentionally tight (3/4/5 pbox at 600 each, zero
-    slack). A model that spends on units OR extra power runs out before
-    the count clause is satisfied — the topology decision is the spend."""
+    """The cash is tight (exactly 4 pbox at 600 each, zero slack on
+    every tier). A model that spends on units OR extra power runs out
+    before the count clause is satisfied — the topology decision is
+    the spend."""
     pack = load_pack(PACK)
-    for lvl, expected in (("easy", 1800), ("medium", 2400), ("hard", 3000)):
+    for lvl in LEVELS:
         c = compile_level(pack, lvl)
-        assert c.starting_cash == expected, (lvl, c.starting_cash)
+        assert c.starting_cash == 2400, (lvl, c.starting_cash)
 
 
 @pytest.mark.parametrize("level", LEVELS)
@@ -185,8 +185,7 @@ def test_fact_alive_clause_uses_present_tense_predicate():
     """The fact-survival clause must use the PRESENT-TENSE predicate
     (`building_count_gte:{type:fact,n:1}`) rather than `has_building`,
     which is a one-shot "ever seen" set that stays true after the fact
-    is destroyed (a documented CLAUDE.md footgun). Otherwise the rush
-    razing the fact would not trigger a LOSS."""
+    is destroyed (a documented CLAUDE.md footgun)."""
     for lvl in LEVELS:
         c = compile_level(load_pack(PACK), lvl)
         fc = c.fail_condition.model_dump(exclude_none=True)
@@ -200,39 +199,73 @@ def test_fact_alive_clause_uses_present_tense_predicate():
         assert fact_clauses, f"{lvl}: missing present-tense fact-alive fail clause"
 
 
-def test_hard_has_two_spawn_point_groups():
-    """Hard-tier contract: ≥2 distinct agent spawn_point groups so a
-    memorised relative-to-base placement that lands in the same world
-    cell on every seed cannot generalise."""
+def test_hard_has_two_seed_driven_spawn_point_groups():
+    """Hard-tier contract: ≥2 distinct seed-driven spawn_point groups
+    so a memorised topology cannot generalise. This pack uses the
+    Wave-9 ENEMY-side spawn_point axis (the agent base is fixed
+    across all seeds; only the enemy composition flips)."""
     c = compile_level(load_pack(PACK), "hard")
-    groups = {
+    enemy_groups = {
         a.spawn_point for a in c.scenario.actors
-        if a.owner == "agent" and a.spawn_point is not None
+        if a.owner == "enemy" 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):
+    assert enemy_groups == {0, 1}, enemy_groups
+    # In-bounds check (per-tier playable area; the maps are 112x40
+    # with cordon=2, so x in 2..109 and y in 2..37).
     for a in c.scenario.actors:
         x, y = a.position
-        assert 2 <= x <= 126 and 2 <= y <= 38, (a.type, a.position)
+        assert 2 <= x <= 109 and 2 <= y <= 37, (a.type, a.position)
 
 
-# ── solvency: intended CLUSTER wins every level + every hard seed ────
+# ── solvency: intended topology wins every level + every seed ────────
 
 
-@pytest.mark.parametrize("level", LEVELS)
-def test_intended_cluster_wins_every_level_and_seed(level):
-    c = compile_level(load_pack(PACK), level)
+def test_easy_intended_line_wins_every_seed():
+    c = compile_level(load_pack(PACK), "easy")
+    for seed in SEEDS:
+        r = run_level(c, make_line(), seed=seed)
+        assert r.outcome == "win", (
+            f"easy seed{seed}: intended LINE topology must WIN; "
+            f"got {r.outcome} (tick={r.signals.game_tick}, "
+            f"kills={r.signals.units_killed}, "
+            f"buildings={r.signals.own_buildings})"
+        )
+
+
+def test_medium_intended_cluster_wins_every_seed():
+    c = compile_level(load_pack(PACK), "medium")
     for seed in SEEDS:
         r = run_level(c, make_cluster(), seed=seed)
         assert r.outcome == "win", (
-            f"{level} seed{seed}: intended cluster topology must WIN; "
+            f"medium seed{seed}: intended CLUSTER topology 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})"
         )
 
 
+def test_hard_matched_topology_wins_every_seed():
+    """Hard rotates enemy spawn_point per seed: even-indexed
+    spawn_point = 0 (concentrated) ⇒ CLUSTER wins; spawn_point = 1
+    (wide-front) ⇒ LINE wins. The seed���spawn_point round-robin in the
+    env is seed%2 on enemy-side, so odd seeds → spawn_point 1 and
+    even seeds → spawn_point 0."""
+    c = compile_level(load_pack(PACK), "hard")
+    for seed in SEEDS:
+        # Try both topologies; at least one must WIN on this seed
+        # (the matched one). The pack's no-cheat bar (below) checks
+        # the unmatched one LOSES.
+        r_cluster = run_level(c, make_cluster(), seed=seed)
+        r_line = run_level(c, make_line(), seed=seed)
+        wins = [n for n, r in (("cluster", r_cluster), ("line", r_line))
+                if r.outcome == "win"]
+        assert wins, (
+            f"hard seed{seed}: neither topology won (cluster={r_cluster.outcome}, "
+            f"line={r_line.outcome}) — at least one must match the active "
+            f"enemy composition"
+        )
+
+
 # ── no-cheat: every lazy / wrong-topology policy LOSES (not draws) ───
 
 
@@ -240,17 +273,14 @@ def test_intended_cluster_wins_every_level_and_seed(level):
 @pytest.mark.parametrize(
     "policy_name,policy_factory",
     [
-        ("stall",       lambda lvl: stall),
-        ("spread_line", lambda lvl: make_spread_line(_N_PBOX[lvl])),
-        ("pure_army",   lambda lvl: pure_army),
+        ("stall",     lambda lvl: stall),
+        ("pure_army", lambda lvl: pure_army),
     ],
 )
-def test_lazy_and_wrong_topology_policies_lose_every_level_and_seed(
-    level, policy_name, policy_factory
-):
-    """Stall (rush razes fact OR clock), spread-line (region clause
-    unmet), and pure-army (count clause unmet) must ALL LOSE on every
-    level + every seed — no draw."""
+def test_lazy_policies_lose_every_level_and_seed(level, policy_name, policy_factory):
+    """Stall (no pbox built, attackers raze fact or clock runs out)
+    and pure-army (never builds a pbox, fails the count clause) must
+    BOTH LOSE on every level + every seed — no draw."""
     c = compile_level(load_pack(PACK), level)
     fn = policy_factory(level)
     for seed in SEEDS:
@@ -262,13 +292,71 @@ def test_lazy_and_wrong_topology_policies_lose_every_level_and_seed(
         )
 
 
+def test_easy_wrong_topology_cluster_loses_every_seed():
+    """On easy, the LINE topology is intended; a CLUSTER at (60,20)
+    fails the four LINE rung clauses (the cluster's pbox cells are all
+    far from y=4/12/28/36) — the win never latches and the episode
+    times out → LOSS."""
+    c = compile_level(load_pack(PACK), "easy")
+    for seed in SEEDS:
+        r = run_level(c, make_cluster(), seed=seed)
+        assert r.outcome == "loss", (
+            f"easy seed{seed}: wrong-topology CLUSTER must LOSE; "
+            f"got {r.outcome} (tick={r.signals.game_tick}, "
+            f"kills={r.signals.units_killed}, "
+            f"buildings={r.signals.own_buildings})"
+        )
+
+
+def test_medium_wrong_topology_line_loses_every_seed():
+    """On medium, the CLUSTER topology is intended; a LINE attempt at
+    rows y=4/12/28/36 lands on the wall water (the chokepoint-arena's
+    corridor is only y=18..22 at x≈60). Only the in-corridor cell
+    actually places; the rest are rejected, so the count clause
+    fails."""
+    c = compile_level(load_pack(PACK), "medium")
+    for seed in SEEDS:
+        r = run_level(c, make_line(), seed=seed)
+        assert r.outcome == "loss", (
+            f"medium seed{seed}: wrong-topology LINE must LOSE; "
+            f"got {r.outcome} (tick={r.signals.game_tick}, "
+            f"kills={r.signals.units_killed}, "
+            f"buildings={r.signals.own_buildings})"
+        )
+
+
+def test_hard_unmatched_topology_loses_on_at_least_one_seed():
+    """On hard, the enemy composition flips by seed. A memorised
+    topology that satisfies the region clause (cluster OR line)
+    cannot satisfy the kill quota on the unmatched seed — at least
+    one of the four seeds must be a LOSS for EACH topology
+    individually."""
+    c = compile_level(load_pack(PACK), "hard")
+    cluster_losses = sum(
+        1 for seed in SEEDS
+        if run_level(c, make_cluster(), seed=seed).outcome == "loss"
+    )
+    line_losses = sum(
+        1 for seed in SEEDS
+        if run_level(c, make_line(), seed=seed).outcome == "loss"
+    )
+    assert cluster_losses >= 1, (
+        f"hard: CLUSTER must LOSE on at least one of seeds {SEEDS} "
+        f"(the wide-front seed); got 0 losses"
+    )
+    assert line_losses >= 1, (
+        f"hard: LINE must LOSE on at least one of seeds {SEEDS} "
+        f"(the concentrated seed); got 0 losses"
+    )
+
+
 # ── determinism ──────────────────────────────────────────────────────
 
 
 def test_intended_run_is_deterministic_on_easy():
     c = compile_level(load_pack(PACK), "easy")
-    a = run_level(c, make_cluster(), seed=3)
-    b = run_level(c, make_cluster(), seed=3)
+    a = run_level(c, make_line(), seed=3)
+    b = run_level(c, make_line(), seed=3)
     assert (a.outcome, a.turns, a.signals.units_killed) == (
         b.outcome,
         b.turns,

tests/test_hard_tier.py

@@ -1465,7 +1465,7 @@ UPGRADED = [
     "scout-detect-enemy-tech",  # hard: 2 agent spawn_point groups
     "coord-converge-on-target",  # hard: 2 agent spawn_point groups
     "econ-quantitative-vs-qualitative-spend",  # hard: 2 agent spawn_point groups
-    "def-tower-line-vs-cluster",  # hard: 2 agent spawn_point groups
+    "def-tower-line-vs-cluster",  # hard: 2 ENEMY spawn_point groups (concentrated vs wide-front)
     "coord-cover-and-move",  # hard: 2 agent spawn_point groups
     "combat-kite-and-pull",  # hard: 2 agent spawn_point groups (Wave-12)
     "econ-tech-vs-expand-decision",  # hard: 2 agent spawn_point groups (Wave-12)