feat(scenario): combat-tank-vs-tank-engagement — focus-fire mirror (Lanchester / SC2 anchor)

Wave-7 Group D combat-micro pack (capability: action). 3-vs-3 medium
tank engagement with ASYMMETRIC geometry: 3 agent tanks bunched at
(30,19..21) facing 3 enemy tanks spread across three latitudes at
(50,15)/(51,20)/(50,25). Centre enemy at x=51 (not x=50) per the
CLAUDE.md silent-fail cell note for (50,20).

Discrimination (verified scripted on all 4 hard seeds):
- stall (only observe): tanks never close to firing range; kill
bar unmet; after_ticks LOSS on every level/seed.
- brute attack_move (drive into the centre): force-wipes on
easy/medium (3 tanks lost), busts within_ticks on hard; LOSS
on every level/seed.
- spread-attack-closest (each tank attacks its OWN nearest enemy):
once centre dies, surviving tanks chase flank enemies in 1-vs-1
duels and Lanchester linear collapses the trade; ends 1-of-3
alive => LOSS on medium (load-bearing: busts own_units_gte:2).
Permitted to squeak on easy (own_units_gte:1, inert-easy-teeth
convention). Collapses to focus on hard (flank spawn => unique
closest enemy from a flank perspective).
- intended focus-fire (ALL 3 tanks attack_unit the same target
each turn, closest first): 3-vs-1 concentrated cannon fire ends
each enemy in 1-2 decision turns; all 3 agent tanks survive;
WIN on every level/seed.

Tiers:
- easy: own_units_gte:1, within_ticks 2400 (forgiving bare-skill
tier per SCENARIO_REVIEW_CHECKLIST inert-easy-teeth convention).
- medium: own_units_gte:2 (LOAD-BEARING — discriminates spread vs
focus via the survival cap), within_ticks 2400.
- hard: own_units_gte:1 RELAXED + within_ticks 1200 (tight kill-
speed pressure). Two seed-driven spawn_point groups (NORTH
y=11..13 / SOUTH y=27..29) round-robined by seed for anti-
memorisation; enemy line always places (CLAUDE.md: enemy actors
don't honour spawn_point). Registered in tests/test_hard_tier.py
UPGRADED.

Engine guardrails: agent fact at (4,20) (turn-1 own_units_gte mis-
fire footgun + engine auto-done mitigation on force-wipe); far enemy
fact at (124,20) (second auto-done mitigation). after_ticks 2401
<= 93+90*29 = 2703; after_ticks 1201 <= 93+90*14 = 1353. Enemy
bot_type empty (no scripted pursuit); stance:3 on enemies for auto-
fire on cannon-range entry; stance:1 on agents so a stall policy
doesn't pull stray shots.

openra_bench/scenarios/packs/combat-tank-vs-tank-engagement.yaml

@@ -0,0 +1,357 @@
+# combat-tank-vs-tank-engagement — Mirror tank trade: WIN by focus-fire
+# (concentrate ALL 3 agent tanks on ONE enemy at a time), LOSE by
+# spread-fire (each tank picks its own nearest enemy). Lanchester
+# square law on a 3-vs-3 medium-tank engagement.
+#
+# Wave-7 ACTION pack (capability: action — combat micro: target
+# prioritization / focus-fire discipline).
+#
+# Real-world / benchmark anchors:
+#   - SC2 mirror micro (siege-tank-vs-siege-tank, marine-vs-marine):
+#     the side that concentrates fire on one target at a time wins the
+#     trade; the side that spreads damage across the whole enemy line
+#     trades 1-for-1 and loses the survivor count.
+#   - Lanchester's SQUARE LAW of attrition: combat power of a focused
+#     force scales as N² (per-kill removes one enemy's OUTPUT DPS for
+#     the rest of the fight); spreading fire collapses to the LINEAR
+#     law (mutual 1-for-1 annihilation).
+#   - Military "CONCENTRATION OF FORCE" doctrine (one of the Principles
+#     of War): a smaller or equal force concentrated at the decisive
+#     point can defeat a numerically equivalent dispersed enemy.
+#
+# Design — ASYMMETRIC GEOMETRY (engineered to discriminate):
+#   Prior MIRROR geometry (3 agents at x=30 stacked y=18..22 vs 3
+#   enemies at x=38 stacked y=18..22) was found engine-fragile: when
+#   both sides start fully in cannon range with identical rows, agent
+#   stance:1 ReturnFire causes the auto-target to collapse onto
+#   whichever single enemy fired first, so the spread-fire wrong-play
+#   accidentally focus-fires and the discrimination disappears. THIS
+#   pack uses ASYMMETRIC geometry:
+#     - Agent strike force: 3 medium tanks BUNCHED at (30,19..21) on
+#       a single column (one centroid, one engagement axis).
+#     - Enemy mirror: 3 medium tanks SPREAD across three latitudes
+#       at (50,15), (51,20), (50,25) — three distinct rows along the
+#       eastern engagement line. (Centre enemy at x=51 NOT (50,20)
+#       per the CLAUDE.md-documented silent-placement-fail at (50,20).)
+#   Each enemy is initially OUT of agent cannon range (cannon ≈ 5,
+#   agent at x=30 vs enemy at x=50/51 ⇒ MD ≥ 20), so tanks must close
+#   into engagement — at which point the asymmetry bites:
+#     * SPREAD policy (each agent tank attack_units its OWN nearest
+#       enemy): tank at (30,19) sees (50,15) at MD=24, (51,20) at
+#       MD=22, (50,25) at MD=26 ⇒ targets (51,20); tank at (30,21)
+#       targets (51,20); tank at (30,20) targets (51,20) — actually
+#       all 3 tanks target the centre INITIALLY, but as they advance
+#       and the centre dies, the surviving tanks fan out to chase
+#       the flank enemies one each ⇒ once the spread-fire chase
+#       begins, the trade collapses to 1-vs-1 duels and Lanchester
+#       linear ⇒ 2 of the 3 agent tanks die in the flank engagements.
+#     * FOCUS policy (ALL 3 tanks attack_unit the SAME target in
+#       sequence — closest first, then a flank, then the last):
+#       3-vs-1 concentrated cannon fire ends each enemy in ~1-2
+#       decision turns; after kill #1 the trade is 3-vs-2 (Lanchester
+#       surplus 3²−2² = 5), after kill #2 it is 3-vs-1; all 3 agent
+#       tanks survive.
+#
+# Discrimination bar (four scripted-policy proxies — see test file):
+#   • stall (only observe): tanks idle at (30,*), enemies at (50,*)
+#     stay out of cannon range. Nothing dies on either side ⇒ kill
+#     bar unmet ⇒ after_ticks LOSS at tick 2401.
+#   • brute attack_move(51,20) (drive into the centre): tanks
+#     auto-target the nearest visible enemy en route (per CLAUDE.md
+#     "move_units auto-fires opportunistically en route regardless of
+#     agent stance"); they reach the engagement zone and trade with
+#     all 3 enemies firing back simultaneously ⇒ ≥2 agent tanks die ⇒
+#     LOSS via the survival cap (own_units_gte:2 on medium, force-wipe
+#     trips own_units_gte:1 on easy).
+#   • spread-attack-closest (each tank attack_units its own closest
+#     enemy): as above — once the centre dies, surviving tanks chase
+#     flank enemies on 1-vs-1 duels; Lanchester linear ⇒ 2 of 3 tanks
+#     die. On EASY (own_units_gte:1) the 1 survivor squeaks through
+#     and SPREAD wins (forgiving bare-skill tier, per the
+#     SCENARIO_REVIEW_CHECKLIST inert-easy-teeth convention). On
+#     MEDIUM (own_units_gte:2) the 1 survivor is below the bar ⇒
+#     LOSS — this is the load-bearing discrimination.
+#   • intended focus-fire (ALL 3 tanks attack_unit the SAME target
+#     each turn, starting with the closest enemy by agent centroid,
+#     then re-targeting the next-closest as enemies fall): all 3
+#     enemies die in ~700-900 ticks, all 3 agent tanks alive at the
+#     end ⇒ WIN on every level.
+#
+# Win-bar relaxation note (RELAXED per the task brief): on HARD the
+# survival cap holds at own_units_gte:2 nominally, but the asymmetric
+# discrimination weakens when the agent stack starts on a FLANK
+# latitude (NORTH y=11..13 or SOUTH y=27..29) — from a flank the
+# enemy line at y=15/20/25 has a unique closest enemy that all agent
+# tanks naturally target (spread ≡ focus). Hard's discrimination is
+# therefore primarily KILL-SPEED (within_ticks 1200) + brute / stall
+# anti-cheat teeth + spawn-variation generalisation across NORTH and
+# SOUTH approach axes — the focus-fire skill is what generalises;
+# spread-as-focus on a flank is acceptable because it IS the
+# intended capability when the geometry collapses to a unique
+# closest target.
+#
+# Hard-tier spawn-variation (≥2 spawn_point groups, registered in
+# tests/test_hard_tier.py::UPGRADED):
+#   - NORTH staging y=11..13 (agent at (30,11..13)).
+#   - SOUTH staging y=27..29 (agent at (30,27..29)).
+#   The asymmetric enemy line (3 enemies at y=15/y=20/y=25) is the
+#   SAME for both spawns (enemy actors don't honour spawn_point per
+#   CLAUDE.md / oramap.rs::expand_scenario_actors). From NORTH the
+#   closest enemy is (50,15) and the farthest is (50,25); from SOUTH
+#   the order inverts. A memorised single-target sequence cannot
+#   generalise across the spawn rotation.
+#
+# Engine guardrails (per CLAUDE.md):
+#   - Map: rush-hour-arena (128 × 40, playable x ∈ [2..126],
+#     y ∈ [2..38]). All actor coords inside bounds.
+#   - Agent owns a `fact` at (4,20): provides has_building:fact for
+#     the win predicate AND prevents the engine auto-`done` on
+#     enemy-units-wipe collapsing the run to DRAW before the win
+#     evaluator sees the terminal frame.
+#   - Far persistent enemy `fact` at (124,20) — out of reach in the
+#     declared tick budget; second engine auto-`done` mitigation
+#     (a MustBeDestroyed building stays alive on the enemy side so
+#     the episode persists to the win/fail evaluator).
+#   - Enemy centre tank is at (51,20) — NOT (50,20) — per CLAUDE.md
+#     "Certain mid-map cells silently fail to place enemy clusters
+#     (e.g. (50,20))"; (51,20) is a documented working cell.
+#   - `within_ticks: 2400` / `after_ticks: 2401` on easy+medium;
+#     max_turns=30 produces tick ≤ 93 + 90·29 = 2703 ⇒ stallers /
+#     brute / spread hit the real LOSS, not a DRAW. Hard uses
+#     `within_ticks: 1200` / `after_ticks: 1201` and max_turns=15
+#     (tick ≤ 93 + 90·14 = 1353 ≥ 1201) — kill-speed pressure for
+#     the focus-fire policy.
+#   - Enemy `bot_type: ''` (no scripted bot pursuit) — enemy tanks
+#     sit on stance:3 AttackAnything so they auto-fire the second a
+#     tank enters cannon range; the test is purely the agent's target
+#     prioritization (no bot lunge contaminating the geometry).
+#   - Agent tanks stance:1 ReturnFire so a stall policy (pure observe,
+#     no movement) doesn't accidentally pull fire from any agent tank
+#     before the enemy is in range — the stall remains a clean
+#     timeout LOSS.
+
+meta:
+  id: combat-tank-vs-tank-engagement
+  title: 'Tank-vs-Tank Mirror — Focus-Fire, Lanchester Square Law'
+  capability: action
+  real_world_meaning: >
+    Three medium tanks face three enemy medium tanks at long range in
+    an ASYMMETRIC mirror engagement: the agent strike force is bunched
+    on one column at (30,19..21); the enemy mirror is spread across
+    three latitudes at (50,15), (51,20), (50,25). Per Lanchester's
+    SQUARE LAW, the side that concentrates fire on ONE enemy at a
+    time wins the trade with minimal losses (3-vs-1 cannon fire ends
+    each enemy tank in 1-2 decision turns; combat-power surplus grows
+    quadratically after each kill); the side that lets each tank pick
+    its own closest target — the spread-fire failure mode — collapses
+    to the linear attrition law, ends 1-of-3 alive, and busts the
+    survival bar. The decision under test is target prioritization:
+    concentrate ALL three tanks' fire on the closest enemy first,
+    eliminate it, then the next, then the last — not let each tank
+    pick its own nearest target. Stalling loses on the kill bar;
+    brute attack-move loses on the survival cap; spread-fire loses on
+    the survival cap (medium); only concentrated focus-fire wins.
+  robotics_analogue: >
+    Military "concentration of force" doctrine (one of the Principles
+    of War): a smaller or equal force concentrated at the decisive
+    point can defeat a numerically equivalent dispersed enemy. The
+    per-kill removal of enemy OUTPUT DPS is the closed-form Lanchester
+    square-law advantage of concentrated fire; the test mirrors the
+    SC2 mirror-tank micro / marine-vs-marine engagement where the
+    side that focus-fires one target at a time wins the trade against
+    a numerically equal foe spreading fire across the whole line.
+  benchmark_anchor:
+    - "SC2 mirror micro"
+    - "Lanchester square law"
+    - "concentration of force"
+  author: openra-bench
+
+base_map: rush-hour-arena
+starting_cash: 0
+
+base:
+  agent: {faction: allies, cash: 0}
+  enemy: {faction: soviet, cash: 0, bot_type: ''}
+  tools: [move_units, attack_unit, attack_move, stop]
+  planning: true
+  # React the instant contact happens or a tank is lost — combat micro
+  # is reactive; without these interrupts the focus-fire policy only
+  # re-targets on the next turn boundary and the trade leaks DPS in
+  # the gap between turns.
+  interrupts:
+    enemy_unit_spotted: true
+    own_unit_destroyed: true
+  termination: {max_ticks: 6000}
+  actors: []   # every level supplies its own actor list via overrides.
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────────
+  # Bare focus-fire skill: 3-vs-3 asymmetric mirror, survival bar ≥1
+  # (forgiving — even if focus-fire loses 2 tanks in the trade, ≥1
+  # alive suffices). Stall LOSES (kill bar unmet → after_ticks LOSS).
+  # Brute attack-move LOSES (drives into a 3-tank crossfire and force-
+  # wipes). Spread-fire MAY squeak by with 1 survivor (the documented
+  # inert-easy-teeth pattern); the strong spread-vs-focus
+  # discrimination is at medium.
+  easy:
+    description: >
+      Three medium tanks (2tnk, allies) at (30,19..21) face THREE
+      enemy medium tanks (2tnk, soviet) spread across three latitudes
+      at (50,15), (51,20), and (50,25). You must close to firing
+      range (cannon range ~5) and eliminate all three. By the
+      Lanchester square law, concentrating ALL THREE tanks' fire on
+      ONE enemy at a time (start with the closest — the centre at
+      (51,20) — kills it in 1-2 decision turns, then a flank, then
+      the last) preserves your force; letting each tank pick its own
+      closest target trades 1-for-1. Win when all 3 enemy tanks are
+      killed AND at least ONE of your tanks survives AND your base
+      is intact, before tick 2400.
+    overrides:
+      actors:
+        # Agent base anchor (paranoia gate against the turn-1
+        # own_units_gte mis-fire footgun, AND engine auto-done
+        # mitigation when the strike force loses all units).
+        - {type: fact, owner: agent, position: [4, 20]}
+        # Strike force — 3 medium tanks BUNCHED on a single column
+        # (one centroid). stance:1 ReturnFire so a stall policy never
+        # pulls a stray shot.
+        - {type: 2tnk, owner: agent, position: [30, 19], stance: 1}
+        - {type: 2tnk, owner: agent, position: [30, 20], stance: 1}
+        - {type: 2tnk, owner: agent, position: [30, 21], stance: 1}
+        # Enemy mirror — 3 medium tanks SPREAD across y=15/y=20/y=25.
+        # Centre at (51,20) NOT (50,20) per CLAUDE.md silent-fail
+        # cell note. stance:3 AttackAnything so they auto-fire the
+        # second an agent tank enters cannon range (the test is
+        # purely about the agent's target prioritization, not bot
+        # pursuit).
+        - {type: 2tnk, owner: enemy, position: [50, 15], stance: 3}
+        - {type: 2tnk, owner: enemy, position: [51, 20], stance: 3}
+        - {type: 2tnk, owner: enemy, position: [50, 25], stance: 3}
+        # Far persistent enemy fact — prevents engine auto-done on
+        # enemy-units-wipe before the win evaluator sees the terminal
+        # frame.
+        - {type: fact, owner: enemy, position: [124, 20]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 3}
+        - {own_units_gte: 1}
+        - {has_building: fact}
+        - {within_ticks: 2400}
+    fail_condition:
+      any_of:
+        - {after_ticks: 2401}
+        - {not: {own_units_gte: 1}}
+    max_turns: 30
+
+  # ── MEDIUM ──────────────────────────────────────────────────────────
+  # +1 controlled variable vs easy: tighten the survival bar to ≥2
+  # (any TWO tank losses fails). Geometry is identical (3-vs-3
+  # asymmetric mirror). At 3-vs-3 with the asymmetric spread, the
+  # SPREAD outcome empirically ends 1-of-3 tanks alive — busts
+  # own_units_gte:2 ⇒ LOSS. The FOCUS outcome keeps all 3 tanks
+  # alive ⇒ WIN. This is the load-bearing discrimination of the pack.
+  medium:
+    description: >
+      Three medium tanks (2tnk, allies) at (30,19..21) face THREE
+      enemy medium tanks (2tnk, soviet) spread across three latitudes
+      at (50,15), (51,20), and (50,25). By Lanchester's square law,
+      concentrating ALL THREE tanks' fire on ONE enemy at a time
+      (start with the closest — the centre at (51,20) — then the
+      flanks) preserves your force; spreading fire (each tank picks
+      its own closest enemy) trades 1-for-1 and busts the survival
+      bar. Win when all 3 enemy tanks are killed AND at least TWO of
+      your tanks survive AND your base is intact, before tick 2400.
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [4, 20]}
+        - {type: 2tnk, owner: agent, position: [30, 19], stance: 1}
+        - {type: 2tnk, owner: agent, position: [30, 20], stance: 1}
+        - {type: 2tnk, owner: agent, position: [30, 21], stance: 1}
+        - {type: 2tnk, owner: enemy, position: [50, 15], stance: 3}
+        - {type: 2tnk, owner: enemy, position: [51, 20], stance: 3}
+        - {type: 2tnk, owner: enemy, position: [50, 25], stance: 3}
+        - {type: fact, owner: enemy, position: [124, 20]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 3}
+        - {own_units_gte: 2}
+        - {has_building: fact}
+        - {within_ticks: 2400}
+    fail_condition:
+      any_of:
+        - {after_ticks: 2401}
+        - {not: {own_units_gte: 2}}
+    max_turns: 30
+
+  # ── HARD ────────────────────────────────────────────────────────────
+  # +2 controlled variables vs medium:
+  #   1. KILL-SPEED PRESSURE — within_ticks tightens from 2400 to
+  #      1200 (per the task-spec RELAXATION fallback: when the
+  #      survival-cap discriminator weakens on a flank spawn
+  #      because all enemies are co-linear from a flank perspective,
+  #      the kill-speed timer becomes the load-bearing
+  #      discriminator). Focus-fire ends the engagement in
+  #      ~700-1000 ticks (3 cannons on 1 target each turn); brute
+  #      drive-into-crossfire and stall both fail the clock.
+  #   2. TWO seed-driven spawn_point groups (NORTH staging y=11..13
+  #      vs SOUTH staging y=27..29) round-robined by seed so a
+  #      memorised single-target sequence cannot generalise. From
+  #      NORTH the closest enemy is (50,15) and farthest is (50,25);
+  #      from SOUTH the order inverts.
+  # The survival cap RELAXES to own_units_gte:1 on hard (per task
+  # brief): on a flank spawn the spread-fire policy naturally
+  # focus-fires the unique closest enemy, so the spread-vs-focus
+  # delta on hard is primarily kill-speed (within_ticks) rather
+  # than survivor count.
+  hard:
+    description: >
+      Three medium tanks (2tnk, allies) stage at ONE of two
+      staging corridors (NORTH y=11..13 OR SOUTH y=27..29, chosen
+      by seed, anti-memorisation), all bunched at x=30 on adjacent
+      rows. They face THREE enemy medium tanks (2tnk, soviet)
+      spread along the eastern line at (50,15), (51,20), and
+      (50,25). By Lanchester's square law, concentrating ALL THREE
+      tanks' fire on ONE enemy at a time (start with the closest,
+      then the next-closest, then the farthest) ends the
+      engagement fast and preserves your force. Win when all 3
+      enemy tanks are killed AND at least ONE of your tanks
+      survives AND your base is intact, before tick 1200 (kill-
+      speed pressure: stalling, driving into crossfire, or
+      anything slower than concentrated focus-fire busts the
+      clock).
+    overrides:
+      actors:
+        # Agent base anchor — duplicated under BOTH spawn_point
+        # groups because ANY agent actor with a spawn_point causes
+        # agent actors WITHOUT a spawn_point to be filtered out
+        # (CLAUDE.md / oramap.rs::expand_scenario_actors).
+        - {type: fact, owner: agent, position: [4, 20], spawn_point: 0}
+        - {type: fact, owner: agent, position: [4, 20], spawn_point: 1}
+        # spawn_point 0 — NORTH staging corridor (y=11..13). Bunched
+        # at x=30, three tanks on adjacent rows.
+        - {type: 2tnk, owner: agent, position: [30, 11], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [30, 12], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [30, 13], stance: 1, spawn_point: 0}
+        # spawn_point 1 — SOUTH staging corridor (y=27..29). Bunched
+        # at x=30.
+        - {type: 2tnk, owner: agent, position: [30, 27], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [30, 28], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [30, 29], stance: 1, spawn_point: 1}
+        # Enemy line — 3 tanks at y=15/y=20/y=25. Enemy actors don't
+        # honour spawn_point, so the SAME 3 enemy tanks place
+        # regardless of which agent spawn group is chosen.
+        - {type: 2tnk, owner: enemy, position: [50, 15], stance: 3}
+        - {type: 2tnk, owner: enemy, position: [51, 20], stance: 3}
+        - {type: 2tnk, owner: enemy, position: [50, 25], stance: 3}
+        - {type: fact, owner: enemy, position: [124, 20]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 3}
+        - {own_units_gte: 1}
+        - {has_building: fact}
+        - {within_ticks: 1200}
+    fail_condition:
+      any_of:
+        - {after_ticks: 1201}
+        - {not: {own_units_gte: 1}}
+    max_turns: 15

tests/test_combat_tank_vs_tank_engagement.py

@@ -0,0 +1,387 @@
+"""combat-tank-vs-tank-engagement — Mirror tank trade: focus-fire WINS,
+spread-fire (and brute attack_move, and stall) LOSE.
+
+The bar: intended FOCUS-fire WINS on every level and every hard seed
+(1-4); STALL and BRUTE attack_move LOSE on every level and every hard
+seed. SPREAD-fire (each tank picks its own closest enemy) LOSES on
+MEDIUM (the load-bearing discrimination: survival cap own_units_gte:2
+trips because spread bleeds 2 tanks in the asymmetric flank chase) —
+SPREAD is permitted to squeak by on EASY (own_units_gte:1, forgiving
+bare-skill tier per the SCENARIO_REVIEW_CHECKLIST inert-easy-teeth
+convention) and on HARD (the asymmetric geometry collapses spread to
+focus when the agent stack starts on a flank latitude — spread ≡
+focus when there's a unique closest enemy from a flank perspective;
+the hard discrimination is kill-speed + spawn-variation, not
+spread-vs-focus survivor count).
+
+Non-win is a real reachable timeout LOSS via the `after_ticks` fail
+clause (within_ticks 2400 + after_ticks 2401 on easy/medium with
+max_turns 30; within_ticks 1200 + after_ticks 1201 on hard with
+max_turns 15).
+
+Validation is scripted (no model / network).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import compile_level
+from openra_bench.scenarios.win_conditions import WinContext, evaluate
+
+PACKS = Path(__file__).parent.parent / "openra_bench" / "scenarios" / "packs"
+PACK_PATH = PACKS / "combat-tank-vs-tank-engagement.yaml"
+
+
+# ── unit-level predicate / metadata checks (no engine) ──────────────
+
+
+def test_pack_compiles_and_meta_fields_populated():
+    pack = load_pack(PACK_PATH)
+    assert pack.meta.id == "combat-tank-vs-tank-engagement"
+    assert pack.meta.capability == "action"
+    assert pack.meta.real_world_meaning, "real_world_meaning required"
+    assert pack.meta.robotics_analogue, "robotics_analogue required"
+    anchors = pack.meta.benchmark_anchor
+    assert isinstance(anchors, list) and len(anchors) == 3, (
+        f"benchmark_anchor must list all 3 anchors, got {anchors!r}"
+    )
+    joined = " ".join(anchors).lower()
+    for needle in ("sc2", "lanchester", "concentration"):
+        assert needle in joined, f"missing anchor keyword: {needle}"
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        assert c.map_supported
+        assert c.win_condition is not None
+        assert c.fail_condition is not None
+
+
+def _ctx(*, units=(), tick=1000, kills=0, lost=0, buildings=("fact",)):
+    """Synthesize a WinContext for predicate-level checks."""
+    import types
+
+    sig = types.SimpleNamespace(
+        game_tick=tick,
+        units_killed=kills,
+        units_lost=lost,
+        cash=0,
+        resources=0,
+        own_buildings=[{"type": b} for b in buildings],
+        own_building_types=set(buildings),
+        enemies_seen_ids=set(),
+        enemy_buildings_seen_ids=set(),
+    )
+    return WinContext(
+        signals=sig,
+        render_state={
+            "units_summary": list(units),
+            "buildings": [{"type": b} for b in buildings],
+        },
+    )
+
+
+def _alive(n):
+    return [
+        {"cell_x": 30, "cell_y": 20, "type": "2tnk", "id": str(1000 + i)}
+        for i in range(n)
+    ]
+
+
+def test_easy_predicates():
+    c = compile_level(load_pack(PACK_PATH), "easy")
+    # Intended focus: kills 3, 3 alive, in time → WIN
+    assert evaluate(c.win_condition, _ctx(units=_alive(3), tick=900, kills=3, lost=0))
+    # Spread allowed to squeak by on easy (own_units_gte:1, 1 survivor)
+    assert evaluate(c.win_condition, _ctx(units=_alive(1), tick=900, kills=3, lost=2))
+    # Kill bar unmet (only 2 kills) → not a win
+    assert not evaluate(c.win_condition, _ctx(units=_alive(3), tick=900, kills=2, lost=0))
+    # Force wipe → fail (own_units_gte:1 trips via fail clause)
+    assert evaluate(c.fail_condition, _ctx(units=[], tick=900, kills=3, lost=3))
+    # Timeout with bar unmet → fail (after_ticks 2401)
+    assert evaluate(c.fail_condition, _ctx(units=_alive(3), tick=2402, kills=2, lost=0))
+
+
+def test_medium_predicates():
+    c = compile_level(load_pack(PACK_PATH), "medium")
+    # Intended focus: kills 3, 3 alive (cap met at ≥2) → WIN
+    assert evaluate(c.win_condition, _ctx(units=_alive(3), tick=900, kills=3, lost=0))
+    # ≥2 alive (cap met) with 3 kills → WIN
+    assert evaluate(c.win_condition, _ctx(units=_alive(2), tick=900, kills=3, lost=1))
+    # Spread-fire: only 1 alive < 2 → not a win (cap busted)
+    assert not evaluate(c.win_condition, _ctx(units=_alive(1), tick=900, kills=3, lost=2))
+    # And the fail clause trips when own_units_gte:2 fails
+    assert evaluate(c.fail_condition, _ctx(units=_alive(1), tick=900, kills=3, lost=2))
+    # Force wipe → fail
+    assert evaluate(c.fail_condition, _ctx(units=[], tick=900, kills=3, lost=3))
+    # Timeout → fail
+    assert evaluate(c.fail_condition, _ctx(units=_alive(3), tick=2402, kills=2, lost=0))
+
+
+def test_hard_predicates():
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    # Intended focus: kills 3, 3 alive, within tight tick budget → WIN
+    assert evaluate(c.win_condition, _ctx(units=_alive(3), tick=900, kills=3, lost=0))
+    # 1 survivor (own_units_gte:1) with full kill bar → WIN
+    assert evaluate(c.win_condition, _ctx(units=_alive(1), tick=900, kills=3, lost=2))
+    # Kill bar unmet → not a win
+    assert not evaluate(c.win_condition, _ctx(units=_alive(3), tick=900, kills=2, lost=0))
+    # Outside tight tick budget (kills met but slow) → not a win
+    assert not evaluate(c.win_condition, _ctx(units=_alive(3), tick=1300, kills=3, lost=0))
+    # Force wipe → fail
+    assert evaluate(c.fail_condition, _ctx(units=[], tick=900, kills=3, lost=3))
+    # Timeout → fail (tight after_ticks 1201)
+    assert evaluate(c.fail_condition, _ctx(units=_alive(3), tick=1202, kills=2, lost=0))
+
+
+def test_timeout_reachable_inside_max_turns():
+    """No draw degeneracy: after_ticks ≤ 93 + 90·(max_turns-1)."""
+    pack = load_pack(PACK_PATH)
+    for lvl, want_after in [("easy", 2401), ("medium", 2401), ("hard", 1201)]:
+        c = compile_level(pack, lvl)
+        max_tick = 93 + 90 * (c.max_turns - 1)
+        assert want_after <= max_tick, (
+            f"{lvl}: after_ticks {want_after} > max reachable tick "
+            f"{max_tick} (max_turns={c.max_turns}); deadline never bites"
+        )
+
+
+def test_hard_has_two_spawn_point_groups():
+    """Hard-tier curation: ≥2 distinct agent spawn_point groups so the
+    seed round-robins the staging corridor (NORTH y=11..13 / SOUTH
+    y=27..29). Engine-roundtrip is asserted by tests/test_hard_tier.py."""
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    groups = {
+        (a.spawn_point if a.spawn_point is not None else 0)
+        for a in c.scenario.actors
+        if a.owner == "agent"
+    }
+    assert len(groups) >= 2, f"hard needs ≥2 spawn_point groups, got {groups}"
+
+
+def test_enemy_line_is_3_tanks_asymmetric_spread():
+    """The asymmetric geometry is the load-bearing physics — the
+    enemy line MUST be 3 tanks spread across three distinct
+    latitudes (the spread vs focus discrimination depends on each
+    enemy being independently targetable). Centre enemy at x=51 (not
+    x=50) per the CLAUDE.md silent-fail-cell note for (50,20)."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        enemy_tanks = [
+            a for a in c.scenario.actors
+            if a.owner == "enemy" and a.type == "2tnk"
+        ]
+        assert len(enemy_tanks) == 3, (
+            f"{lvl}: must have exactly 3 enemy tanks, got {len(enemy_tanks)}"
+        )
+        ys = sorted(a.position[1] for a in enemy_tanks)
+        assert len(set(ys)) == 3, (
+            f"{lvl}: enemy tanks must be on 3 distinct latitudes "
+            f"(asymmetric spread), got ys={ys}"
+        )
+        # Verify the (50,20) silent-fail cell is NOT used.
+        positions = [tuple(a.position) for a in enemy_tanks]
+        assert (50, 20) not in positions, (
+            f"{lvl}: (50,20) is a CLAUDE.md-documented silent-fail "
+            f"cell — centre enemy must be at (51,20). Got {positions}"
+        )
+        types = [a.type for a in c.scenario.actors if a.owner == "enemy"]
+        assert "fact" in types, f"{lvl}: needs a persistent enemy fact"
+
+
+def test_agent_strike_force_is_3_tanks_bunched():
+    """The agent strike force MUST be 3 medium tanks bunched on
+    adjacent rows at a single column (one centroid) — that bunched-
+    vs-spread asymmetry is what makes focus-fire load-bearing."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium"):
+        c = compile_level(pack, lvl)
+        agent_tanks = [
+            a for a in c.scenario.actors
+            if a.owner == "agent" and a.type == "2tnk"
+        ]
+        assert len(agent_tanks) == 3, (
+            f"{lvl}: must have exactly 3 agent tanks, got {len(agent_tanks)}"
+        )
+        xs = {a.position[0] for a in agent_tanks}
+        assert len(xs) == 1, (
+            f"{lvl}: agent tanks must be bunched on ONE column (same x), "
+            f"got xs={xs}"
+        )
+    # Hard: per-spawn-group bunching (each spawn_point has 3 tanks
+    # bunched on one column at a single latitude band).
+    c = compile_level(pack, "hard")
+    for sp in (0, 1):
+        agent_tanks = [
+            a for a in c.scenario.actors
+            if a.owner == "agent" and a.type == "2tnk" and a.spawn_point == sp
+        ]
+        assert len(agent_tanks) == 3, (
+            f"hard sp={sp}: must have 3 agent tanks, got {len(agent_tanks)}"
+        )
+        xs = {a.position[0] for a in agent_tanks}
+        assert len(xs) == 1, (
+            f"hard sp={sp}: agent tanks bunched on ONE column, got xs={xs}"
+        )
+
+
+# ── engine-driven scripted policies ─────────────────────────────────
+
+
+def _own_ids(rs):
+    return [str(u["id"]) for u in (rs.get("units_summary", []) or [])]
+
+
+def _enemy_tanks(rs):
+    out = []
+    for e in (rs.get("enemy_summary") or []):
+        t = (e.get("type") or e.get("actor_type") or "").lower()
+        if t == "2tnk":
+            out.append(e)
+    return out
+
+
+def _stall(rs, Command):
+    """Pure observe — tanks never close to firing range; nothing dies
+    either way ⇒ kill bar unmet ⇒ after_ticks LOSS."""
+    return [Command.observe()]
+
+
+def _brute_attack_move(rs, Command):
+    """Brute: every tank attack_moves toward the centre enemy. The
+    bunched stack drives into the 3-tank crossfire at the engagement
+    line; concentrated incoming fire kills ≥2 agent tanks ⇒ LOSS."""
+    own = _own_ids(rs)
+    if not own:
+        return [Command.observe()]
+    return [Command.attack_move(own, 51, 20)]
+
+
+def _spread_attack_closest(rs, Command):
+    """Spread: each agent tank attack_units ITS OWN nearest visible
+    enemy tank. With the asymmetric spread (3 enemies on three rows),
+    once the centre dies the surviving agent tanks chase different
+    flank enemies in 1-vs-1 duels — Lanchester linear law collapses
+    the trade to mutual annihilation, ending with 1-of-3 alive. On
+    MEDIUM (own_units_gte:2) this busts the survival cap ⇒ LOSS."""
+    own = _own_ids(rs)
+    if not own:
+        return [Command.observe()]
+    es = _enemy_tanks(rs)
+    if not es:
+        # No targets in sight — advance to contact.
+        return [Command.attack_move(own, 51, 20)]
+    cmds = []
+    for u in (rs.get("units_summary") or []):
+        uid = str(u["id"])
+        ux, uy = u["cell_x"], u["cell_y"]
+        es_sorted = sorted(
+            es, key=lambda e: (e["cell_x"] - ux) ** 2 + (e["cell_y"] - uy) ** 2
+        )
+        tid = es_sorted[0].get("id")
+        if tid is not None:
+            cmds.append(Command.attack_unit([uid], str(tid)))
+    return cmds or [Command.observe()]
+
+
+def _focus_fire(rs, Command):
+    """Focus-fire: ALL agent tanks attack_unit the SAME target each
+    turn — the closest enemy to the agent centroid. Once that enemy
+    falls, the policy automatically re-targets the next-closest. This
+    is the Lanchester-square-law optimal: concentrate N output on 1
+    target, remove that target's DPS, then repeat — combat-power
+    surplus grows quadratically with each kill."""
+    own = _own_ids(rs)
+    if not own:
+        return [Command.observe()]
+    es = _enemy_tanks(rs)
+    if not es:
+        return [Command.attack_move(own, 51, 20)]
+    us = rs.get("units_summary") or []
+    cx = sum(u["cell_x"] for u in us) / len(us)
+    cy = sum(u["cell_y"] for u in us) / len(us)
+    es.sort(key=lambda e: (e["cell_x"] - cx) ** 2 + (e["cell_y"] - cy) ** 2)
+    tid = es[0].get("id")
+    if tid is not None:
+        return [Command.attack_unit(own, str(tid))]
+    return [Command.attack_move(own, 51, 20)]
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_intended_focus_fire_wins(level, seed):
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _focus_fire, seed=seed)
+    assert r.outcome == "win", (
+        f"{level} seed={seed}: intended focus-fire should WIN, got "
+        f"{r.outcome} after {r.turns} turns "
+        f"(kills={r.signals.units_killed}, losses={r.signals.units_lost})"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_stall_loses(level, seed):
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _stall, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: stall must be a real timeout LOSS "
+        f"(no engagement → kill bar unmet → after_ticks fires), got "
+        f"{r.outcome}"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_brute_attack_move_loses(level, seed):
+    """Brute attack_move into the centre crosses through the 3-tank
+    crossfire and force-wipes the agent strike force on EASY (3 of 3
+    lost) ⇒ LOSS via not own_units_gte:1; on MEDIUM (2 lost) ⇒ LOSS
+    via not own_units_gte:2; on HARD (1-3 lost, but timing slow) ⇒
+    LOSS via the tight within_ticks 1200 + force-wipe."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _brute_attack_move, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: brute attack_move must LOSE (drive-into-"
+        f"crossfire force-wipe / tick budget bust), got {r.outcome} "
+        f"(kills={r.signals.units_killed}, losses={r.signals.units_lost})"
+    )
+
+
+@pytest.mark.parametrize("level", ["medium"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_spread_attack_closest_loses_on_medium(level, seed):
+    """Spread-attack-closest must LOSE on MEDIUM — the asymmetric
+    flank chase ends with 1-of-3 agent tanks alive (2 lost), busting
+    the survival cap own_units_gte:2. EASY is excluded as the bare-
+    skill tier (own_units_gte:1 lets the 1 survivor squeak by — the
+    documented SCENARIO_REVIEW_CHECKLIST inert-easy-teeth pattern).
+    HARD is excluded because the asymmetric geometry collapses
+    spread to focus when the agent stack starts on a flank latitude
+    (NORTH or SOUTH) — from a flank there is a unique closest enemy
+    that all 3 agent tanks naturally target (spread ≡ focus); the
+    hard discrimination is kill-speed + spawn-variation, not the
+    survivor-count delta."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _spread_attack_closest, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: spread-attack-closest must LOSE on "
+        f"medium (flank chase bleeds 2 tanks, own_units_gte:2 fails), "
+        f"got {r.outcome} (kills={r.signals.units_killed}, "
+        f"losses={r.signals.units_lost})"
+    )

tests/test_hard_tier.py

@@ -621,6 +621,20 @@ UPGRADED = [
     # equivalent column-vs-wedge decision from a flipped bearing — a
     # memorised "form wedge from y=14" opening cannot generalise.
     "combat-formation-tank-wedge",
+    # Wave-7 Group D combat-micro pack: SC2 mirror micro / Lanchester
+    # square law / concentration-of-force doctrine. ASYMMETRIC geometry
+    # (3 agent tanks bunched at (30,*) vs 3 enemy tanks spread across
+    # 3 latitudes at (50,15)/(51,20)/(50,25)) so focus-fire on the
+    # closest enemy preserves the force while spread-fire (each tank
+    # picks its own nearest enemy) collapses to Lanchester linear and
+    # loses 2 of 3 tanks (the load-bearing discrimination on medium).
+    # Hard tier defines two agent spawn_point groups (NORTH y=11..13 /
+    # SOUTH y=27..29) round-robined by seed; the enemy line always
+    # places (enemy actors don't honour spawn_point — CLAUDE.md) so
+    # both spawns face the same focus-fire decision from a flipped
+    # bearing. Hard discriminates via kill-speed (tight within_ticks
+    # 1200) + spawn-variation generalisation.
+    "combat-tank-vs-tank-engagement",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation