feat(scenario): build-defensive-tower-line — pbox-line choke defense (ERQA / MicroRTS anchor)

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

@@ -0,0 +1,258 @@
+meta:
+  id: build-defensive-tower-line
+  title: 'Build a Defensive Tower LINE Across the Choke (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.
+    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).
+  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.
+  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 `rusher` scripted bot charges the agent's
+# centroid (agent fact on the west), so its path is forced THROUGH
+# that lane on every seed. Agent base pre-placed at the west (fact +
+# tent + powr) so the pbox queue is ready turn 1.
+# Pack-level cash is overridden per-level (4/4/4 pbox at 600cr each;
+# medium/hard get tighter constraints, not more pbox — see below).
+# An unarmed high-HP enemy `fact` far east keeps the engine alive
+# past rusher 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:
+    faction: allies
+  enemy:
+    faction: soviet
+    bot_type: rusher
+  tools:
+    - observe
+    - build
+    - place_building
+    - move_units
+    - attack_unit
+    - 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).
+  termination:
+    max_ticks: 12000
+  actors:
+    # Pre-placed agent base on the WEST so rusher path is forced
+    # through the mid-map corridor 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]}
+
+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
+  # and a cluster on y=20 misses ALL FOUR). The intended LINE places
+  # one pbox per rung (4 rungs × 1 pbox = budget exhausted). A cluster
+  # at (60,20) satisfies the count clause but FAILS each rung; a
+  # random scatter (e.g. 4 pbox near the base) misses every rung; 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:
+    description: >
+      A rusher band 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; a random scatter near the base fails
+      every rung; a pure-army layout (no pbox) fails the count and
+      lets the rush raze the fact. Your fact must survive.
+    starting_cash: 2400
+    overrides:
+      actors:
+        - {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 (light wave).
+        - {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}
+        # Light rusher band at far east — forced through the corridor
+        # on the way to agent fact centroid (10, 20).
+        - {type: e1, owner: enemy, position: [100, 20], stance: 3, count: 4}
+        - {type: e3, owner: enemy, position: [102, 20], stance: 3, count: 1}
+        # 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]}
+    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: fact, n: 1}
+        - within_ticks: 5400
+    fail_condition:
+      any_of:
+        - after_ticks: 5401
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 60
+
+  # ── MEDIUM ── +1 axis: HEAVY wave (rusher band ~doubled) with
+  # the SAME tight 4-pbox budget. The cluster, scatter, and pure-army
+  # layouts still all lose the same way as easy; the difference is
+  # that the LINE has to assemble FASTER before the heavier rush
+  # breaks through the pre-placed defenders. max_turns 60 ⇒
+  # reachable tick 5403; deadline 5400.
+  medium:
+    description: >
+      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 LINE must assemble fast. A cluster, a scatter, and a
+      pure-army layout all lose; the fact must survive.
+    starting_cash: 2400
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 20]}
+        - {type: tent, owner: agent, position: [14, 18]}
+        - {type: powr, owner: agent, position: [14, 22]}
+        # 5 mobile base defenders + a 4-rifle corridor screen at the
+        # choke entrance (x=58) so the LINE has time to assemble
+        # behind the screen against the heavier wave. The screen
+        # WILL be ground down by the rush; only the LINE topology
+        # finishes the survivors before the fact dies.
+        - {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}
+        - {type: e1, owner: agent, position: [58, 18], stance: 2}
+        - {type: e1, owner: agent, position: [58, 19], stance: 2}
+        - {type: e1, owner: agent, position: [58, 21], stance: 2}
+        - {type: e1, owner: agent, position: [58, 22], stance: 2}
+        # Heavier rusher band (one more e1 than easy, same e3
+        # grenadier). The tighter timing pressure — not more cash
+        # for more pbox — is what makes medium harder than easy.
+        # Band staged at x=115 (vs easy x=100) so the LINE has time
+        # to fully assemble behind the corridor screen before the
+        # heavier band engages it.
+        - {type: e1, owner: enemy, position: [115, 20], stance: 3, count: 5}
+        - {type: e3, owner: enemy, position: [117, 20], stance: 3, count: 1}
+        # Anti-DRAW marker.
+        - {type: fact, owner: enemy, position: [120, 20]}
+    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: fact, n: 1}
+        - within_ticks: 5400
+    fail_condition:
+      any_of:
+        - after_ticks: 5401
+        - 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:
+    description: >
+      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. The fact must survive.
+    starting_cash: 2400
+    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.
+        - {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: e1,   owner: agent, position: [12, 12], stance: 2, spawn_point: 0}
+        - {type: e1,   owner: agent, position: [12, 13], stance: 2, spawn_point: 0}
+        - {type: e1,   owner: agent, position: [12, 11], stance: 2, spawn_point: 0}
+        - {type: e1,   owner: agent, position: [14, 12], stance: 2, spawn_point: 0}
+        - {type: e1,   owner: agent, position: [8,  12], stance: 2, spawn_point: 0}
+        # spawn_point 1 — SOUTH base at y=28 (mirror across y=20).
+        - {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: e1,   owner: agent, position: [12, 28], stance: 2, spawn_point: 1}
+        - {type: e1,   owner: agent, position: [12, 27], stance: 2, spawn_point: 1}
+        - {type: e1,   owner: agent, position: [12, 29], stance: 2, spawn_point: 1}
+        - {type: e1,   owner: agent, position: [14, 28], stance: 2, spawn_point: 1}
+        - {type: e1,   owner: agent, position: [8,  28], stance: 2, spawn_point: 1}
+        # Enemies don't honour spawn_point (engine: oramap.rs).
+        # Symmetric rusher band at y=20 (mid-latitude); charges agent
+        # centroid so its path crosses the x=60 corridor on every
+        # seed regardless of which base latitude was picked.
+        - {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]}
+    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: fact, n: 1}
+        - within_ticks: 6300
+    fail_condition:
+      any_of:
+        - after_ticks: 6301
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 70

openra_bench/scenarios/packs/econ-harvester-pathing-optimization.yaml

@@ -0,0 +1,279 @@
+meta:
+  id: econ-harvester-pathing-optimization
+  title: Economy — Harvester Pathing Optimization (Split-Routing M/M/c)
+  capability: reasoning
+  real_world_meaning: >
+    Split-routing under heterogeneous round-trip cost. The agent owns
+    TWO harvesters and faces TWO ore patches: A — a NEAR small patch
+    (rich per-cell but quickly exhausted by two collectors stacking on
+    it) — and B — a FAR larger patch (slow per-cycle but doesn't
+    saturate). The optimal policy sends ONE harvester to A and ONE to
+    B (the "split route"), so the proc receives a steady alternating
+    delivery stream from two short and one long round-trip cycle. The
+    LAZY/BRUTE alternatives both fail: piling BOTH harvs on A pumps
+    early cash but never enters B's region (the routing constraint in
+    the win predicate goes unmet); piling BOTH on B earns barely any
+    income within the deadline (long round-trip dominates). Stalling
+    earns zero. The capability under test is the OR vehicle-routing /
+    SC2 worker-distribution insight: distribute collectors across
+    heterogeneous sources to balance round-trip throughput, not to
+    monocrop the best-looking node.
+  robotics_analogue: >
+    Fleet vehicle-routing across a multi-server queueing system
+    (M/M/c): two pickup stations at different distances from a depot,
+    each modelled as a server with its own service rate; the optimal
+    fleet allocation puts exactly one vehicle per server so the depot
+    queue alternates arrivals from heterogeneous cycle times rather
+    than stacking all vehicles on the lowest-latency server (which
+    saturates the server and starves throughput) or the
+    highest-throughput server (which dominates the cycle and starves
+    the depot in early windows).
+  author: wave7-fleet
+  benchmark_anchor:
+    - "SC2 worker distribution"
+    - "OR vehicle routing"
+    - "M/M/c queueing"
+
+# ENGINE NOTE (verified 2026-05-20 against installed openra_train wheel,
+# post-S0/S1 harvest income — Task #14, scripted run_level seeds 1-4):
+#
+# 1. Per-harvester yields over 4500 ticks (50 turns) on rush-hour-arena,
+#    proc at (12,18), 2 harvs at (14,18)/(14,20):
+#       A=(16,18) NEAR — ~9000 cr/harv/4500t (1 harv: 8000; 2 harvs: 18000)
+#       B=(60,18) MID  — ~1500 cr/harv/4500t (1 harv: 1000-2000)
+#       B=(80,18) FAR  — ~1000 cr/harv/4500t (1 harv: 1000)
+#    The 2-harv yield on A is HIGHER than 1A+1B in raw credits, BUT
+#    the win predicate REQUIRES a harv inside BOTH region A AND region
+#    B (`units_of_type_in_region_gte` clauses). The "stack on A"
+#    policy never enters B's region (the harvest order persists, the
+#    harv shuttles between A and proc), so the routing clause fails
+#    even at 18000 cr. This is the discrimination teeth: the win
+#    predicate enforces SPLIT routing as a hard constraint, not as a
+#    cash-output preference.
+#
+# 2. Empirical (seed 1, scripted policies):
+#       stall       0 cr — LOSS every tier (no cash, no region cover)
+#       2-on-A     18000 cr but 0 harvs in B — LOSS every tier
+#       2-on-B      2000 cr (FAR) — LOSS every tier (cash < bar)
+#       1A+1B (split)  4500-6000 cr + both region clauses fire — WIN
+#                   every tier; WIN fires at ~turn 25 (easy, B nearer)
+#                   or turn 35 (medium/hard, B farther) when the
+#                   loaded harv from B passes through B's radius
+#                   while the A harv is at A.
+#
+# 3. The `harvest` order with an explicit target cell PERSISTS — the
+#    harv shuttles patch ↔ proc on that route. To pivot to a different
+#    patch the agent must re-issue `harvest` with new coords. This is
+#    the routing knob the model uses.
+#
+# 4. Tick budget: engine advances ~90 ticks per decision turn.
+#    Easy/medium use max_turns=50 → ceiling 4503 → within_ticks =
+#    after_ticks = 4500 (non-finisher LOSES, not draws).
+#    Hard uses max_turns=50 → ceiling 4503 → within_ticks =
+#    after_ticks = 4500 (same alignment).
+#
+# 5. The pre-placed proc + fact + harvs trigger ConquestVictoryConditions
+#    — without a persistent enemy actor the engine auto-`done`s on
+#    "all enemies dead". An unarmed e1 at (120,36) stance:0 sits well
+#    outside the harvest envelope so it can't be killed; the win/fail
+#    predicate evaluates cleanly to the bar.
+#
+# 6. Hard tier spawn round-robin (verified seeds 1-4): seeds 1,3
+#    pick spawn_point 1 (SOUTH base, proc at y=28); seeds 2,4 pick
+#    spawn_point 0 (NORTH base, proc at y=14). The neutral mines
+#    place at the SAME four cells across both spawns (CLAUDE.md:
+#    "spawn_point filter applies ONLY to AGENT actors"), but the
+#    SPAWN-MATCHED A/B pair flips per seed: NORTH → A=(16,14)
+#    B=(80,14); SOUTH → A=(16,28) B=(80,28). A memorised "always
+#    split (16,14)+(80,14)" policy LOSES on the SOUTH seeds (1,3)
+#    because the harvs head north and never enter the SOUTH-matched
+#    regions of the active win-predicate disjunct. The win predicate
+#    is `any_of` over the two spawn-matched (A,B) pairs.
+
+base_map: rush-hour-arena
+starting_cash: 0
+
+base:
+  agent:
+    faction: allies
+  enemy:
+    faction: soviet
+  tools:
+    - observe
+    - harvest
+    - move_units
+    - stop
+  planning: true
+  termination:
+    max_ticks: 40000
+  actors:
+    # Pre-placed agent base + 2 harvs centred on row y=18..20.
+    - {type: fact, owner: agent, position: [10, 22]}
+    - {type: proc, owner: agent, position: [12, 18]}
+    - {type: harv, owner: agent, position: [14, 18]}
+    - {type: harv, owner: agent, position: [14, 20]}
+    # Default patches (overridden per level for tier-specific geometry).
+    - {type: mine, owner: neutral, position: [16, 18]}
+    - {type: mine, owner: neutral, position: [80, 18]}
+    # Inert enemy marker far from the harvest envelope keeps the
+    # episode from auto-terminating on "all enemies dead" before the
+    # win/fail predicate is evaluated.
+    - {type: e1, owner: enemy, position: [120, 36], stance: 0}
+
+levels:
+  easy:
+    description: >
+      Two patches and two harvesters. A — NEAR patch at (16,18) — is
+      rich per-cell; B — MID patch at (60,18) — is slower per round-
+      trip. The win predicate requires economy_value ≥ 4000 AND at
+      least one harvester in EACH patch's region (radius 6). Stacking
+      both harvs on A pumps 18000 cr but never enters B's region —
+      LOSS. Stacking both on B earns only ~2000 cr — LOSS. The split
+      (1 harv to A, 1 to B) clears both routing clauses AND the modest
+      cash bar — WIN. The capability asked is "use BOTH patches with
+      one harv each, don't monocrop the best-looking one".
+    starting_cash: 0
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 22]}
+        - {type: proc, owner: agent, position: [12, 18]}
+        - {type: harv, owner: agent, position: [14, 18]}
+        - {type: harv, owner: agent, position: [14, 20]}
+        - {type: mine, owner: neutral, position: [16, 18]}
+        - {type: mine, owner: neutral, position: [60, 18]}
+        - {type: e1, owner: enemy, position: [120, 36], stance: 0}
+    win_condition:
+      all_of:
+        - economy_value_gte: 4000
+        - has_building: fact
+        - units_of_type_in_region_gte:
+            type: harv
+            x: 16
+            y: 18
+            radius: 6
+            n: 1
+        - units_of_type_in_region_gte:
+            type: harv
+            x: 60
+            y: 18
+            radius: 6
+            n: 1
+        - within_ticks: 4500
+    # ceiling 93 + 90*49 = 4503 ⇒ deadline bites; non-finisher LOSES.
+    fail_condition:
+      any_of:
+        - after_ticks: 4500
+        - not: {has_building: fact}
+        - not: {has_building: proc}
+    max_turns: 50
+  medium:
+    description: >
+      Same split-routing capability as easy, but B is pushed out to
+      (80,18) (FAR) so 2-on-B yields only ~2000 cr/4500t and the bar
+      is tightened to 5000 cr. The capability asked is identical —
+      one harv per patch — but the deadline now bites harder on a
+      monocrop policy: 2-on-A still earns the most credits (18000)
+      but the B-region clause is unsatisfied so the win never fires;
+      2-on-B clears the routing clause but only earns ~2000 cr; the
+      split (1 each) clears both at ~6000 cr around turn 35.
+    starting_cash: 0
+    win_condition:
+      all_of:
+        - economy_value_gte: 5000
+        - has_building: fact
+        - units_of_type_in_region_gte:
+            type: harv
+            x: 16
+            y: 18
+            radius: 6
+            n: 1
+        - units_of_type_in_region_gte:
+            type: harv
+            x: 80
+            y: 18
+            radius: 6
+            n: 1
+        - within_ticks: 4500
+    # ceiling 93 + 90*49 = 4503 ⇒ deadline bites; non-finisher LOSES.
+    fail_condition:
+      any_of:
+        - after_ticks: 4500
+        - not: {has_building: fact}
+        - not: {has_building: proc}
+    max_turns: 50
+  hard:
+    description: >
+      Two spawn groups round-robined per seed: NORTH base (y=14) and
+      SOUTH base (y=28). Four neutral mines stay fixed at
+      (16,14)/(16,28)/(80,14)/(80,28); the SPAWN-MATCHED (A,B) pair
+      flips per seed — NORTH → A=(16,14), B=(80,14); SOUTH →
+      A=(16,28), B=(80,28). The win predicate is `any_of` over the
+      two spawn-matched split clauses, so a memorised "always send to
+      (16,14)+(80,14)" policy LOSES on the SOUTH seeds because the
+      harvs never enter the SOUTH-matched regions of the satisfied
+      disjunct. The capability asked is "identify your own spawn,
+      then split-route to the MATCHED A and B regions" — a route-
+      planning task that cannot be memorised from a single seed.
+    starting_cash: 0
+    overrides:
+      actors:
+        # spawn_point 0 — base NORTH (proc + harvs around y=14).
+        - {type: fact, owner: agent, position: [10, 14], spawn_point: 0}
+        - {type: proc, owner: agent, position: [12, 14], spawn_point: 0}
+        - {type: harv, owner: agent, position: [14, 14], spawn_point: 0}
+        - {type: harv, owner: agent, position: [14, 15], spawn_point: 0}
+        # spawn_point 1 — base SOUTH (proc + harvs around y=28).
+        - {type: fact, owner: agent, position: [10, 28], spawn_point: 1}
+        - {type: proc, owner: agent, position: [12, 28], spawn_point: 1}
+        - {type: harv, owner: agent, position: [14, 28], spawn_point: 1}
+        - {type: harv, owner: agent, position: [14, 29], spawn_point: 1}
+        # Four shared patches — identical to both spawns; the MATCHED
+        # (A,B) pair flips per seed (NORTH → (16,14)+(80,14); SOUTH →
+        # (16,28)+(80,28)).
+        - {type: mine, owner: neutral, position: [16, 14]}
+        - {type: mine, owner: neutral, position: [80, 14]}
+        - {type: mine, owner: neutral, position: [16, 28]}
+        - {type: mine, owner: neutral, position: [80, 28]}
+        - {type: e1, owner: enemy, position: [120, 36], stance: 0}
+    win_condition:
+      all_of:
+        - has_building: fact
+        - within_ticks: 4500
+        - any_of:
+            # NORTH-matched split.
+            - all_of:
+                - economy_value_gte: 5000
+                - units_of_type_in_region_gte:
+                    type: harv
+                    x: 16
+                    y: 14
+                    radius: 6
+                    n: 1
+                - units_of_type_in_region_gte:
+                    type: harv
+                    x: 80
+                    y: 14
+                    radius: 6
+                    n: 1
+            # SOUTH-matched split.
+            - all_of:
+                - economy_value_gte: 5000
+                - units_of_type_in_region_gte:
+                    type: harv
+                    x: 16
+                    y: 28
+                    radius: 6
+                    n: 1
+                - units_of_type_in_region_gte:
+                    type: harv
+                    x: 80
+                    y: 28
+                    radius: 6
+                    n: 1
+    # ceiling 93 + 90*49 = 4503 ⇒ deadline bites; non-finisher LOSES.
+    fail_condition:
+      any_of:
+        - after_ticks: 4500
+        - not: {has_building: fact}
+        - not: {has_building: proc}
+    max_turns: 50

tests/test_build_defensive_tower_line.py

@@ -0,0 +1,297 @@
+"""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).
+
+Anchors: ERQA spatial commit / MicroRTS defense placement / military
+perimeter (firewall rule placement).
+
+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:{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 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 hard tier defines ≥2 spawn_point groups (NORTH base y=12 / SOUTH
+  base y=28) so a memorised base-relative placement cannot generalise.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+
+from openra_bench.eval_core import run_level
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+
+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)]
+
+# Cells used by the "random-4-pbox" wrong-topology policy: 4 pboxes
+# clustered near the base rather than along the corridor. 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)]
+
+
+# ── scripted policies ────────────────────────────────────────────────
+
+
+def stall(rs, C):
+    """Observe-only — the agent never spends. Fact gets razed by the
+    rush AND the count/region clauses are never satisfied."""
+    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 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)]
+        # 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
+
+    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 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):
+            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],
+            )
+        )
+        return cmds
+
+    return policy
+
+
+# ── scenario-shape invariants ────────────────────────────────────────
+
+
+def test_pack_compiles_with_three_levels_and_rusher_bot():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "build-defensive-tower-line"
+    assert pack.meta.capability == "reasoning"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+    # Required-by-spec benchmark anchors.
+    anchors = pack.meta.benchmark_anchor
+    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).
+    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)
+
+
+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."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.starting_cash == 2400, (lvl, c.starting_cash)
+
+
+@pytest.mark.parametrize("level", LEVELS)
+def test_every_level_has_a_reachable_timeout_fail(level):
+    """Non-win must be a real LOSS: the `after_ticks` fail clause must
+    be strictly below the tick reachable at max_turns. No interrupts on
+    this pack ⇒ each step is exactly 90 ticks (max tick = 93+90·(N-1))."""
+    c = compile_level(load_pack(PACK), level)
+    assert c.fail_condition is not None
+    fc = c.fail_condition.model_dump(exclude_none=True)
+    deadline = None
+    for clause in fc.get("any_of", []) or []:
+        if "after_ticks" in clause:
+            deadline = int(clause["after_ticks"])
+    assert deadline is not None, f"{level}: no after_ticks fail clause"
+    reachable = 93 + 90 * (c.max_turns - 1)
+    assert deadline < reachable, (
+        f"{level}: deadline {deadline} unreachable within "
+        f"{c.max_turns} turns (max tick {reachable}) → draw degeneracy"
+    )
+
+
+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."""
+    for lvl in LEVELS:
+        c = compile_level(load_pack(PACK), lvl)
+        fc = c.fail_condition.model_dump(exclude_none=True)
+        fact_clauses = [
+            clause for clause in fc.get("any_of", []) or []
+            if isinstance(clause, dict)
+            and isinstance(clause.get("not"), dict)
+            and "building_count_gte" in (clause["not"] or {})
+            and (clause["not"]["building_count_gte"] or {}).get("type") == "fact"
+        ]
+        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)}"
+        )
+
+
+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."""
+    c = compile_level(load_pack(PACK), "hard")
+    groups = {
+        a.spawn_point for a in c.scenario.actors
+        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):
+    for a in c.scenario.actors:
+        x, y = a.position
+        assert 2 <= x <= 126 and 2 <= y <= 38, (a.type, a.position)
+
+
+# ── solvency: intended LINE wins every level + every hard seed ───────
+
+
+@pytest.mark.parametrize("level", LEVELS)
+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)
+        assert r.outcome == "win", (
+            f"{level} seed{seed}: intended LINE 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})"
+        )
+
+
+# ── no-cheat: every lazy / wrong-topology policy LOSES (not draws) ───
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize(
+    "policy_name,policy_factory",
+    [
+        ("stall",         lambda: stall),
+        ("random_4_pbox", lambda: make_random_4_pbox()),
+    ],
+)
+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."""
+    c = compile_level(load_pack(PACK), level)
+    fn = policy_factory()
+    for seed in SEEDS:
+        r = run_level(c, fn, seed=seed)
+        assert r.outcome == "loss", (
+            f"{level} seed{seed} {policy_name}: must LOSE (real fail, "
+            f"not a draw); got {r.outcome} (tick={r.signals.game_tick}, "
+            f"buildings={r.signals.own_buildings})"
+        )
+
+
+# ── determinism ──────────────────────────────────────────────────────
+
+
+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)
+    assert (a.outcome, a.turns, a.signals.units_killed) == (
+        b.outcome,
+        b.turns,
+        b.signals.units_killed,
+    ), "same seed must be deterministic"

tests/test_econ_harvester_pathing_optimization.py

@@ -0,0 +1,358 @@
+"""Full contributor-loop validation for econ-harvester-pathing-optimization.
+
+The pack tests harvester SPLIT-routing under heterogeneous round-trip
+cost (OR vehicle-routing / SC2 worker-distribution / M/M/c queueing).
+TWO harvesters, TWO patches — A near and B far. The optimal policy
+sends ONE harv to A and ONE to B; the win predicate encodes the
+routing requirement as `units_of_type_in_region_gte` clauses on BOTH
+patch regions plus a modest cash bar.
+
+Bar (per CLAUDE.md "no defect, no cheat"):
+- stall LOSES every tier (no income, no region cover).
+- 2-on-A LOSES every tier — pumps more credits than the bar but never
+  enters B's region, so the routing clause fails.
+- 2-on-B LOSES every tier — clears B's region but the FAR round-trip
+  earns ~2000 cr, well below the cash bar.
+- 1A+1B (intended SPLIT) WINS every tier and every hard seed.
+- Hard: a memorised single-pair "always send to (16,14)+(80,14)"
+  policy LOSES on the spawn-mismatched seeds (the `any_of` disjunct
+  for that spawn pair never matches).
+- The capability-policy that IDENTIFIES the matched (A,B) pair from
+  the harvs' Y row and splits accordingly WINS every hard seed.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+from openra_bench.eval_core import run_level
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+
+PACK = PACKS_DIR / "econ-harvester-pathing-optimization.yaml"
+
+# Easy / medium geometry.
+EASY_A = (16, 18)
+EASY_B = (60, 18)
+MED_A = (16, 18)
+MED_B = (80, 18)
+
+# Hard tier: four patches, NORTH and SOUTH spawn-matched pairs.
+HARD_NA = (16, 14)
+HARD_NB = (80, 14)
+HARD_SA = (16, 28)
+HARD_SB = (80, 28)
+
+
+# ---------------------------------------------------------------- policies
+
+
+def stall_policy(rs, Command):
+    return [Command.observe()]
+
+
+def _make_alloc(targets):
+    """Send harv[i] (in id order) to targets[i] every turn. The
+    `harvest` order persists so re-issuing is idempotent; passing
+    `None` for a slot leaves that harv idle (used by the stall-ish
+    one-harv probes)."""
+    def f(rs, Command):
+        harvs = sorted(
+            (u for u in rs.get("units_summary", []) if u.get("type") == "harv"),
+            key=lambda u: u["id"],
+        )
+        cmds = []
+        for h, t in zip(harvs, targets):
+            if t is not None:
+                cmds.append(Command.harvest([str(h["id"])], *t))
+        return cmds or [Command.observe()]
+    return f
+
+
+def _make_smart_hard():
+    """Hard-tier intended policy: identify the matched (A,B) pair from
+    the harvs' Y row (NORTH base → harvs at y=14..15 → split to
+    (16,14)+(80,14); SOUTH base → y=28..29 → split to (16,28)+(80,28))."""
+    def f(rs, Command):
+        harvs = sorted(
+            (u for u in rs.get("units_summary", []) if u.get("type") == "harv"),
+            key=lambda u: u["id"],
+        )
+        if not harvs:
+            return [Command.observe()]
+        y = harvs[0]["cell_y"]
+        if y < 21:
+            targets = [HARD_NA, HARD_NB]
+        else:
+            targets = [HARD_SA, HARD_SB]
+        return [
+            Command.harvest([str(h["id"])], *t)
+            for h, t in zip(harvs, targets)
+        ]
+    return f
+
+
+# ---------------------------------------------------------------- helpers
+
+
+def _run(level, policy_factory, seed=1):
+    c = compile_level(load_pack(PACK), level)
+    assert c.map_supported, "rush-hour-arena terrain must be present"
+    policy = policy_factory() if callable(policy_factory) else policy_factory
+    return c, run_level(c, policy, seed=seed)
+
+
+def _ev(res):
+    return res.signals.cash + res.signals.resources
+
+
+# ---------------------------------------------------------------- structural
+
+
+def test_pack_loads_and_meta_active():
+    pack = load_pack(PACK)
+    assert pack.meta.status == "active"
+    assert pack.meta.id == "econ-harvester-pathing-optimization"
+    assert pack.meta.capability == "reasoning"
+    anchors = pack.meta.benchmark_anchor
+    # The task's three named real-world / benchmark anchors.
+    assert any("SC2" in a and "worker" in a for a in anchors), anchors
+    assert any("OR" in a and "routing" in a for a in anchors), anchors
+    assert any("M/M/c" in a for a in anchors), anchors
+
+
+def test_all_tiers_have_reachable_deadlines():
+    """tick-alignment idiom: within_ticks ≤ ceiling AND
+    after_ticks ≤ ceiling AND within_ticks == after_ticks (so a
+    non-finisher LOSES, not draws)."""
+    pack = load_pack(PACK)
+
+    def _find_within(node):
+        """Recurse through nested all_of/any_of to find the
+        within_ticks leaf in the win condition."""
+        if isinstance(node, dict):
+            if "within_ticks" in node:
+                return int(node["within_ticks"])
+            for k in ("all_of", "any_of"):
+                if k in node:
+                    for c in node[k]:
+                        v = _find_within(c)
+                        if v is not None:
+                            return v
+        return None
+
+    for lvl in ("easy", "medium", "hard"):
+        L = pack.levels[lvl]
+        ceiling = 93 + 90 * (L.max_turns - 1)
+        wt = _find_within(L.win_condition.model_dump())
+        ft = next(
+            int(c["after_ticks"])
+            for c in L.fail_condition.model_dump()["any_of"]
+            if "after_ticks" in c
+        )
+        assert wt is not None, f"{lvl}: within_ticks missing from win"
+        assert wt <= ceiling, f"{lvl}: within_ticks {wt} > ceiling {ceiling}"
+        assert ft <= ceiling, f"{lvl}: after_ticks {ft} > ceiling {ceiling}"
+        assert wt == ft, (
+            f"{lvl}: within_ticks {wt} != after_ticks {ft} "
+            "(non-finisher must LOSE, not draw)"
+        )
+
+
+def test_hard_has_two_seed_driven_spawn_groups():
+    """Hard tier must define ≥2 agent spawn_point groups (the
+    UPGRADED contract — a single memorised opening can't generalise)."""
+    c = compile_level(load_pack(PACK), "hard")
+    sp = {
+        (a.spawn_point if a.spawn_point is not None else 0)
+        for a in c.scenario.actors
+        if a.owner == "agent"
+    }
+    assert len(sp) >= 2, (
+        f"hard must define ≥2 agent spawn_point groups; got {sorted(sp)}"
+    )
+
+
+# ---------------------------------------------------------------- EASY
+
+
+def test_easy_stall_loses():
+    _, res = _run("easy", lambda: stall_policy)
+    assert res.outcome == "loss", (
+        f"stall must LOSE easy; got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_easy_both_to_a_loses_despite_high_cash():
+    """The crucial discrimination: 2-on-A earns ~18000 cr (well over
+    the 4000 bar) but never enters B's region — the routing clause
+    fails so the win predicate as a whole fails. LOSS, not WIN."""
+    _, res = _run("easy", lambda: _make_alloc([EASY_A, EASY_A]))
+    assert res.outcome == "loss", (
+        f"2-on-A must LOSE easy (no harv in B region); "
+        f"got {res.outcome} ev={_ev(res)}"
+    )
+    assert _ev(res) >= 8000, (
+        f"2-on-A should still HAVE earned a lot of cash "
+        f"(routing clause is the teeth, not cash); ev={_ev(res)}"
+    )
+
+
+def test_easy_both_to_b_loses_on_cash():
+    """2-on-B clears B's region but the FAR round-trip earns ~2000 cr
+    over 4500 ticks — well below the 4000 bar. LOSS."""
+    _, res = _run("easy", lambda: _make_alloc([EASY_B, EASY_B]))
+    assert res.outcome == "loss", (
+        f"2-on-B must LOSE easy (~2000 ev < 4000 bar); "
+        f"got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_easy_split_wins():
+    """The intended split (1 harv to A, 1 harv to B) clears both
+    routing clauses AND the modest cash bar — WIN."""
+    _, res = _run("easy", lambda: _make_alloc([EASY_A, EASY_B]))
+    assert res.outcome == "win", (
+        f"1A+1B split must WIN easy; got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_easy_split_wins_either_assignment():
+    """The assignment of which harv-id goes where doesn't matter —
+    routing is symmetric. Sanity check the reversed assignment also
+    wins (catches a hidden id-ordering dependency)."""
+    _, res = _run("easy", lambda: _make_alloc([EASY_B, EASY_A]))
+    assert res.outcome == "win", (
+        f"1B+1A split must WIN easy; got {res.outcome} ev={_ev(res)}"
+    )
+
+
+# ---------------------------------------------------------------- MEDIUM
+
+
+def test_medium_stall_loses():
+    _, res = _run("medium", lambda: stall_policy)
+    assert res.outcome == "loss", (
+        f"stall must LOSE medium; got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_medium_both_to_a_loses_despite_high_cash():
+    """2-on-A still earns the most credits (~18000) but the B-region
+    clause is unsatisfied. LOSS."""
+    _, res = _run("medium", lambda: _make_alloc([MED_A, MED_A]))
+    assert res.outcome == "loss", (
+        f"2-on-A must LOSE medium (no harv in B region); "
+        f"got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_medium_both_to_b_loses_on_cash():
+    """B at (80,18) is FAR — 2 harvs there earn only ~2000 cr over
+    4500 ticks, well below the 5000 bar."""
+    _, res = _run("medium", lambda: _make_alloc([MED_B, MED_B]))
+    assert res.outcome == "loss", (
+        f"2-on-B must LOSE medium (~2000 ev < 5000 bar); "
+        f"got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_medium_split_wins():
+    _, res = _run("medium", lambda: _make_alloc([MED_A, MED_B]))
+    assert res.outcome == "win", (
+        f"1A+1B split must WIN medium; got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_medium_split_wins_either_assignment():
+    _, res = _run("medium", lambda: _make_alloc([MED_B, MED_A]))
+    assert res.outcome == "win", (
+        f"1B+1A split must WIN medium; got {res.outcome} ev={_ev(res)}"
+    )
+
+
+# ---------------------------------------------------------------- HARD
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_hard_stall_loses_every_seed(seed):
+    _, res = _run("hard", lambda: stall_policy, seed=seed)
+    assert res.outcome == "loss", (
+        f"stall must LOSE hard/seed{seed}; got {res.outcome} ev={_ev(res)}"
+    )
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_hard_both_to_matched_a_loses_every_seed(seed):
+    """Stacking both harvs on the NORTH-near patch (16,14) is a "use
+    only A" policy. On a NORTH spawn it clears the A-region clause
+    but the NORTH B-region is empty. On a SOUTH spawn it's outright
+    far from both matched regions. LOSS every seed."""
+    _, res = _run("hard", lambda: _make_alloc([HARD_NA, HARD_NA]), seed=seed)
+    assert res.outcome == "loss", (
+        f"2-on-A(north) must LOSE hard/seed{seed}; "
+        f"got {res.outcome} ev={_ev(res)}"
+    )
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_hard_both_to_matched_b_loses_every_seed(seed):
+    """Mirror: 2-on-B(north) — far patch only, never enters A's
+    region (on either spawn) and earns ~1000 cr."""
+    _, res = _run("hard", lambda: _make_alloc([HARD_NB, HARD_NB]), seed=seed)
+    assert res.outcome == "loss", (
+        f"2-on-B(north) must LOSE hard/seed{seed}; "
+        f"got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_hard_memorised_north_split_loses_on_south_spawn_seeds():
+    """A model that memorises "always split (16,14)+(80,14)" loses on
+    the SOUTH-spawn seeds (1 and 3 per round-robin) because the harvs
+    head to NORTH-matched cells and never enter the SOUTH-matched
+    regions — the SOUTH disjunct fails (no harvs in its regions) and
+    the NORTH disjunct fails on cash (the harvs are too far from
+    their own proc to round-trip efficiently)."""
+    for seed in (1, 3):
+        _, res = _run("hard", lambda: _make_alloc([HARD_NA, HARD_NB]), seed=seed)
+        assert res.outcome == "loss", (
+            f"memorised-NORTH-split must LOSE hard/seed{seed} (SOUTH spawn); "
+            f"got {res.outcome} ev={_ev(res)}"
+        )
+
+
+def test_hard_memorised_south_split_loses_on_north_spawn_seeds():
+    """Symmetric: memorising "always split (16,28)+(80,28)" loses on
+    NORTH-spawn seeds 2 and 4."""
+    for seed in (2, 4):
+        _, res = _run("hard", lambda: _make_alloc([HARD_SA, HARD_SB]), seed=seed)
+        assert res.outcome == "loss", (
+            f"memorised-SOUTH-split must LOSE hard/seed{seed} (NORTH spawn); "
+            f"got {res.outcome} ev={_ev(res)}"
+        )
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_hard_smart_spawn_matched_split_wins_every_seed(seed):
+    """The intended capability — identify the spawn-matched (A,B)
+    pair from the agent's harv Y position, then split-route to BOTH
+    matched patches — WINS every seed cleanly."""
+    _, res = _run("hard", _make_smart_hard, seed=seed)
+    assert res.outcome == "win", (
+        f"SMART spawn-matched split must WIN hard/seed{seed}; "
+        f"got {res.outcome} ev={_ev(res)}"
+    )
+
+
+# ---------------------------------------------------------------- determinism
+
+
+def test_outcomes_are_deterministic_per_seed():
+    """Same seed, same policy → identical outcome and ev."""
+    c = compile_level(load_pack(PACK), "medium")
+    a = run_level(c, _make_alloc([MED_A, MED_B]), seed=2)
+    b = run_level(c, _make_alloc([MED_A, MED_B]), seed=2)
+    assert (a.outcome, a.turns, _ev(a)) == (b.outcome, b.turns, _ev(b))

tests/test_hard_tier.py

@@ -117,6 +117,14 @@ UPGRADED = [
     # flips per seed ((16,14) for NORTH, (16,28) for SOUTH), so a
     # memorised "always send to (16,14)" cannot generalise.
     "econ-multi-patch-allocation",
+    # Wave-7 econ reasoning: split-routing under heterogeneous
+    # round-trip cost (OR vehicle-routing / SC2 worker-distribution /
+    # M/M/c). Hard defines two agent spawn_point groups (NORTH base
+    # y=14 / SOUTH base y=28) round-robined by seed; four neutral
+    # mines stay fixed but the SPAWN-MATCHED (A,B) pair flips per
+    # seed (NORTH → (16,14)+(80,14); SOUTH → (16,28)+(80,28)), so a
+    # memorised single-pair split cannot generalise.
+    "econ-harvester-pathing-optimization",
     # Group F opening greenfield seed (Wave-4): cold-start from a
     # single MCV with no buildings / no harvester / no income. Hard
     # tier defines 2 agent spawn_point groups (NORTH (20,14) / SOUTH