feat(scenario): combat-pincer-coordination — synchronized two-prong attack (SC2 / military pincer anchor)

Wave-6 Group N coordination pack — SC2 multi-prong / two-prong attack
timing, military pincer movement doctrine, envelopment from multiple
angles, synchronisation of dispersed forces.

Two 3-tank squads (3× 2tnk each) start on the SAME west edge at
OPPOSING latitudes (north y=8, south y=32). A central enemy cluster
sits at the mid-map (around (50,20)). The win predicate REQUIRES both
squads to engage simultaneously:

- units_in_region_gte:{x:50,y:20,radius:8,n:4} — a single squad has
only 3 tanks so single-squad-A cannot satisfy the region clause
regardless of attrition (structural pincer teeth).
- units_lost_lte:2 — sequenced (A first, B late) is shredded by the
cluster's anti-armour mass (2× 2tnk + 2× e3 + 4× e1) and loses ≥3
tanks before B arrives → busts the cap (timing teeth).
- within_ticks:4500 / after_ticks:4501 (max_tick=4863 with
max_turns:54 — deadline bites, no DRAW degeneracy) — stall hits
the deadline.

Difficulty axis (one new controlled variable per tier):
- easy: lighter cluster (4× e1 + 2× e3, no enemy armour; kill bar 6).
Sequenced may squeak by here per the inert-easy-teeth
convention; stall + single-squad still LOSE.
- medium: full cluster (4× e1 + 2× e3 + 2× 2tnk = 8 enemies; kill
bar 8). Sequenced now LOSES on the attrition cap.
- hard: +2 seed-driven agent spawn_point groups (group 0:
(5,8)/(5,32); group 1: (3,5)/(3,35)) so a memorised
single-cell opening cannot generalise; cluster symmetric
across y=20 so both spawns face the same pincer decision.

Engine guardrails (per CLAUDE.md):
- Enemy cluster anchored at (50,19) / (50,21) — avoids the (50,20)
silent-no-place footgun; win region (50,20, r=8) still covers
both halves.
- Far persistent enemy fact at (120,4) keeps the episode alive past
full cluster elimination so within_ticks / region predicates
evaluate on the terminal frame (engine auto-done mitigation).
- All agent actors declare spawn_point on hard (CLAUDE.md: 'if ANY
agent actor declares spawn_point, every agent actor WITHOUT
spawn_point is filtered OUT'); two full layouts listed explicitly.

Scripted-policy validation (tests/test_combat_pincer_coordination.py
covers all 4 seeds per level on every policy):
- stall → LOSS on every level/seed (clock).
- single-squad-A → LOSS on every level/seed (region n=4).
- sequenced-A-then-B-late → LOSS on medium/hard every seed (cap).
- intended pincer-sync → WIN on every level/seed (0 losses).

Model smoke (Qwen/Qwen3.6-Plus, medium, seed 1):
combat-pincer-coordination:medium:public#1 loss comp=0.2187
(expected discrimination — pack is meant to detect synchronization)

Registered in tests/test_hard_tier.py::UPGRADED.

openra_bench/scenarios/packs/combat-pincer-coordination.yaml

@@ -0,0 +1,299 @@
+# combat-pincer-coordination.yaml
+#
+# ACTION capability — synchronised two-prong pincer attack. Two armoured
+# squads start on the SAME west edge but at OPPOSING latitudes
+# (north y≈8 and south y≈32). A central enemy cluster sits at the mid-
+# map. The win predicate requires BOTH squads to engage simultaneously:
+# `units_in_region_gte:{n:4}` cannot be satisfied by a single squad
+# (only 3 tanks per squad — even arriving intact is 1 short of n=4),
+# and `units_lost_lte:2` makes a serialised "Squad A engages first,
+# Squad B follows" attempt fail because A is shredded by the cluster
+# before B arrives.
+#
+# Real-world anchor: military pincer movement / SC2 two-prong attack /
+# envelopment from two directions. The capability is the timing
+# coordination — both prongs must commit at the same moment so the
+# defender cannot focus on either prong in detail.
+#
+# Engine notes (per CLAUDE.md):
+#   - Enemy cluster anchored at (50,19) / (50,21) — CLAUDE.md warns
+#     that (50,20) silently fails to place enemy clusters; the off-by-
+#     one cells are confirmed working. The win region centre at
+#     (50,20) r=8 still covers both halves of the cluster (and both
+#     ingress tanks once they engage the cluster face).
+#   - Far persistent enemy `fact` at (120,4) keeps the episode alive
+#     past full enemy elimination so within_ticks / region predicates
+#     evaluate on the terminal frame (engine auto-`done` would
+#     otherwise collapse to DRAW the instant the last MustBeDestroyed
+#     enemy actor falls).
+#   - `units_killed_gte: 8` matches the central-cluster enemy count
+#     on medium/hard (the far sentinel fact at (120,4) is OUT of all
+#     squad routes so it survives and never counts toward kills);
+#     easy uses a lighter 6-enemy cluster with kill bar 6.
+#   - Enemy stance:3 (AttackAnything) so the cluster fires on any
+#     tank in range from the instant of contact — no bot_type needed.
+#     For the squad-A-then-B-late timing teeth, the enemy 2× 2tnk +
+#     2× e3 anti-armour mass MUST be sufficient to shred a 3-tank
+#     squad arriving alone (~12s to clear with 3 attackers = ~800
+#     damage absorbed = 2+ tanks lost on the lone squad). With both
+#     squads synchronised the same cluster falls in ~6s and the
+#     6-tank force loses ≤1 tank — well inside the
+#     `units_lost_lte: 2` cap and with ≥4 tanks (in fact ≥5) inside
+#     the central region.
+#   - Tick budget: 4500 within / 4501 fail. With max_turns 54 the max
+#     reachable tick is 93 + 90·53 = 4863 → the `after_ticks` clause
+#     fires before the run ends → no DRAW degeneracy.
+#
+# Discrimination (the four-script bar; scripted-policy validation in
+# tests/test_combat_pincer_coordination.py covers all 4 seeds per
+# level on every policy):
+#   • stall (Command.observe only) — agent units never engage → kill
+#     bar unmet → after_ticks LOSS.
+#   • single-squad-A — Squad B held back; A walks alone into the
+#     cluster. Even if A clears the cluster, only 3 tanks (max) can
+#     occupy the objective region while n=4 is required → LOSS. On
+#     medium/hard A is also shredded by the cluster's anti-armour →
+#     units_lost_lte:2 busts as a second teeth.
+#   • sequenced-A-then-B-late — A advances first, takes attrition,
+#     B follows after a long delay. On medium/hard A loses 3 of 3
+#     tanks before B arrives → units_lost_lte:2 busts → LOSS. On
+#     easy with no enemy armour A may clear cleanly and B walks in →
+#     this may squeak by (acceptable per SCENARIO_REVIEW_CHECKLIST
+#     inert-easy-teeth convention — easy is the bare-skill tier).
+#   • intended pincer-sync — both squads attack_move the cluster on
+#     turn 1; their staging latitudes (y=8, y=32) put them
+#     equidistant (~45 cells each) from the cluster so a naive
+#     simultaneous launch arrives together; mass DPS clears the
+#     cluster before either side bleeds → WIN.
+#
+# Validate:
+#   cd /Users/berta/Projects/OpenRA-Bench && \
+#   python3 -m openra_bench.scenarios.validate \
+#     openra_bench/scenarios/packs/combat-pincer-coordination.yaml
+
+meta:
+  id: combat-pincer-coordination
+  title: 'Pincer Attack — Two Squads Strike Simultaneously From Two Sides'
+  capability: action
+  real_world_meaning: >
+    Two armoured squads start at OPPOSING latitudes on the west edge
+    (one to the north, one to the south) and must converge on a
+    central enemy cluster simultaneously, hitting the defender from
+    two sides at once. Sending a single squad alone fails on two
+    counts: only 3 tanks (not the required 4) can occupy the
+    objective region, and the lone squad is shredded by the cluster's
+    mass anti-armour before clearing it. Sending both squads but not
+    synchronised (one held back, the other commits first) lets the
+    cluster focus on the lead squad and destroy it before the trailing
+    squad arrives, busting the attrition cap. Only a true
+    simultaneous two-prong commit clears the cluster cleanly and
+    leaves the joint force standing on the objective.
+  robotics_analogue: >
+    Synchronous two-team pincer attack on a contested objective: each
+    team approaches on a different bearing and both must arrive within
+    a common window so the defending agents cannot focus on either
+    team in detail. Serialising one team behind the other lets the
+    defender concentrate fire and destroy the lead team before
+    reinforcement; only the joint simultaneous commit overwhelms
+    the defence and preserves the strike force.
+  benchmark_anchor:
+    - "SC2 multi-prong / two-prong attack timing"
+    - "military pincer movement doctrine"
+    - "envelopment from multiple angles"
+    - "synchronisation of dispersed forces"
+  author: openra-bench
+
+base_map: rush-hour-arena
+
+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 — pincer
+  # micro is reactive; without these interrupts the sync policy only
+  # re-targets on the next turn boundary and any gap is fatal to the
+  # already-thin attrition cap.
+  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 pincer skill: lighter cluster (4× e1 + 2× e3, no enemy
+  # armour; 6 enemies total, kill bar 6). Stall still LOSES on the
+  # clock; single-squad still LOSES on the region predicate (3 tanks
+  # cannot satisfy n=4). Sequenced may squeak by on this lighter
+  # cluster — that is the SCENARIO_REVIEW_CHECKLIST "inert anti-
+  # cheat teeth acceptable on easy" convention: the bare-skill tier
+  # only enforces stall-loses and intended-wins; the sequence-vs-
+  # sync delta lives on medium and hard.
+  easy:
+    description: >
+      You command TWO squads of medium tanks (3× 2tnk each, 6 tanks
+      total). Squad A stages at the NORTH-WEST corner (5,8); Squad B
+      stages at the SOUTH-WEST corner (5,32). A central enemy cluster
+      sits at the mid-map (around (50,20)): 4 rifle infantry (e1) +
+      2 anti-tank rocket soldiers (e3). Both squads must converge on
+      the cluster SIMULTANEOUSLY from the north and the south
+      (a pincer). Win when you have killed 6 enemies AND at least 4
+      of your 6 tanks are inside an 8-cell radius of (50,20) AND no
+      more than 2 tanks are lost, before tick 4500. Sending only one
+      squad cannot satisfy the 4-in-region clause. A stall loses on
+      the clock.
+    overrides:
+      actors:
+        # Squad A (NORTH-WEST) — 3 medium tanks at (5,8).
+        - {type: 2tnk, owner: agent, position: [5, 8],  stance: 1, count: 3}
+        # Squad B (SOUTH-WEST) — 3 medium tanks at (5,32).
+        - {type: 2tnk, owner: agent, position: [5, 32], stance: 1, count: 3}
+        # Enemy cluster — anchored at (50,19) / (50,21) (CLAUDE.md
+        # notes (50,20) silently fails to place enemy clusters; the
+        # off-by-one cells work). The win region (50,20, r=8) still
+        # covers both halves.
+        - {type: e1, owner: enemy, position: [50, 19], stance: 3, count: 2}
+        - {type: e1, owner: enemy, position: [50, 21], stance: 3, count: 2}
+        - {type: e3, owner: enemy, position: [50, 19], stance: 3}
+        - {type: e3, owner: enemy, position: [50, 21], stance: 3}
+        # Far persistent enemy marker (sentinel) — out of every
+        # squad route, keeps the episode alive past full cluster
+        # elimination so within_ticks / region predicates evaluate
+        # on the terminal frame (no DRAW collapse).
+        - {type: fact, owner: enemy, position: [120, 4]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 6}
+        - {units_in_region_gte: {x: 50, y: 20, radius: 8, n: 4}}
+        - {units_lost_lte: 2}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {units_lost_lte: 2}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 54
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 controlled variable: full enemy cluster — 4× e1 + 2× e3 +
+  # 2× 2tnk (8 enemies total; kill bar = 8). The enemy armour gives
+  # the cluster enough sustained anti-armour DPS to shred a lone
+  # 3-tank squad (~12s to clear, ~800 damage absorbed) → A-only or
+  # A-then-B-late busts units_lost_lte:2. The 6-tank synchronised
+  # commit halves the clear time and the per-tank damage share, so
+  # the sync wins comfortably (validated: 0 losses on every seed).
+  medium:
+    description: >
+      You command TWO squads of medium tanks (3× 2tnk each, 6 tanks
+      total). Squad A stages at the NORTH-WEST corner (5,8); Squad B
+      stages at the SOUTH-WEST corner (5,32). A central enemy cluster
+      sits at the mid-map (around (50,20)): 4 rifle infantry (e1) +
+      2 anti-tank rocket soldiers (e3, Dragon launcher) + 2 medium
+      tanks (2tnk) — the enemy armour gives the cluster enough
+      sustained anti-armour DPS to shred a lone 3-tank squad before
+      it can clear the cluster. Both squads must converge
+      SIMULTANEOUSLY (a pincer): attack-moving with both squads at
+      once on turn 1 doubles the strike force and halves the per-tank
+      damage share, clearing the cluster before either side bleeds
+      out. Sending only one squad cannot satisfy the 4-in-region
+      clause; sending A first and B late lets the cluster shred A
+      before B arrives. Win when you have killed 8 enemies AND at
+      least 4 of your 6 tanks are inside an 8-cell radius of (50,20)
+      AND no more than 2 tanks are lost, before tick 4500.
+    overrides:
+      actors:
+        - {type: 2tnk, owner: agent, position: [5, 8],  stance: 1, count: 3}
+        - {type: 2tnk, owner: agent, position: [5, 32], stance: 1, count: 3}
+        # 4× e1 + 2× e3 + 2× 2tnk = 8 enemies. Avoid the (50,20) cell
+        # (CLAUDE.md silent-no-place footgun); split between (50,19)
+        # and (50,21). The enemy 2tnks are the load-bearing anti-
+        # armour that shreds a lone 3-tank squad arriving alone.
+        - {type: e1, owner: enemy, position: [50, 19], stance: 3, count: 2}
+        - {type: e1, owner: enemy, position: [50, 21], stance: 3, count: 2}
+        - {type: e3, owner: enemy, position: [50, 19], stance: 3}
+        - {type: e3, owner: enemy, position: [50, 21], stance: 3}
+        - {type: 2tnk, owner: enemy, position: [50, 19], stance: 3}
+        - {type: 2tnk, owner: enemy, position: [50, 21], stance: 3}
+        - {type: fact, owner: enemy, position: [120, 4]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 8}
+        - {units_in_region_gte: {x: 50, y: 20, radius: 8, n: 4}}
+        - {units_lost_lte: 2}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {units_lost_lte: 2}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 54
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 more controlled variable: TWO seed-driven agent spawn groups
+  # with DIFFERENT cell coordinates. Group 0 stages Squad A NORTH
+  # (5,8) / Squad B SOUTH (5,32). Group 1 SHIFTS the squads to (8,6)
+  # / (8,34) — same west-edge / opposing-latitude pincer shape but
+  # the exact start cells differ across seeds so a memorised single-
+  # cell opening cannot generalise. Both groups remain approximately
+  # equidistant from the central cluster (~46-47 cells) so the naive
+  # simultaneous launch still arrives together. Per CLAUDE.md, "if
+  # ANY agent actor declares spawn_point, every agent actor WITHOUT
+  # spawn_point is filtered OUT", so the two full squad layouts are
+  # listed explicitly. The defender cluster is symmetric across y=20
+  # so both spawns face the same simultaneous-pincer decision.
+  hard:
+    description: >
+      You command TWO squads of medium tanks (3× 2tnk each, 6 tanks
+      total) staged on the west edge — one squad to the NORTH, one
+      to the SOUTH (the exact staging cells vary by seed; treat the
+      two squads symmetrically). A central enemy cluster
+      sits at the mid-map (around (50,20)): 4 rifle infantry (e1) +
+      2 anti-tank rocket soldiers (e3, Dragon launcher) + 2 medium
+      tanks (2tnk) — the enemy armour gives the cluster enough
+      sustained anti-armour DPS to shred a lone 3-tank squad. Both
+      squads must converge SIMULTANEOUSLY (a pincer): attack-moving
+      with both squads at once on turn 1 clears the cluster before
+      either side bleeds out. Win when you have killed 8 enemies AND
+      at least 4 of your 6 tanks are inside an 8-cell radius of
+      (50,20) AND no more than 2 tanks are lost, before tick 4500.
+    overrides:
+      actors:
+        # spawn_point 0 — Squad A NORTH (5,8), Squad B SOUTH (5,32).
+        - {type: 2tnk, owner: agent, position: [5, 8],  stance: 1, count: 3, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [5, 32], stance: 1, count: 3, spawn_point: 0}
+        # spawn_point 1 — SHIFTED layout: NORTH squad at (3, 5) and
+        # SOUTH squad at (3, 35). Both remain on the west edge and
+        # approximately equidistant (~49-50 cells) from the central
+        # cluster at (50,20); the slight extra distance vs group 0
+        # keeps the synchronised launch viable while ensuring the
+        # squad arriving alone takes ≥ the same attrition (still
+        # loses ≥3 of 3 tanks on the sequenced policy). The exact
+        # start cells DIFFER from group 0, satisfying the hard-tier
+        # invariant (≥2 distinct seed-driven starts) and ensuring a
+        # memorised single-cell opening cannot generalise across
+        # seeds.
+        - {type: 2tnk, owner: agent, position: [3, 5],  stance: 1, count: 3, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [3, 35], stance: 1, count: 3, spawn_point: 1}
+        # Central cluster — 4× e1 + 2× e3 + 2× 2tnk = 8 enemies,
+        # symmetric across y=20 so both spawn groups face the same
+        # pincer decision.
+        - {type: e1, owner: enemy, position: [50, 19], stance: 3, count: 2}
+        - {type: e1, owner: enemy, position: [50, 21], stance: 3, count: 2}
+        - {type: e3, owner: enemy, position: [50, 19], stance: 3}
+        - {type: e3, owner: enemy, position: [50, 21], stance: 3}
+        - {type: 2tnk, owner: enemy, position: [50, 19], stance: 3}
+        - {type: 2tnk, owner: enemy, position: [50, 21], stance: 3}
+        - {type: fact, owner: enemy, position: [120, 4]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 8}
+        - {units_in_region_gte: {x: 50, y: 20, radius: 8, n: 4}}
+        - {units_lost_lte: 2}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {units_lost_lte: 2}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 54

tests/test_combat_pincer_coordination.py

@@ -0,0 +1,364 @@
+"""combat-pincer-coordination — synchronised two-prong pincer attack.
+
+The bar: TWO 3-tank squads start on the SAME west edge at OPPOSING
+latitudes (north y=8, south y=32). A central enemy cluster sits at
+the mid-map (around (50,20)). The win predicate REQUIRES both squads
+to engage simultaneously:
+
+  • `units_in_region_gte:{x:50,y:20,radius:8,n:4}` — at least 4 tanks
+    must be inside the central region; a single squad has only 3 tanks
+    so single-squad-A cannot satisfy this clause regardless of
+    attrition.
+  • `units_lost_lte:2` — sequenced (A first, B late) is shredded by
+    the cluster's anti-armour mass and loses ≥3 tanks before B
+    arrives → busts the cap.
+  • `within_ticks:4500` — stall hits the deadline → after_ticks LOSS.
+
+Discrimination (the four-script bar; the scripted runs cover all
+seeds 1–4 per level on every policy):
+
+  • stall                  — every level/seed must LOSE (clock).
+  • single-squad-A         — every level/seed must LOSE (region n=4).
+  • sequenced-A-then-B-late — medium/hard must LOSE (attrition cap
+                              busted by lone Squad A); easy is the
+                              bare-skill tier where this may squeak
+                              by (SCENARIO_REVIEW_CHECKLIST inert-
+                              easy-teeth convention).
+  • intended pincer-sync   — every level/seed must WIN.
+
+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-pincer-coordination.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-pincer-coordination"
+    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) == 4, (
+        f"benchmark_anchor must list 4 anchors, got {anchors!r}"
+    )
+    joined = " ".join(anchors).lower()
+    for needle in ("sc2", "pincer", "envelopment", "synchronisation"):
+        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):
+    """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,
+        power_provided=0,
+        power_drained=0,
+        own_buildings=[],
+        own_building_types=set(),
+        enemies_seen_ids=set(),
+        enemy_buildings_seen_ids=set(),
+        explored_percent=0.0,
+        then_progress={},
+        seq_progress={},
+    )
+    return WinContext(
+        signals=sig,
+        render_state={"units_summary": list(units)},
+    )
+
+
+def _tanks_at(n, x=50, y=20):
+    return [
+        {"cell_x": x, "cell_y": y, "type": "2tnk", "id": str(2000 + i)}
+        for i in range(n)
+    ]
+
+
+def test_predicates_per_level():
+    """Region n=4 + kill bar + attrition + deadline all load-bearing."""
+    pack = load_pack(PACK_PATH)
+    expectations = {
+        # (kill_bar, region_n, lost_cap, within, after_fail)
+        "easy":   (6, 4, 2, 4500, 4501),
+        "medium": (8, 4, 2, 4500, 4501),
+        "hard":   (8, 4, 2, 4500, 4501),
+    }
+    for lvl, (kb, n, cap, w, af) in expectations.items():
+        c = compile_level(pack, lvl)
+        # Intended win: ≥n tanks in region, ≥kb kills, ≤cap lost, in time.
+        ctx_win = _ctx(units=_tanks_at(n + 1), tick=w - 100, kills=kb, lost=cap)
+        assert evaluate(c.win_condition, ctx_win), f"{lvl}: intended should WIN"
+        # Region clause unmet (only 3 tanks at objective) → not a win
+        # — this is the load-bearing pincer teeth (single squad has only 3 tanks).
+        ctx_3 = _ctx(units=_tanks_at(3), tick=w - 100, kills=kb, lost=0)
+        assert not evaluate(c.win_condition, ctx_3), (
+            f"{lvl}: 3 tanks in region < n={n} must not satisfy win"
+        )
+        # Kill bar unmet → not a win.
+        ctx_low_kills = _ctx(units=_tanks_at(n + 1), tick=w - 100, kills=kb - 1, lost=0)
+        assert not evaluate(c.win_condition, ctx_low_kills), (
+            f"{lvl}: kills < {kb} must not satisfy win"
+        )
+        # Attrition cap busted → not a win + fails.
+        ctx_lost = _ctx(units=_tanks_at(n + 1), tick=w - 100, kills=kb, lost=cap + 1)
+        assert not evaluate(c.win_condition, ctx_lost)
+        assert evaluate(c.fail_condition, ctx_lost), f"{lvl}: lost>{cap} must FAIL"
+        # Timeout busted → fails.
+        ctx_late = _ctx(units=_tanks_at(n + 1), tick=af + 1, kills=kb, lost=0)
+        assert evaluate(c.fail_condition, ctx_late), f"{lvl}: tick>after must FAIL"
+        # Force-wipe → fails.
+        ctx_wipe = _ctx(units=[], tick=w - 100, kills=kb, lost=6)
+        assert evaluate(c.fail_condition, ctx_wipe)
+
+
+def test_timeout_reachable_inside_max_turns():
+    """No DRAW degeneracy: after_ticks fail trigger must be reachable
+    within max_turns (engine advances ~90 ticks per turn ⇒ max tick
+    ≈ 93 + 90·(max_turns-1))."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        max_tick = 93 + 90 * (c.max_turns - 1)
+        # After-ticks fail clause is 4501 on every level here.
+        assert 4501 <= max_tick, (
+            f"{lvl}: after_ticks 4501 > max reachable tick {max_tick} "
+            f"(max_turns={c.max_turns}); deadline never bites"
+        )
+
+
+def test_two_squads_on_every_level():
+    """Two 3-tank squads at opposing latitudes (north y≈8 vs south
+    y≈32); the pincer mechanism requires both prongs."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        agent_actors = [a for a in c.scenario.actors if a.owner == "agent"]
+        # All agent units are medium tanks (2tnk).
+        for a in agent_actors:
+            assert a.type == "2tnk", (
+                f"{lvl}: agent must be 2tnk (medium tanks); got {a.type}"
+            )
+        # Two latitudes represented (north y<20 and south y>20).
+        latitudes = {("N" if a.position[1] < 20 else "S") for a in agent_actors}
+        assert latitudes == {"N", "S"}, (
+            f"{lvl}: agent squads must span both latitudes; got {latitudes}"
+        )
+
+
+def test_enemy_cluster_avoids_silent_no_place_cell():
+    """CLAUDE.md: (50,20) silently fails to place enemy clusters.
+    Cluster must anchor on the off-by-one cells (50,19) / (50,21)."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        cluster = [
+            a for a in c.scenario.actors
+            if a.owner == "enemy" and a.type in ("e1", "e3", "2tnk")
+        ]
+        assert cluster, f"{lvl}: no central cluster declared"
+        for a in cluster:
+            assert tuple(a.position) != (50, 20), (
+                f"{lvl}: enemy cluster member at (50,20) — CLAUDE.md "
+                f"silent-no-place footgun"
+            )
+            assert a.position[0] == 50 and a.position[1] in (19, 21), (
+                f"{lvl}: cluster member off-anchor; got {a.position}"
+            )
+
+
+def test_persistent_far_enemy_marker_present():
+    """Engine auto-`done` mitigation: a far unarmed enemy `fact` keeps
+    the episode alive past full cluster elimination so within_ticks /
+    region predicates evaluate on the terminal frame (no DRAW collapse)."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        far_facts = [
+            a for a in c.scenario.actors
+            if a.owner == "enemy" and a.type == "fact"
+            and a.position[0] >= 100  # far east of the cluster
+        ]
+        assert far_facts, f"{lvl}: needs a far persistent enemy fact sentinel"
+
+
+def test_hard_has_two_spawn_point_groups():
+    """Hard-tier curation: ≥2 distinct agent spawn_point groups so the
+    seed round-robins which squad ID is north vs south."""
+    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}"
+
+
+# ── engine-driven scripted policies ─────────────────────────────────
+
+
+def _split_squads(rs):
+    """Return (north_ids, south_ids) — split agent 2tnk units by
+    latitude. The agent's two staging latitudes are y≈8 (north) and
+    y≈32 (south); the cluster sits at y=20."""
+    n_ids, s_ids = [], []
+    for u in (rs.get("units_summary") or []):
+        if str(u.get("type", "")).lower() != "2tnk":
+            continue
+        if int(u["cell_y"]) < 20:
+            n_ids.append(str(u["id"]))
+        else:
+            s_ids.append(str(u["id"]))
+    return n_ids, s_ids
+
+
+def _stall(rs, Command):
+    """Pure observe — agent units never engage → kill bar unmet AND
+    region clause unmet → after_ticks LOSS."""
+    return [Command.observe()]
+
+
+def _single_squad_a(rs, Command):
+    """Send only the NORTH squad; hold the SOUTH squad. Even if A
+    clears the cluster on its own, only 3 tanks can be in the
+    objective region → `units_in_region_gte:{n:4}` cannot be
+    satisfied → LOSS. On medium/hard the cluster's enemy 2tnks also
+    shred A → units_lost_lte:2 busts as a second teeth."""
+    a, b = _split_squads(rs)
+    cmds = []
+    if a:
+        cmds.append(Command.attack_move(a, 50, 20))
+    if b:
+        cmds.append(Command.stop(b))
+    return cmds or [Command.observe()]
+
+
+def _make_sequenced_a_then_b_late(delay_turns=20):
+    """Squad A commits first; Squad B holds for `delay_turns` then
+    advances. The cluster shreds A in detail before B arrives →
+    units_lost_lte:2 busts on medium/hard. On easy with no enemy
+    armour A may clear the cluster cleanly and B walks in → may WIN
+    (acceptable per the inert-easy-teeth convention)."""
+    state = {"turn": 0}
+
+    def policy(rs, Command):
+        state["turn"] += 1
+        a, b = _split_squads(rs)
+        cmds = []
+        if a:
+            cmds.append(Command.attack_move(a, 50, 20))
+        if b:
+            if state["turn"] >= delay_turns:
+                cmds.append(Command.attack_move(b, 50, 20))
+            else:
+                cmds.append(Command.stop(b))
+        return cmds or [Command.observe()]
+
+    return policy
+
+
+def _intended_pincer_sync(rs, Command):
+    """Both squads attack_move the cluster on turn 1. The two squads
+    are equidistant from the cluster (~45 cells each) so a naive
+    simultaneous launch arrives together; mass DPS clears the
+    cluster in ~6s before either side bleeds out."""
+    a, b = _split_squads(rs)
+    cmds = []
+    if a:
+        cmds.append(Command.attack_move(a, 50, 20))
+    if b:
+        cmds.append(Command.attack_move(b, 50, 20))
+    return cmds or [Command.observe()]
+
+
+@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 + region clause unmet), got {r.outcome}"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_single_squad_a_loses(level, seed):
+    """Single-squad-A cannot satisfy `units_in_region_gte:{n:4}` —
+    only 3 tanks exist in Squad A so the region clause is structurally
+    unsatisfiable. On medium/hard the cluster also shreds A as a
+    second teeth (units_lost_lte:2 busts)."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _single_squad_a, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: single-squad-A must LOSE "
+        f"(region n=4 impossible with 3 tanks); got {r.outcome} "
+        f"(kills={r.signals.units_killed}, lost={r.signals.units_lost})"
+    )
+
+
+@pytest.mark.parametrize("level", ["medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_sequenced_a_then_b_late_loses_on_medium_hard(level, seed):
+    """A commits first, B holds 20 turns. The cluster's enemy 2tnks
+    shred A (lose 3 of 3 tanks) before B arrives → units_lost_lte:2
+    busts → LOSS. Easy has no enemy armour so this may squeak by
+    there (bare-skill-tier inert-easy-teeth convention)."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _make_sequenced_a_then_b_late(20), seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: sequenced-A-then-B-late must LOSE "
+        f"(A shredded by enemy 2tnks before B arrives); got {r.outcome} "
+        f"(kills={r.signals.units_killed}, lost={r.signals.units_lost})"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_intended_pincer_sync_wins(level, seed):
+    """Both squads attack_move the cluster on turn 1 — naive
+    simultaneous launch with equidistant staging arrives together,
+    mass DPS clears the cluster before either side bleeds out."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _intended_pincer_sync, seed=seed)
+    assert r.outcome == "win", (
+        f"{level} seed={seed}: intended pincer-sync should WIN, "
+        f"got {r.outcome} after {r.turns} turns "
+        f"(kills={r.signals.units_killed}, lost={r.signals.units_lost})"
+    )

tests/test_hard_tier.py

@@ -539,6 +539,20 @@ UPGRADED = [
     # filtered out), so the strike geometry is symmetric but a
     # memorised opening cannot generalise.
     "rob-unit-loss-recovery",
+    # Wave-6 Group N coordination pack — military pincer movement /
+    # SC2 two-prong attack / envelopment from two directions. Two
+    # 3-tank squads start at OPPOSING west-edge latitudes (north y=8 /
+    # south y=32) and must converge on a central enemy cluster
+    # SIMULTANEOUSLY: the win predicate requires ≥4 tanks in the
+    # central region (single squad has only 3 — structurally
+    # impossible) AND ≤2 tanks lost (sequenced A-then-B-late shreds A
+    # before B arrives → cap busted). Hard defines two agent
+    # spawn_point groups round-robined by seed with DIFFERENT cell
+    # coordinates (group 0: (5,8)/(5,32); group 1: (3,5)/(3,35)) so
+    # a memorised single-cell opening cannot generalise; the cluster
+    # is symmetric across y=20 so both spawns face the same pincer
+    # decision.
+    "combat-pincer-coordination",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation