feat(scenario): mcv-deploy-third-base — tri-region operational footprint via 3rd MCV (SC2LE 3-base anchor)

Group A seed (Mid-Late: 3rd MCV → 3rd base). Three MCVs must EACH
deploy at a DISTINCT target region (NE/SE/S-CENTER) for the
tri-region operational footprint — bunching at one region or
abandoning an MCV leaves a region uncovered and LOSES. Uses the
Wave-2 MCV deploy fix.

Pack design:
- Map: arena 160x80 cordon 4 (wider arena for 3 well-separated
regions plus a west starter base).
- starting_cash 0 (the decision is move+deploy, not build).
- One pre-placed agent fact (west, (15,40)) + three MCVs at varied
agent positions + a persistent unarmed enemy fact marker
((150,40) easy/medium, (150,75) hard) for LOSS-not-DRAW.
- within_ticks 6300 + pre-fail at tick 4000 with <2 facts so
stalling LOSES well before the deadline.
- max_turns 75 across all tiers (reachable tick 6753 > 6300 ✓).
- Easy: MCVs sit INSIDE their target regions; decision is solely
'deploy all three'.
- Medium: MCVs cluster at west; must move to each region; light
patrol per region.
- Hard: TWO spawn_point groups rotate the whole MCV cluster
between WEST and EAST starts (per-MCV nearest-region flips per
seed); doubled patrols; objective_coords: relative.

Win = building_count_gte:{type:fact,n:3} AND building_in_region
(one per region: NE (130,15), SE (130,65), S-CENTER (75,70), all
radius 8) AND within_ticks:6300. Fail = after_ticks:6301 OR (after
tick 4000 with fewer than 2 facts).

Benchmark anchors: SC2LE 3-base macro, MicroRTS multi-front
expansion, distribution-network multi-warehouse planning, tri-region
operational footprint.

Scripted-policy validation (tests/test_mcv_deploy_third_base.py):
- stall → LOSS on all 3 levels × all 4 seeds.
- bunch-in-place → LOSS on medium+hard × all 4 seeds (facts land
outside every target region).
- deploy-only-two-regions → LOSS on all 3 levels × all 4 seeds.
- intended-3-regions → WIN on all 3 levels × all 4 seeds.
Plus tick/turn-alignment, spawn-variation, anchor, and arena
compile guard tests. 48 new tests pass; tests/test_hard_tier.py
appends 'mcv-deploy-third-base' to UPGRADED.

openra_bench/scenarios/packs/mcv-deploy-third-base.yaml

@@ -0,0 +1,323 @@
+# MCV-DEPLOY-THIRD-BASE — Group A seed (Mid-Late: 3rd MCV → 3rd base).
+# Tri-region operational footprint: the agent must commit ALL THREE
+# MCVs to DISTINCT target regions (NE / SE / S-CENTER), not bunch them
+# at one spot and not abandon any. Real-world anchor: a distribution
+# network with three production/supply/distribution sites placed across
+# distinct geographies for maximum coverage.
+#
+# Why this is harder than mcv-deploy-second-base:
+#   - 3 distinct deploy decisions (1 MCV → 1 region, x3) instead of 2,
+#   - 3 separate `building_in_region` checks (one per region) so the
+#     model cannot collapse coverage onto one or two regions,
+#   - longer horizon (within_ticks 6300 → max_turns ~75) so movement
+#     across a wider 160x80 arena is a real factor,
+#   - a light enemy patrol near each target on medium/hard creates
+#     incidental MCV risk en route (lose any MCV → cannot deploy it →
+#     missing region → LOSS).
+#
+# Wave-2 MCV deploy fix (commits bdedc55 OpenRA-Rust + b0cb710
+# OpenRA-Bench, validated by tests/test_mcv_deploy.py) is the
+# pre-requisite: `Command.deploy([mcv_id])` removes the MCV and
+# creates an agent-owned `fact` at offset (mcv_x-1, mcv_y-1). The
+# whole pack rests on that contract.
+#
+# Engine tick/turn budget (CLAUDE.md): ~90 ticks/turn, tick ≤
+# 93 + 90·(max_turns − 1). For within_ticks 6300 we need max_turns ≥
+# 70 (reachable tick at 70 turns = 93 + 90·69 = 6303). We use 75 for
+# slack on hard's combat detours.
+#
+# Engine footguns applied:
+#   - `spawn_mcvs: false` — the engine default is true (auto-seeds an
+#     extra MCV at the map's mpspawn cells), polluting the unit count
+#     and the deploy decision. The pack declares every actor itself.
+#   - Persistent unarmed enemy `fact` MARKER at the east edge
+#     prevents engine auto-`done` via all-enemies-eliminated, so a
+#     non-winner emits a real LOSS on the deadline (never a DRAW).
+#   - The west existing agent `fact` counts toward `building_count_gte:
+#     {type: fact, n: 3}` (so the agent needs +2 deploys at minimum
+#     to satisfy that bar) — but the THREE region predicates EACH
+#     require a fact in their target region, and the west fact is in
+#     NONE of them, so the agent MUST deploy all three MCVs at the
+#     three target regions to win. (The `n: 3` bar plus the three
+#     region predicates together are the no-cheat seal: any laziest
+#     play that ignores 1+ MCVs fails the corresponding region.)
+#   - Hard tier: ≥2 agent spawn_point groups so the whole MCV CLUSTER
+#     rotates between WEST (group 0) and EAST (group 1) starts — the
+#     closest region for each MCV flips per seed, so a memorised
+#     assignment cannot generalise.
+#
+# Region geometry (all radius 8, well inside the playable 160×80
+# arena cordon: x∈[4,156], y∈[4,76]):
+#   - NE       : center (130, 15)
+#   - SE       : center (130, 65)
+#   - S-CENTER : center ( 75, 70)
+# Easy MCV positions land each MCV INSIDE a distinct region (the
+# resulting fact cell at (mcv_x-1, mcv_y-1) is in the region). Medium
+# and hard require movement: MCVs start clustered or in inappropriate
+# pairings so the agent must move at least one MCV across a long
+# stretch to populate every region.
+
+meta:
+  id: mcv-deploy-third-base
+  title: 'MCV Deploy Third Base — Tri-Region Operational Footprint'
+  capability: reasoning
+  real_world_meaning: >
+    Tri-region facility footprint — each site at the RIGHT region for
+    coverage. The operator commits THREE indivisible mobile assets to
+    three DISTINCT geographies so the resulting network covers all
+    three regions. Bunching two assets in one region wastes a deploy
+    and leaves one region uncovered; abandoning an asset entirely
+    leaves another uncovered. The decision is committing each asset
+    to its designated region (which the start positions hint at on
+    easy and which the model must reason about on medium/hard).
+  robotics_analogue: >
+    Autonomous-fleet multi-FOB deployment for redundant coverage —
+    three mobile platforms each transition from mobile to fixed
+    (deploy is irreversible: the platform anchors and converts into a
+    forward operating base), one per designated coverage region, so
+    the resulting tri-FOB network maximises overall coverage and
+    redundancy across the operational theatre.
+  benchmark_anchor:
+    - "SC2LE 3-base macro"
+    - "MicroRTS multi-front expansion"
+    - "distribution-network multi-warehouse planning"
+    - "tri-region operational footprint"
+  author: "openra-bench"
+
+# Wider 160×80 arena (cordon 4) — fits THREE well-separated regions
+# (NE, SE, S-CENTER) plus a west base, the spread the tri-region
+# footprint requires. The pack-level base_map is the rush-hour-arena
+# sentinel (a known-supported string the loader can resolve before the
+# per-level `overrides.base_map` generator spec replaces it). Per-level
+# overrides materialise the actual arena .oramap.
+base_map: rush-hour-arena
+
+# starting_cash: 0 — the agent never needs to BUILD anything. Every
+# objective is satisfied purely by deploying MCVs. The 0 cash is the
+# explicit signal that build/place_building tools are not the path.
+starting_cash: 0
+
+base:
+  agent: {faction: allies}
+  enemy: {faction: soviet, cash: 0}
+  # Tools include build/place_building so the tool list isn't lying
+  # about what the engine accepts, but cash:0 makes them inert — the
+  # path is move_units + deploy only.
+  tools: [observe, deploy, move_units, build, place_building, stop]
+  spawn_mcvs: false
+  planning: true
+  termination: {max_ticks: 8500}
+  actors: []
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Bare skill: each MCV starts INSIDE its designated region (the
+  # fact cell after deploy lands at (mcv_x-1, mcv_y-1), still inside
+  # radius 8 of the region center). The decision is purely "deploy
+  # ALL THREE, not just one or two" — no movement, no enemies.
+  # All target regions are inside agent vision (no fog scout needed).
+  # max_turns 75 → reachable tick 93 + 90·74 = 6753 > 6300 ✓
+  # (the deadline bites; a stall emits LOSS, not DRAW).
+  easy:
+    description: >
+      You have THREE Construction Vehicles (MCV), each pre-positioned
+      AT a distinct target region (NE, SE, and S-CENTER), plus one
+      existing Construction Yard (fact) at your starter base in the
+      west. Deploy EACH MCV in place — each deploy consumes the MCV
+      and creates a new fact one cell up-and-left of the MCV's
+      position, inside its designated region. Win = you own ≥3 facts
+      total AND there is a fact near (130,15) AND a fact near
+      (130,65) AND a fact near (75,70), before tick 6300. Deploying
+      only 1 or 2 MCVs leaves an uncovered region and LOSES. Losing
+      an MCV before deploying it also LOSES (its region stays
+      uncovered).
+    overrides:
+      base_map:
+        generator: arena
+        name: mcv-deploy-third-base-arena
+        width: 160
+        height: 80
+        cordon: 4
+      actors:
+        # Existing west agent fact (the starter base). Does NOT count
+        # toward any of the three target-region predicates (none of
+        # them are in the west), but DOES count toward the
+        # `building_count_gte: {type: fact, n: 3}` total bar.
+        - {type: fact, owner: agent, position: [15, 40]}
+        # Three MCVs already inside their designated regions. After
+        # deploy, fact lands at (mcv_x-1, mcv_y-1):
+        #   (131,16) → fact (130,15) — exactly NE region center
+        #   (131,66) → fact (130,65) — exactly SE region center
+        #   ( 76,71) → fact ( 75,70) — exactly S-CENTER center
+        - {type: mcv, owner: agent, position: [131, 16]}
+        - {type: mcv, owner: agent, position: [131, 66]}
+        - {type: mcv, owner: agent, position: [76, 71]}
+        # Persistent unarmed enemy `fact` MARKER at the far east edge,
+        # outside all three target regions. Keeps the episode alive
+        # past any partial outcome (the all-enemies-eliminated
+        # auto-`done` is gated on this surviving) so a non-winner
+        # emits a real reachable LOSS on the deadline, never a DRAW.
+        - {type: fact, owner: enemy, position: [150, 40]}
+    win_condition:
+      all_of:
+        - building_count_gte: {type: fact, n: 3}
+        - building_in_region: {x: 130, y: 15, radius: 8, type: fact, count: 1}
+        - building_in_region: {x: 130, y: 65, radius: 8, type: fact, count: 1}
+        - building_in_region: {x: 75, y: 70, radius: 8, type: fact, count: 1}
+        - within_ticks: 6300
+    fail_condition:
+      any_of:
+        - after_ticks: 6301
+        # Pre-fail clause: if the agent has not produced ≥2 facts by
+        # tick 4000 the run is unwinnable (no time to move+deploy
+        # the remaining MCV). Catches a stall LONG before the main
+        # deadline, so playback shows the genuine LOSS reason.
+        - all_of:
+            - after_ticks: 4000
+            - not: {building_count_gte: {type: fact, n: 2}}
+    max_turns: 75
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 axis: the MCVs no longer start inside their target regions —
+  # they're clustered around the west starter base. The agent must
+  # MOVE each MCV to a distinct region (the assignment is the
+  # decision) and then deploy. A LIGHT enemy patrol sits near each
+  # target so a slow / wandering MCV may be lost en route (no
+  # patrol is on the optimal direct line — they're offset).
+  # Same tick budget; target regions are in fog (the model must
+  # ground them from the coordinate disclosure).
+  # max_turns 75 → reachable tick 6753 > 6300 ✓
+  medium:
+    description: >
+      Same THREE Construction Vehicles, but this time clustered at
+      your starter base in the west — you must MOVE each one to its
+      target region BEFORE deploying. Three target regions (NE near
+      (130,15), SE near (130,65), S-CENTER near (75,70)) each need
+      ONE fact. A light Soviet patrol sits near each target — keep
+      to a direct path and the patrol will only graze you. Win = you
+      own ≥3 facts total AND there is a fact in each of the three
+      target regions, before tick 6300. Losing any MCV before its
+      deploy leaves a region uncovered and LOSES; bunching two MCVs
+      in one region also LOSES (a region is left uncovered).
+    overrides:
+      base_map:
+        generator: arena
+        name: mcv-deploy-third-base-arena
+        width: 160
+        height: 80
+        cordon: 4
+      enemy: {faction: soviet, cash: 0, bot_type: patrol}
+      actors:
+        # Same west starter fact as easy.
+        - {type: fact, owner: agent, position: [15, 40]}
+        # Three MCVs CLUSTERED at the starter base (varied positions
+        # so they're distinct cells, but all within a few cells of
+        # the west fact). The agent must reason about which MCV
+        # should head to which region.
+        - {type: mcv, owner: agent, position: [20, 35]}
+        - {type: mcv, owner: agent, position: [20, 40]}
+        - {type: mcv, owner: agent, position: [20, 45]}
+        # Light Soviet patrols near each target (stance 2 = return
+        # fire only — the patrol bot oscillates around spawn cell;
+        # placed OFFSET from each region's center so the direct
+        # approach is unthreatened, a meandering MCV gets grazed).
+        - {type: e1, owner: enemy, position: [115, 12], stance: 2}
+        - {type: e1, owner: enemy, position: [115, 68], stance: 2}
+        - {type: e1, owner: enemy, position: [60, 68],  stance: 2}
+        # Persistent far enemy marker (LOSS-not-DRAW guarantee).
+        - {type: fact, owner: enemy, position: [150, 40]}
+    win_condition:
+      all_of:
+        - building_count_gte: {type: fact, n: 3}
+        - building_in_region: {x: 130, y: 15, radius: 8, type: fact, count: 1}
+        - building_in_region: {x: 130, y: 65, radius: 8, type: fact, count: 1}
+        - building_in_region: {x: 75, y: 70, radius: 8, type: fact, count: 1}
+        - within_ticks: 6300
+    fail_condition:
+      any_of:
+        - after_ticks: 6301
+        - all_of:
+            - after_ticks: 4500           # half-way through, must have ≥2 facts
+            - not: {building_count_gte: {type: fact, n: 2}}
+    max_turns: 75
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 axis: TWO agent spawn_point groups rotate the whole MCV
+  # CLUSTER between WEST and EAST starts. The same three target
+  # regions stay fixed (enemy actors don't honour spawn_point per
+  # CLAUDE.md), but which corner an MCV starts in determines which
+  # target is CLOSEST — a memorised "MCV-i goes to region-j"
+  # assignment cannot generalise across seeds.
+  # max_turns 75 → reachable tick 6753 > 6300 ✓
+  hard:
+    description: >
+      Same tri-region objective (NE, SE, S-CENTER each need a fact)
+      under tighter pressure. Your three Construction Vehicles cluster
+      at either the WEST or the EAST edge of the map depending on the
+      run — read your MCVs' positions and assign each to the region
+      it can reach fastest. A doubled Soviet patrol sits near each
+      target. Win = you own ≥3 facts total AND there is a fact in
+      each of the three target regions, before tick 6300. Losing any
+      MCV before its deploy LOSES (the region stays uncovered);
+      bunching two MCVs in one region LOSES (a region uncovered).
+    objective_coords: relative
+    overrides:
+      base_map:
+        generator: arena
+        name: mcv-deploy-third-base-arena
+        width: 160
+        height: 80
+        cordon: 4
+      enemy: {faction: soviet, cash: 0, bot_type: patrol}
+      actors:
+        # West starter fact (duplicated across both spawn groups so
+        # whichever group is selected, the starter base is present —
+        # see CLAUDE.md note on the spawn_point filter dropping every
+        # un-tagged agent actor when ANY agent actor is tagged).
+        - {type: fact, owner: agent, position: [15, 40], spawn_point: 0}
+        - {type: fact, owner: agent, position: [15, 40], spawn_point: 1}
+        # WEST MCV cluster (group 0) — closest region is S-CENTER
+        # (75,70) at ~70 cells, NE (130,15) at ~115, SE (130,65) at
+        # ~115. The agent must commit one MCV to the far NE and one
+        # to the far SE despite the western starter — the natural
+        # west-side "do nothing" laziest play leaves both east
+        # regions uncovered.
+        - {type: mcv, owner: agent, position: [20, 35], spawn_point: 0}
+        - {type: mcv, owner: agent, position: [20, 40], spawn_point: 0}
+        - {type: mcv, owner: agent, position: [20, 45], spawn_point: 0}
+        # EAST MCV cluster (group 1) — closest regions are NE and SE;
+        # S-CENTER (75,70) is the far target. Inversion of group 0:
+        # an agent that memorised "always head south-east first"
+        # on group 0 will leave S-CENTER uncovered on group 1.
+        - {type: mcv, owner: agent, position: [145, 35], spawn_point: 1}
+        - {type: mcv, owner: agent, position: [145, 40], spawn_point: 1}
+        - {type: mcv, owner: agent, position: [145, 45], spawn_point: 1}
+        # Doubled patrols (one extra unit per region vs medium) —
+        # attrition risk is real, but each patrol's spawn cell is
+        # offset from the region center so the optimal direct
+        # approach is still unthreatened.
+        - {type: e1, owner: enemy, position: [115, 12], stance: 2}
+        - {type: e1, owner: enemy, position: [117, 14], stance: 2}
+        - {type: e1, owner: enemy, position: [115, 68], stance: 2}
+        - {type: e1, owner: enemy, position: [117, 66], stance: 2}
+        - {type: e1, owner: enemy, position: [60, 68],  stance: 2}
+        - {type: e1, owner: enemy, position: [62, 66],  stance: 2}
+        # Persistent far enemy marker (LOSS-not-DRAW guarantee). NOT
+        # tagged with spawn_point — enemy actors place regardless
+        # (CLAUDE.md: spawn_point filter applies only to AGENT
+        # actors).
+        - {type: fact, owner: enemy, position: [150, 75]}
+    win_condition:
+      all_of:
+        - building_count_gte: {type: fact, n: 3}
+        - building_in_region: {x: 130, y: 15, radius: 8, type: fact, count: 1}
+        - building_in_region: {x: 130, y: 65, radius: 8, type: fact, count: 1}
+        - building_in_region: {x: 75, y: 70, radius: 8, type: fact, count: 1}
+        - within_ticks: 6300
+    fail_condition:
+      any_of:
+        - after_ticks: 6301
+        - all_of:
+            - after_ticks: 4500
+            - not: {building_count_gte: {type: fact, n: 2}}
+    max_turns: 75

tests/test_hard_tier.py

@@ -62,14 +62,15 @@ UPGRADED = [
     # column against three raider vectors (north/central/south).
     "mid-economy-under-fire",
     # Other mcv-deploy-* siblings (defensible-site, near-resource,
-    # second-base, third-base, relocate-under-pressure) register
-    # themselves via their own Wave-3 commits as they land.
+    # relocate-under-pressure) register themselves via their own
+    # Wave-3 commits as they land.
     # Group A seed: hard tier stages the spare MCV NE-leaning vs
     # SE-leaning by seed; the win predicate accepts a deploy at
     # either candidate region (NE or SE) so the model must pick the
     # NEAREST one — cross-map diagonal blows the tick budget.
     "mcv-deploy-second-base",
     # Group A seed (this commit): hard tier seed-varies the FRESH
+    # Group A seed (sibling commit): hard tier seed-varies the FRESH
     # MCV's start column (40,20 vs 60,20) with the matching safe
     # shoulders, so a single memorised relocation cell cannot
     # generalise across seeds.
@@ -78,6 +79,11 @@ UPGRADED = [
     # harvest income); hard tier defines 2 symmetric spawn_point groups
     # (north/south base) so each seed gets its own near-patch geometry.
     "mcv-deploy-near-resource",
+    # Wave-2 MCV deploy + tri-region operational footprint: 3 MCVs
+    # must each deploy at a DISTINCT target region (NE/SE/S-CENTER);
+    # hard tier rotates the WHOLE MCV cluster between WEST and EAST
+    # starts so the per-MCV nearest-region assignment flips per seed.
+    "mcv-deploy-third-base",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation

tests/test_mcv_deploy_third_base.py

@@ -0,0 +1,320 @@
+"""mcv-deploy-third-base — Group A seed (Mid-Late: 3rd MCV → 3rd base).
+
+Tri-region operational footprint scripted-policy validation. The pack
+declares THREE MCVs and a single existing west `fact`; the win
+predicate requires ≥3 facts AND a fact INSIDE each of three distinct
+target regions (NE / SE / S-CENTER) before tick 6300. The discriminator
+is committing each MCV to a DISTINCT region — bunching all three at
+the base satisfies `building_count_gte` but fails all three region
+predicates; deploying only 1-2 leaves at least one region uncovered;
+stalling produces no new facts at all.
+
+This file proves the no-defect / no-cheat bar at scripted level (no
+model, no network) across seeds 1–4 and across easy / medium / hard:
+
+  - stall  (only Command.observe())                          → LOSS
+  - bunch-all-at-base (deploy in place; on medium/hard MCVs
+    start away from the target regions, so the resulting facts
+    land in the west cluster, NOT in any target region)     → LOSS
+  - deploy-only-two-regions (cover NE+SE, abandon S-CENTER)  → LOSS
+  - intended-3-regions (move each MCV to a distinct region
+    and deploy)                                              → WIN
+"""
+
+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 / "mcv-deploy-third-base.yaml"
+
+# Three target region centers (see pack YAML). Deploy converts an MCV
+# at (mx, my) into a fact at (mx-1, my-1), so to land a fact exactly
+# at (cx, cy) the MCV must be at (cx+1, cy+1).
+REGIONS = [(130, 15), (130, 65), (75, 70)]
+MCV_TARGETS = [(cx + 1, cy + 1) for (cx, cy) in REGIONS]
+
+LEVELS = ("easy", "medium", "hard")
+HARD_SEEDS = (1, 2, 3, 4)
+
+
+# ── scripted policies ─────────────────────────────────────────────────
+
+
+def stall(rs, Command):
+    """Do nothing — the deadline (and the early pre-fail clause at
+    tick 4000 with <2 facts) emits a real LOSS."""
+    return [Command.observe()]
+
+
+def bunch_in_place(rs, Command):
+    """Deploy every MCV at its current cell. On EASY the MCVs already
+    sit inside their target regions (so this also wins easy — easy's
+    decision is solely "deploy all three, not zero"). On MEDIUM and
+    HARD the MCVs cluster at the west (or east) starter base and the
+    resulting facts land OUTSIDE every target region, so the pack's
+    three `building_in_region` predicates all fail → LOSS."""
+    cmds = []
+    for u in rs.get("units_summary") or []:
+        if str(u.get("type", "")).lower() == "mcv":
+            cmds.append(Command.deploy([str(u["id"])]))
+    return cmds or [Command.observe()]
+
+
+def make_deploy_only_two():
+    """Send MCVs to the first TWO regions, never the third. The
+    third region's `building_in_region` predicate is never satisfied
+    → LOSS on the deadline. Works on all tiers."""
+    state = {"assigned": {}, "deployed": set()}
+    # Only two of the three targets are used.
+    targets_pool = [MCV_TARGETS[0], MCV_TARGETS[1]]
+
+    def fn(rs, Command):
+        units = rs.get("units_summary") or []
+        mcvs = sorted(
+            [u for u in units if str(u.get("type", "")).lower() == "mcv"],
+            key=lambda u: u["id"],
+        )
+        # Stable id→target assignment, nearest-unused-target.
+        for u in mcvs:
+            if u["id"] not in state["assigned"] and len(state["assigned"]) < len(
+                targets_pool
+            ):
+                used = set(state["assigned"].values())
+                cands = [t for t in targets_pool if t not in used]
+                if not cands:
+                    continue
+                t = min(
+                    cands,
+                    key=lambda t: (t[0] - u["cell_x"]) ** 2
+                    + (t[1] - u["cell_y"]) ** 2,
+                )
+                state["assigned"][u["id"]] = t
+        cmds = []
+        for u in mcvs:
+            tgt = state["assigned"].get(u["id"])
+            if tgt is None:
+                continue
+            tx, ty = tgt
+            if abs(u["cell_x"] - tx) <= 1 and abs(u["cell_y"] - ty) <= 1:
+                if u["id"] not in state["deployed"]:
+                    cmds.append(Command.deploy([str(u["id"])]))
+                    state["deployed"].add(u["id"])
+            else:
+                cmds.append(Command.move_units([str(u["id"])], tx, ty))
+        return cmds or [Command.observe()]
+
+    return fn
+
+
+def make_intended_three_regions():
+    """The intended policy: assign each MCV to a DISTINCT target
+    region (nearest-unused), move it there, deploy. After all three
+    MCVs deploy, the agent owns ≥3 facts (existing west + 3 new)
+    AND each target region holds one fact → WIN."""
+    state = {"assigned": {}, "deployed": set()}
+
+    def fn(rs, Command):
+        units = rs.get("units_summary") or []
+        mcvs = sorted(
+            [u for u in units if str(u.get("type", "")).lower() == "mcv"],
+            key=lambda u: u["id"],
+        )
+        for u in mcvs:
+            if u["id"] in state["assigned"]:
+                continue
+            used = set(state["assigned"].values())
+            cands = [t for t in MCV_TARGETS if t not in used]
+            if not cands:
+                continue
+            t = min(
+                cands,
+                key=lambda t: (t[0] - u["cell_x"]) ** 2
+                + (t[1] - u["cell_y"]) ** 2,
+            )
+            state["assigned"][u["id"]] = t
+        cmds = []
+        for u in mcvs:
+            tgt = state["assigned"].get(u["id"])
+            if tgt is None:
+                continue
+            tx, ty = tgt
+            if abs(u["cell_x"] - tx) <= 1 and abs(u["cell_y"] - ty) <= 1:
+                if u["id"] not in state["deployed"]:
+                    cmds.append(Command.deploy([str(u["id"])]))
+                    state["deployed"].add(u["id"])
+            else:
+                cmds.append(Command.move_units([str(u["id"])], tx, ty))
+        return cmds or [Command.observe()]
+
+    return fn
+
+
+# ── tests ─────────────────────────────────────────────────────────────
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", HARD_SEEDS)
+def test_intended_three_regions_wins_every_level_every_seed(level, seed):
+    """The intended commit-each-MCV-to-its-own-region policy must WIN
+    on every level and every hard seed (1–4) — the no-defect bar."""
+    pack = load_pack(PACK)
+    c = compile_level(pack, level)
+    res = run_level(c, make_intended_three_regions(), seed=seed)
+    assert res.outcome == "win", (
+        f"{level} seed={seed}: intended-3-regions must WIN; got "
+        f"{res.outcome} (tick={res.signals.game_tick} "
+        f"buildings={res.signals.own_buildings})"
+    )
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", HARD_SEEDS)
+def test_stall_loses_every_level_every_seed(level, seed):
+    """The do-nothing policy: no MCV ever deploys → no new facts →
+    the early pre-fail (`after_ticks: 4000` AND <2 facts) bites well
+    before the deadline. Real reachable LOSS, never a DRAW."""
+    pack = load_pack(PACK)
+    c = compile_level(pack, level)
+    res = run_level(c, stall, seed=seed)
+    assert res.outcome == "loss", (
+        f"{level} seed={seed}: stall must LOSE; got {res.outcome} "
+        f"(tick={res.signals.game_tick})"
+    )
+
+
+@pytest.mark.parametrize("level", ("medium", "hard"))
+@pytest.mark.parametrize("seed", HARD_SEEDS)
+def test_bunch_at_base_loses_on_medium_and_hard(level, seed):
+    """On medium and hard the MCVs cluster at the west (or east, on
+    hard's seed-rotated group) starter base — deploying in place
+    lands every resulting fact OUTSIDE all three target regions, so
+    every `building_in_region` predicate fails and the run LOSES on
+    the deadline. (Easy MCVs already sit in their regions by design,
+    so bunch-in-place wins easy — the easy decision is solely "do
+    you deploy at all"; only medium/hard test the distribution
+    capability.)"""
+    pack = load_pack(PACK)
+    c = compile_level(pack, level)
+    res = run_level(c, bunch_in_place, seed=seed)
+    assert res.outcome == "loss", (
+        f"{level} seed={seed}: bunch-in-place must LOSE; got "
+        f"{res.outcome} (buildings={res.signals.own_buildings})"
+    )
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", HARD_SEEDS)
+def test_deploy_only_two_regions_loses(level, seed):
+    """Partial coverage policy: only the FIRST TWO target regions get
+    a fact; the THIRD is abandoned. The third region's
+    `building_in_region` predicate is never satisfied → LOSS, on
+    every tier and every seed."""
+    pack = load_pack(PACK)
+    c = compile_level(pack, level)
+    res = run_level(c, make_deploy_only_two(), seed=seed)
+    assert res.outcome == "loss", (
+        f"{level} seed={seed}: deploy-only-two-regions must LOSE; "
+        f"got {res.outcome} (buildings={res.signals.own_buildings})"
+    )
+
+
+def test_within_ticks_is_reachable_per_tier():
+    """Tick/turn alignment: the within_ticks deadline must be inside
+    max_turns (tick ≤ 93 + 90·(max_turns − 1)) — otherwise a staller
+    DRAWS instead of LOSING. Re-derived per tier."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        max_tick = 93 + 90 * (c.max_turns - 1)
+        assert 6300 <= max_tick, (
+            f"{lvl}: within_ticks=6300 > reachable max_tick="
+            f"{max_tick} (would draw instead of losing)"
+        )
+
+
+def test_hard_has_two_spawn_groups_with_distinct_starts():
+    """Hard-tier curation contract: ≥2 agent spawn_point groups, and
+    the seeds (1, 2, 3, 4) must actually produce ≥2 distinct starts
+    on the live engine (the whole MCV CLUSTER rotates between WEST
+    and EAST). Mirrors `tests/test_hard_tier.py` for early signal."""
+    from pathlib import Path
+
+    from openra_bench.eval_core import _scenario_to_tmp_yaml, RustEnvPool
+    from openra_bench.rust_adapter import RustObsAdapter
+
+    pack = load_pack(PACK)
+    c = compile_level(pack, "hard")
+    sp = {
+        (a.spawn_point if a.spawn_point is not None else 0)
+        for a in c.scenario.actors
+        if a.owner == "agent"
+    }
+    assert len(sp) >= 2, (
+        f"hard must define ≥2 agent spawn_point groups; got {sorted(sp)}"
+    )
+
+    starts = set()
+    tmp = _scenario_to_tmp_yaml(c)
+    pool = RustEnvPool(size=1, scenario_path=tmp)
+    env = pool.acquire()
+    try:
+        for seed in HARD_SEEDS:
+            ad = RustObsAdapter()
+            ad.observe(env.reset(seed=seed))
+            u = ad.render_state().get("units_summary", []) or []
+            mcvs = sorted(
+                (x["cell_x"], x["cell_y"])
+                for x in u
+                if str(x.get("type", "")).lower() == "mcv"
+            )
+            starts.add(tuple(mcvs))
+    finally:
+        pool.release(env)
+        pool.shutdown()
+        Path(tmp).unlink(missing_ok=True)
+    assert len(starts) >= 2, (
+        f"hard seeds {HARD_SEEDS} produced identical MCV starts "
+        f"{starts}; spawn_point round-robin not taking effect"
+    )
+
+
+def test_meta_benchmark_anchor_carries_required_strings():
+    """The pack must declare the four benchmark / real-world anchors
+    the brief required (SC2LE / MicroRTS / distribution-network /
+    tri-region operational footprint)."""
+    pack = load_pack(PACK)
+    anchors = set(pack.meta.benchmark_anchor)
+    required = {
+        "SC2LE 3-base macro",
+        "MicroRTS multi-front expansion",
+        "distribution-network multi-warehouse planning",
+        "tri-region operational footprint",
+    }
+    assert required.issubset(anchors), (
+        f"missing benchmark anchors: {required - anchors}"
+    )
+
+
+def test_pack_compiles_with_arena_base_map():
+    """The pack-level base_map is a known-supported sentinel; the
+    real generator-spec arena is materialised per-level via
+    `overrides.base_map` (the documented idiom — a Level-level
+    `base_map` outside `overrides:` is silently ignored). All three
+    levels must compile onto the generated arena."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.scenario.base_map == "mcv-deploy-third-base-arena", (
+            f"{lvl}: expected mcv-deploy-third-base-arena, got "
+            f"{c.scenario.base_map}"
+        )
+        assert c.map_supported, (
+            f"{lvl}: mcv-deploy-third-base-arena must resolve to a "
+            "real .oramap (mapgen materialise should have written it)"
+        )