feat(scenario): combat-target-priority-highvalue — focus high-threat units first (SC2 focus-fire anchor)

openra_bench/scenarios/packs/combat-target-priority-highvalue.yaml

@@ -0,0 +1,345 @@
+# combat-target-priority-highvalue — ACTION capability: threat-weighted
+# target prioritization. A 4-tank squad faces a MIXED enemy cluster:
+# cheap rifle chaff (e1) plus THREE high-threat anti-armour rocket
+# soldiers (e3). The squad must FOCUS THE THREE ROCKET SOLDIERS FIRST
+# — they out-damage the chaff and whittle the squad below the survival
+# cap if left alive. Killing the chaff first leaves the rockets firing
+# through the whole engagement and the squad LOSES.
+#
+# Sibling of combat-focus-fire-priority (same SC2 focus-fire idiom);
+# THIS pack encodes the capability via a SURVIVAL floor
+# (`own_units_gte`) plus an explicit non-combat building anchor
+# (`building_count_gte:fact:1`) — the "preserve the squad" framing
+# rather than the "attrition cap" (`units_lost_lte`) framing. Same
+# anchor family, different predicate idiom.
+#
+# Discrimination (the four script-policy bar — verified deterministic
+# across seeds 1-4 on every level):
+#   • stall (only observe): the tanks idle at the staging edge and
+#     never close; the kill bar (units_killed_gte:K) is never met and
+#     the after_ticks fail clause fires → LOSS.
+#   • brute attack_move (attack-move onto the cluster centroid): the
+#     engine auto-targets the NEAREST hostile — the e1 chaff screen is
+#     posted three columns closer than the rocket soldiers, so the
+#     squad chews the chaff first while the three e3s fire anti-armour
+#     rockets through the whole engagement; all four tanks are lost
+#     → busts `own_units_gte` → LOSS.
+#   • kill-chaff-first (attack_unit the e1 chaff one at a time): the
+#     three e3 rockets keep landing through the entire chaff mop-up;
+#     ~3 tanks die before the rockets are silenced → busts the
+#     survival floor → LOSS.
+#   • intended focus-threats-first: attack_unit ALL FOUR tanks onto
+#     ONE e3 at a time — 4 tank cannons concentrate ~400 HP of armour
+#     against ~50 HP of infantry, so each e3 dies in 1-2 decision
+#     turns before it can land more than ~1 rocket; with all three
+#     rockets silenced inside the first ~3 turns the chaff cannot
+#     scratch the squad → mop up the e1s → kill bar met, the squad
+#     stays above the survival floor → WIN.
+#
+# Why the spec works (verified against the engine combat sheet):
+#   • e3 = anti-tank rocket soldier (Dragon launcher, range ~5, high
+#     anti-armour DPS). THREE e3 firing unopposed wipe a 4-tank squad
+#     in ~540 ticks (~6 decision turns) — measured. Left firing
+#     through a chaff mop-up they reliably kill ~3 tanks.
+#   • e1 = basic rifle infantry. Per-shot damage vs 2tnk armour is
+#     low; the e1 chaff alone cannot drop the squad below the floor
+#     inside the budget once the three e3s are dead.
+#   • 4× 2tnk concentrated on a single e3 kill it in 1-2 decision
+#     turns; the same fire SPREAD across the cluster kills the first
+#     e3 in 4+ turns, granting all three rockets free anti-tank
+#     shots. That focus-vs-spread delta is the discrimination.
+#   • Measured (deterministic): chaff-first loses 3 tanks, focus-
+#     threats-first loses 0, brute loses all 4, on every level.
+#
+# Engine guardrails:
+#   • Map: rush-hour-arena (128 × 40, playable x in [2..126], y in
+#     [2..38]). Tanks stage at x=48; the enemy cluster holds at
+#     x=66-70 (stance:2 Defend — a stationary wall, auto-fires in
+#     range but never advances, so the screen+rocket geometry is
+#     stable and the rockets fire the moment a tank is in range).
+#     The e1 screen is a COMPACT contiguous column so the whole
+#     cluster stays inside the tank squad's vision (no straggler
+#     slips into the fog and starves the kill count).
+#   • Agent `fact` at the staging edge — satisfies the win clause
+#     `building_count_gte:fact:1` (a non-combat anchor: the squad
+#     must still own its base while it focus-fires) AND, being an
+#     agent actor, keeps the agent side alive for the evaluator.
+#   • Far-east enemy `fact` at (120,20) prevents engine auto-done
+#     when the last cluster unit falls — the kill bar is satisfied on
+#     units, not buildings, so the marker keeps the episode running
+#     until the win/fail evaluator sees the terminal frame (no DRAW).
+#   • after_ticks/within_ticks reachable within max_turns
+#     (tick ≤ 93 + 90·(max_turns-1)); within_ticks 2700 < 2703 at
+#     max_turns 30; a staller hits after_ticks 2701 and LOSES.
+
+meta:
+  id: combat-target-priority-highvalue
+  title: 'Target Priority — Kill the High-Threat Units FIRST'
+  capability: action
+  real_world_meaning: >
+    Four medium tanks face a mixed enemy cluster at close range:
+    a screen of cheap rifle infantry (e1 chaff) backed by THREE
+    high-threat anti-armour rocket soldiers (e3). The decision is
+    threat-weighted target prioritization: concentrate ALL FOUR
+    tanks' fire on the rocket soldiers FIRST (each dies in 1-2
+    decision turns to 4-vs-1 fire, before it can land more than a
+    couple of anti-tank rockets), THEN mop up the chaff. Engaging
+    the chaff first — via attack_move auto-targeting the nearer
+    rifle screen, or by explicitly attacking the cheap infantry —
+    leaves the three rocket soldiers firing through the entire
+    mop-up and they whittle the squad below the survival floor.
+    A brute attack-move play and a kill-chaff-first play both LOSE;
+    the threat-first focus play WINS.
+  robotics_analogue: >
+    Military target prioritization under fire — when engaging a
+    mixed force, the high-threat asset (anti-armour weapon, AA
+    battery, command vehicle) is neutralised FIRST, even when it is
+    not the nearest target, because it out-damages the cheap escort.
+    Killing the low-threat chaff first lets the priority threat keep
+    firing and attrits the friendly force. Threat-weighted
+    engagement — not nearest-first — preserves the squad.
+  benchmark_anchor:
+    - "SC2 focus-fire target priority"
+    - "threat-weighted engagement"
+    - "military target prioritization"
+  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 policy only
+  # re-targets on the next turn boundary and the e3s get free shots.
+  interrupts:
+    enemy_unit_spotted: true
+    own_unit_destroyed: true
+  termination: {max_ticks: 6000}
+  actors: []
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Bare threat-priority skill: 4 tanks vs a cluster of 9 e1 chaff +
+  # 3 e3 high-threat. FORGIVING survival floor — the squad may lose
+  # one tank and still win (own_units_gte:3). A staller LOSES on the
+  # kill bar via after_ticks; a brute attack-move spreads onto the
+  # chaff and the three e3s wipe the squad; kill-chaff-first loses 3
+  # tanks to the rockets and busts the floor. Focus-threats-first
+  # keeps all four tanks → WIN.
+  easy:
+    description: >
+      Four medium tanks stage at x=48, y=18..21 with your
+      construction yard (fact) behind them at the west edge. To the
+      east is a mixed enemy cluster: a screen of NINE rifle infantry
+      (e1, cheap chaff) at x=66 backed by THREE rocket soldiers (e3,
+      anti-tank Dragon launcher — the high-threat units) at x=69.
+      Threat-priority doctrine: concentrate ALL FOUR tanks' fire on
+      ONE rocket soldier first (kill it in 1-2 decision turns), then
+      the second, then the third, THEN mop up the rifle chaff.
+      Engaging the chaff first leaves the rocket soldiers firing
+      anti-tank rockets through the whole mop-up and they pick off
+      your tanks. Win when 12 enemy units are killed AND at least 3
+      tanks survive AND your construction yard still stands, before
+      tick 2700.
+    overrides:
+      actors:
+        # Strike force — 4 medium tanks staging mid-west.
+        - {type: 2tnk, owner: agent, position: [48, 18], stance: 1}
+        - {type: 2tnk, owner: agent, position: [48, 19], stance: 1}
+        - {type: 2tnk, owner: agent, position: [48, 20], stance: 1}
+        - {type: 2tnk, owner: agent, position: [48, 21], stance: 1}
+        # Agent construction yard — the non-combat win anchor
+        # (building_count_gte:fact:1); also keeps the agent side
+        # alive for the evaluator.
+        - {type: fact, owner: agent, position: [4, 20]}
+        # Enemy cluster — a COMPACT contiguous screen of NINE cheap
+        # rifle infantry along x=66, y=15..23 (the NEAREST hostiles
+        # ⇒ engine auto-target picks them under attack_move) backed
+        # by THREE rocket soldiers at x=69, inside Dragon range 5 of
+        # the front line. stance:2 (Defend) — the cluster holds as a
+        # stationary wall and auto-fires the moment a tank is in
+        # range. The column is compact so the whole cluster stays in
+        # the tank squad's vision (no straggler hides in the fog).
+        - {type: e1, owner: enemy, position: [66, 15], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 16], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 17], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 18], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 19], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 20], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 21], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 22], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 23], stance: 2}
+        # THREE rocket soldiers — the high-threat units. Tucked
+        # behind the chaff screen at x=69 (3 cells back ⇒ not the
+        # nearest target, so attack_move auto-picks the chaff) but
+        # still inside Dragon range 5 once the tanks reach contact.
+        - {type: e3, owner: enemy, position: [69, 19], stance: 2}
+        - {type: e3, owner: enemy, position: [69, 20], stance: 2}
+        - {type: e3, owner: enemy, position: [69, 21], stance: 2}
+        # Far persistent enemy marker — prevents engine auto-done
+        # when the cluster falls so the evaluator sees the terminal
+        # frame (no DRAW collapse).
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 12}
+        - {own_units_gte: 3}
+        - {within_ticks: 2700}
+        - {building_count_gte: {type: fact, n: 1}}
+    # Fail floor aligned to the win floor (own_units_gte:3) — a squad
+    # at own=2 is a real LOSS, not a dead-zone DRAW. easy still
+    # FORGIVES one tank lost (own=3 wins); the kill-chaff-first play
+    # drops to own≤2 and LOSES here.
+    fail_condition:
+      any_of:
+        - {after_ticks: 2701}
+        - {not: {own_units_gte: 3}}
+    max_turns: 30
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 axis vs easy: a TIGHTER survival floor — the squad must keep
+  # ALL FOUR tanks alive (own_units_gte:4, zero loss). The cluster is
+  # the same 9 e1 + 3 e3; the controlled variable is purely the
+  # zero-loss floor. A brute and a kill-chaff-first play both LOSE:
+  # the three e3s firing through the chaff mop-up score ~3 tank kills
+  # and bust the zero-loss floor. The intended focus-threats-first
+  # WINS — concentrating all four tanks on each rocket soldier in
+  # turn ends it in 1-2 decision ticks before it can land more than
+  # ~1 rocket, preserving the whole squad.
+  medium:
+    description: >
+      Four medium tanks stage at x=48, y=18..21 with your
+      construction yard behind them. The eastern enemy cluster is a
+      compact screen of NINE rifle infantry (e1, cheap chaff) at
+      x=66 backed by THREE rocket soldiers (e3, anti-tank Dragon
+      launcher — the high-threat units) at x=69. Threat-priority
+      doctrine: concentrate ALL FOUR tanks' fire on ONE rocket
+      soldier first (kill in 1-2 decision turns), then the second,
+      then the third, THEN mop up the rifle chaff. Engaging the
+      chaff first — via attack_move auto-targeting the nearer rifle
+      screen, or by attacking the cheap infantry first — leaves the
+      rocket soldiers firing through the entire mop-up and they kill
+      your tanks. Win when 12 enemy units are killed AND all four
+      tanks survive AND your construction yard still stands, before
+      tick 2700.
+    overrides:
+      actors:
+        - {type: 2tnk, owner: agent, position: [48, 18], stance: 1}
+        - {type: 2tnk, owner: agent, position: [48, 19], stance: 1}
+        - {type: 2tnk, owner: agent, position: [48, 20], stance: 1}
+        - {type: 2tnk, owner: agent, position: [48, 21], stance: 1}
+        - {type: fact, owner: agent, position: [4, 20]}
+        # Compact contiguous screen of NINE cheap rifle infantry
+        # along x=66, y=15..23 (engine auto-target picks the nearest
+        # hostile under attack_move).
+        - {type: e1, owner: enemy, position: [66, 15], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 16], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 17], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 18], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 19], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 20], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 21], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 22], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 23], stance: 2}
+        # THREE rocket soldiers behind the chaff screen at x=69 —
+        # inside Dragon range 5 of the contact line, not the nearest
+        # target (e1s at x=66 are 3 cells closer ⇒ engine auto-
+        # target picks the chaff under attack_move). With 3 e3s
+        # firing through the chaff mop-up a brute or chaff-first
+        # play takes ~3 tank kills and busts the zero-loss floor.
+        - {type: e3, owner: enemy, position: [69, 19], stance: 2}
+        - {type: e3, owner: enemy, position: [69, 20], stance: 2}
+        - {type: e3, owner: enemy, position: [69, 21], stance: 2}
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 12}
+        - {own_units_gte: 4}
+        - {within_ticks: 2700}
+        - {building_count_gte: {type: fact, n: 1}}
+    # Fail floor aligned to the zero-loss win floor (own_units_gte:4)
+    # — any tank lost (own≤3) is a real LOSS, not a dead-zone DRAW.
+    fail_condition:
+      any_of:
+        - {after_ticks: 2701}
+        - {not: {own_units_gte: 4}}
+    max_turns: 30
+
+  # ── HARD ────────────────────────────────────────────────���────────
+  # +1 axis vs medium: the strike force (and its construction yard)
+  # stage from TWO seed-driven spawn_point groups (NORTH corridor
+  # y=10..13 OR SOUTH corridor y=27..30) so the engagement geometry
+  # varies per seed. The chaff screen (10 e1, y=15..24) + rocket trio
+  # is symmetric across y=20 — both spawns face the same priority
+  # decision (focus one e3 → next → next → mop up chaff). The
+  # zero-loss survival floor from medium is retained.
+  hard:
+    description: >
+      Four medium tanks stage at ONE of two corridors (NORTH
+      y=10..13 OR SOUTH y=27..30, chosen by seed, anti-
+      memorisation) with your construction yard behind them. The
+      eastern enemy cluster is a compact screen of TEN rifle
+      infantry (e1, cheap chaff) at x=66 backed by THREE rocket
+      soldiers (e3, anti-tank — the high-threat units) at x=69.
+      Threat-priority doctrine: concentrate ALL FOUR tanks on ONE
+      rocket soldier at a time — kill it cleanly, then the next,
+      then the third, THEN mop up the rifle chaff. Starting on the
+      rifle chaff leaves the rockets firing through the whole
+      engagement and they kill your tanks. Win when 13 enemy units
+      are killed AND all four tanks survive AND your construction
+      yard still stands, before tick 2700.
+    overrides:
+      actors:
+        # spawn_point 0 — NORTH staging corridor (y=10..13).
+        - {type: 2tnk, owner: agent, position: [48, 10], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [48, 11], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [48, 12], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [48, 13], stance: 1, spawn_point: 0}
+        - {type: fact, owner: agent, position: [4, 11], spawn_point: 0}
+        # spawn_point 1 — SOUTH staging corridor (y=27..30).
+        - {type: 2tnk, owner: agent, position: [48, 27], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [48, 28], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [48, 29], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [48, 30], stance: 1, spawn_point: 1}
+        - {type: fact, owner: agent, position: [4, 29], spawn_point: 1}
+        # Compact contiguous screen of TEN cheap rifle infantry along
+        # x=66, y=15..24 — symmetric across y=19.5 so either spawn
+        # faces an equivalent decision. Engine auto-target picks the
+        # nearest hostile under attack_move ⇒ this chaff line is what
+        # a brute engages first.
+        - {type: e1, owner: enemy, position: [66, 15], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 16], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 17], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 18], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 19], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 20], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 21], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 22], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 23], stance: 2}
+        - {type: e1, owner: enemy, position: [66, 24], stance: 2}
+        # THREE rocket soldiers behind the chaff screen at x=69 —
+        # inside Dragon range 5 of the contact line, symmetric across
+        # y=20 so either spawn faces an equivalent focus-fire
+        # decision. Starting on the chaff lets all three fire through
+        # the whole mop-up and bust the zero-loss floor.
+        - {type: e3, owner: enemy, position: [69, 19], stance: 2}
+        - {type: e3, owner: enemy, position: [69, 20], stance: 2}
+        - {type: e3, owner: enemy, position: [69, 21], stance: 2}
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 13}
+        - {own_units_gte: 4}
+        - {within_ticks: 2700}
+        - {building_count_gte: {type: fact, n: 1}}
+    # Fail floor aligned to the zero-loss win floor (own_units_gte:4)
+    # — any tank lost (own≤3) is a real LOSS, not a dead-zone DRAW.
+    fail_condition:
+      any_of:
+        - {after_ticks: 2701}
+        - {not: {own_units_gte: 4}}
+    max_turns: 30

tests/test_combat_target_priority_highvalue.py

@@ -0,0 +1,206 @@
+"""combat-target-priority-highvalue pack — full no-cheat validation.
+
+Wave-11 ACTION pack: threat-weighted target prioritization (SC2
+focus-fire target priority / military target prioritization anchor).
+A 4-tank squad faces a mixed enemy cluster — a screen of cheap rifle
+chaff (e1) backed by THREE high-threat anti-armour rocket soldiers
+(e3). The squad must FOCUS THE ROCKET SOLDIERS FIRST: 4-vs-1
+concentrated fire deletes each e3 in 1-2 decision turns before it can
+land more than ~1 rocket. Killing the chaff first leaves all three
+rockets firing through the entire mop-up and they whittle the squad
+below the survival floor.
+
+Win = units_killed_gte:K AND own_units_gte:F AND within_ticks:2700
+AND building_count_gte:fact:1 (a non-combat anchor: the squad must
+still own its construction yard while it focus-fires). Fail floors
+are aligned to the win floor so every non-timeout outcome is a real
+WIN or LOSS — no dead-zone DRAW.
+
+Bar (per CLAUDE.md), verified deterministic across seeds 1-4 on
+every level:
+  • stall (observe only)   → LOSS every level/seed (after_ticks).
+  • brute attack_move      → LOSS (auto-targets the chaff screen;
+    the three e3s wipe the squad).
+  • kill-chaff-first       → LOSS (rockets fire through the chaff
+    mop-up and bust the survival floor).
+  • focus-threats-first    → WIN every level/seed (all three e3s
+    silenced inside the first ~3 turns, squad preserved).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("openra_train", 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 / "combat-target-priority-highvalue.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+# enemy cluster advance target — the chaff column, mid-y.
+_ADV = (66, 20)
+
+
+# ── helpers ───────────────────────────────────────────────────────
+
+
+def _tank_ids(obs):
+    return [
+        str(u["id"])
+        for u in (obs.get("units_summary") or [])
+        if str(u.get("type", "")).lower() == "2tnk"
+    ]
+
+
+def _enemy_units(obs):
+    """(id, type) for every visible enemy combat unit."""
+    out = []
+    for e in (obs.get("enemy_summary") or []):
+        t = str(e.get("type", "")).lower()
+        if t in ("e1", "e3"):
+            out.append((str(e.get("id")), t))
+    return out
+
+
+# ── policies ──────────────────────────────────────────────────────
+
+
+def _stall_policy():
+    """Do nothing — the kill bar is never met, after_ticks LOSS."""
+    def pol(obs, Cmd):
+        return [Cmd.observe()]
+    return pol
+
+
+def _brute_policy():
+    """attack_move onto the cluster centroid — the engine auto-targets
+    the NEAREST hostile (the chaff screen), so the three e3s fire
+    through the whole engagement and wipe the squad."""
+    def pol(obs, Cmd):
+        ids = _tank_ids(obs)
+        if not ids:
+            return [Cmd.observe()]
+        es = [
+            e for e in (obs.get("enemy_summary") or [])
+            if str(e.get("type", "")).lower() in ("e1", "e3")
+        ]
+        if es:
+            cx = sum(e["cell_x"] for e in es) // len(es)
+            cy = sum(e["cell_y"] for e in es) // len(es)
+            return [Cmd.attack_move(ids, cx, cy)]
+        return [Cmd.attack_move(ids, _ADV[0], _ADV[1])]
+    return pol
+
+
+def _focus_policy(first: str):
+    """attack_unit, prioritising the `first` unit type. first='e1' is
+    the kill-chaff-first trap; first='e3' is the intended threat-first
+    focus play."""
+    def pol(obs, Cmd):
+        ids = _tank_ids(obs)
+        if not ids:
+            return [Cmd.observe()]
+        es = _enemy_units(obs)
+        prio = [e for e in es if e[1] == first]
+        rest = [e for e in es if e[1] != first]
+        if prio:
+            return [Cmd.attack_unit(ids, prio[0][0])]
+        if rest:
+            return [Cmd.attack_unit(ids, rest[0][0])]
+        # no enemy in view — close to contact range.
+        return [Cmd.attack_move(ids, _ADV[0], _ADV[1])]
+    return pol
+
+
+# ── tests ─────────────────────────────────────────────────────────
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", SEEDS)
+def test_stall_loses(level, seed):
+    """A do-nothing policy must LOSE on the deadline — no draw."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _stall_policy(), seed=seed)
+    assert res.outcome == "loss", (
+        f"{level}/seed{seed}: stall must LOSE, got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", SEEDS)
+def test_brute_attack_move_loses(level, seed):
+    """A brute attack-move play auto-targets the chaff screen; the
+    three rocket soldiers fire through the engagement and wipe the
+    squad — a real LOSS, not a draw."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _brute_policy(), seed=seed)
+    assert res.outcome == "loss", (
+        f"{level}/seed{seed}: brute must LOSE, got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", SEEDS)
+def test_kill_chaff_first_loses(level, seed):
+    """Explicitly attacking the cheap e1 chaff first leaves the three
+    rockets firing through the whole mop-up; the squad drops below the
+    survival floor — a real LOSS."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _focus_policy("e1"), seed=seed)
+    assert res.outcome == "loss", (
+        f"{level}/seed{seed}: kill-chaff-first must LOSE, got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", SEEDS)
+def test_focus_threats_first_wins(level, seed):
+    """The intended capability — concentrate all four tanks on the
+    rocket soldiers FIRST — must WIN every level and seed."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _focus_policy("e3"), seed=seed)
+    assert res.outcome == "win", (
+        f"{level}/seed{seed}: focus-threats-first must WIN, got {res.outcome}"
+    )
+
+
+def test_hard_agent_spawn_axis_has_two_groups():
+    """The hard tier must define ≥2 agent-side spawn_point groups
+    (the seed-driven staging-corridor axis); the strike force and its
+    construction yard are duplicated under each group."""
+    c = compile_level(load_pack(PACK), "hard")
+    agent_sps = {
+        a.spawn_point
+        for a in c.scenario.actors
+        if a.owner == "agent" and a.spawn_point is not None
+    }
+    assert len(agent_sps) >= 2, (
+        f"hard needs ≥2 agent spawn_point groups, got {sorted(agent_sps)}"
+    )
+
+
+def test_tick_budget_alignment():
+    """within_ticks / after_ticks must be reachable inside max_turns
+    (tick ≤ 93 + 90·(max_turns-1)) so the deadline actually bites."""
+    for level in LEVELS:
+        c = compile_level(load_pack(PACK), level)
+        max_tick = 93 + 90 * (c.max_turns - 1)
+        win_clauses = c.win_condition.all_of or []
+        within = next(
+            (cl["within_ticks"] for cl in win_clauses if "within_ticks" in cl),
+            None,
+        )
+        assert within is not None and within <= max_tick, (
+            f"{level}: within_ticks {within} not reachable by {max_tick}"
+        )
+        fail_clauses = c.fail_condition.any_of or []
+        after = next(
+            (cl["after_ticks"] for cl in fail_clauses if "after_ticks" in cl),
+            None,
+        )
+        assert after is not None and after <= max_tick, (
+            f"{level}: after_ticks {after} not reachable by {max_tick}"
+        )