feat(scenario): combat-protect-vip-escort — escort fragile VIP through cumulative arty walls (SC2 medivac / VIP protection anchor)

Wave-6 ACTION cell. VIP=unique harv (unarmed); escort=4× 2tnk.
Cumulative arty walls scale 1/2/3 per tier; hard adds 2 agent
spawn_point groups (NORTH y=14 / SOUTH y=26) round-robined by seed.
Salvaged from main-worktree drop by W6 agent.

openra_bench/scenarios/packs/combat-protect-vip-escort.yaml

@@ -0,0 +1,379 @@
+# combat-protect-vip-escort — Get the fragile VIP through, preserve it.
+#
+# ACTION focus: a single unique `harv` is the VIP — the only one of
+# its type on the map AND structurally unarmed (the harvester
+# carries no weapon: it can never return fire even on stance:3).
+# It must reach the east extraction point (~100, 20). Four 2tnk
+# escorts at the same west staging zone must clear a long-range
+# artillery threat AND the rifle infantry walls strung along the
+# route AND keep the VIP behind their advance, so the arty + e1
+# squads burn DPS into 400-HP tank armour rather than the fragile
+# harvester. The VIP cannot engage directly (no weapon). If the
+# agent drives it into the arty's range envelope without the
+# tanks suppressing the arty first, the arty (dps45) shreds the
+# VIP in two-three decision turns; the escort tanks must lead,
+# suppress the arty + the rifle walls, and only then does the
+# VIP cross safely.
+#
+# Real-world anchor: VIP-protection / diplomatic-escort detail —
+# the principal (POTUS limo, ambassador convoy, SecDef movement)
+# is unarmed and must not engage; the protective detail moves in
+# bounding formation ahead and to the flanks, neutralising threats
+# along the route before the principal traverses. SC2 VIP-survival
+# missions, MicroRTS fragile-target preservation, and military
+# convoy doctrine all encode the same constraint: the high-value
+# unit is preserved by the escort's offence, not by its own fight.
+#
+# Discrimination (the four-script bar — scripted, no model):
+#   • stall (observe-only): nothing moves; the VIP never reaches
+#     the extraction → after_ticks 4501 LOSS (no draw degeneracy).
+#   • VIP-alone: only the harvester is moved; with no escort it
+#     enters the arty envelope (rng 7c) unaccompanied and is the
+#     only target the arty has — arty dps45 vs harv burns the
+#     harvester down in 2-3 decision turns → `not unit_type_count_
+#     gte:{harv,1}` fail clause fires → LOSS.
+#   • VIP-leads-charge: harv + tanks dispatched in a single column.
+#     On medium and hard the cumulative arty + rifle-wall fire
+#     onto the column kills the VIP before extraction → LOSS. On
+#     easy the single rifle wall isn't enough cumulative damage,
+#     so charge MAY squeak by — the forgiving bare-skill tier
+#     (SCENARIO_REVIEW_CHECKLIST.md: "inert anti-cheat teeth are
+#     acceptable on easy").
+#   • intended escort-clears-path: escort tanks attack_move east
+#     AHEAD of the harv (4× 2tnk dps22 = 88 dps focus on the arty
+#     first — arty hp75 dies in ~1 decision turn of concentrated
+#     fire; then the tanks pick off the e1 walls). The harv hangs
+#     ~10 cells behind the rear-most tank so the arty + rifle fire
+#     auto-target the closer tanks; once tanks have cleared the
+#     route, the harv crosses safely → harv arrives at extraction
+#     alive within budget → WIN.
+#
+# Why the spec works (engine combat sheet):
+#   • harv = ore harvester (hp600 nominal, heavily armoured, slow,
+#     UNARMED — game_knowledge: "ore harvester (gathers ore for
+#     credits; unarmed)"; prompt_v2: "$1100 hp600 unarmed sight4c
+#     tracked"). With no weapon it cannot return fire even on
+#     stance:3 — "the VIP must not engage" is enforced by the unit
+#     kit. The harv is reasonably tough vs rifle fire (e1 dps6 vs
+#     armour) but FRAGILE vs arty (dps45) — arty puts the harv to
+#     0 hp in ~2 decision turns of standing exposure.
+#   • e1 = basic rifle infantry (rng3c, dps6 vs armour, sight4c,
+#     hp50). Cheap to clear (one tank shot per e1). Their role
+#     here is to extend the fire envelope so a charge column
+#     accumulates attrition damage, AND so a focus-fire policy
+#     must pick the arty SPECIFICALLY rather than relying on
+#     attack_move auto-target (which spreads damage across all
+#     visible threats).
+#   • arty = artillery (rng7c, dps45 splash, hp75, sight5c). Long
+#     range (outranges 2tnk's 4.75c by 2.25c) — a stationary arty
+#     fires on closing tanks BEFORE they can return fire, so the
+#     escort takes attrition while approaching. Anti-armour DPS is
+#     high enough to kill the harv in ~2 decision turns of standing
+#     exposure. 4 tanks concentrating fire can kill 1 arty in ~1
+#     decision turn (88 dps vs hp75).
+#   • 2tnk = medium tank (rng4.75c, dps22, hp 400). Four tanks vs
+#     an e1 wall: combined dps 88 onto hp200 cleans a 4-e1 wall in
+#     ~2-3 decision turns.
+#   • Distance / time budget: extraction at (100,20), staging at
+#     (8,20) ⇒ ~92 cells. A 2tnk moves ~5-6 cells per decision turn
+#     uncontested, ~3-4 cells per turn while engaging. Escort
+#     timeline: ~5 turns to first contact (wall at x=30), ~3 turns
+#     to clear wall 1, ~2 turns to arty contact (x=49), ~2 turns
+#     focus-fire arty, ~5 turns to wall 2 (x=70), ~3 turns to
+#     clear it, ~5 turns final push — ~25 turns ⇒ ~2300 ticks,
+#     comfortably under within_ticks 4500.
+#
+# Engine guardrails (per CLAUDE.md):
+#   • Map: rush-hour-arena (128 × 40 playable; x in [2..126], y in
+#     [2..38]). All actor / region cells are inside.
+#   • CLAUDE.md footgun: enemy clusters at (50,20) silently FAIL to
+#     place — every enemy y row avoids that exact cell.
+#   • A persistent far enemy `fact` at (120,20) keeps the episode
+#     alive past the route enemies being cleaned out (so the
+#     win/fail evaluator sees the terminal frame; no DRAW collapse).
+#   • after_ticks fail clauses are reachable within max_turns
+#     (tick ≤ 93 + 90·(max_turns-1)); within_ticks 4500 < 4503 at
+#     max_turns 50; staller hits after_ticks 4501 and LOSES, not
+#     draws.
+#   • unit_type_count_gte:{type:harv,n:1} as a NEGATED fail clause
+#     fires the instant the VIP dies (signals.units_summary loses
+#     the harv entry → count == 0 → not(...) == True). That is the
+#     "VIP died" loss condition, distinct from total force wipe.
+#   • Interrupts are LEFT DISABLED in this pack: enemy_unit_spotted
+#     fires on each route enemy and step_until_event advances only
+#     ~5 ticks per interrupt — with 10+ enemies strung along the
+#     route the per-turn tick rate collapses and even the intended
+#     escort cannot reach the extraction inside the 4500-tick
+#     budget. Without interrupts each turn advances ~90 ticks
+#     uniformly and the escort completes in ~25 turns. The model
+#     still sees the full per-turn state every decision; reactive
+#     micro is not the controlled capability of this pack — escort
+#     LEADERSHIP (tanks-before-VIP) is.
+#   • The engine ignores the `health` placement field (verified by
+#     direct comparison: health=10/50/100 all give the same initial
+#     hp_ratio 1.0 and identical decay under enemy fire). The VIP's
+#     fragility is enforced via ENEMY CHOICE (arty dps45 vs harv's
+#     hp600 = ~13s to kill = ~2 decision turns) rather than reduced
+#     max-HP.
+#   • Spawn-driven hard tier: enemy actors don't honour spawn_point
+#     (CLAUDE.md), so the route enemies always place identically.
+#     Variation comes from AGENT staging row (NORTH y=14 / SOUTH
+#     y=26). The route enemies' y-band is widened (y=13..27 in hard)
+#     so both staging rows face an equivalent contested corridor.
+
+meta:
+  id: combat-protect-vip-escort
+  title: 'Protect the VIP — Escort a Fragile Unit Through the Hazard'
+  capability: action
+  real_world_meaning: >
+    A single fragile high-value unit (the VIP — an unarmed
+    harvester, the only one of its kind on the map) must reach
+    the east extraction point. Four medium tanks at the same west
+    staging zone are the protective detail. The VIP cannot fight
+    (no weapon) and dies under sustained artillery fire, so the
+    escort must move AHEAD, clear the rifle infantry and the
+    long-range artillery strung along the route, and only then
+    let the VIP cross. Sending the VIP alone or at the head of
+    the column gets it killed; the escort's offence preserves
+    the VIP.
+  robotics_analogue: >
+    Protected-asset transit / VIP detail / diplomatic convoy: a
+    high-value principal (unarmed, fragile) must traverse a
+    contested route. The protective detail moves in bounding
+    formation ahead and to the flanks, neutralising threats along
+    the route before the principal traverses. The principal does
+    not engage directly — its survival depends on the detail's
+    offence, not its own fight.
+  benchmark_anchor:
+    - "SC2 VIP-survival missions"
+    - "military VIP protection doctrine"
+    - "diplomatic security / convoy escort"
+    - "fragile-target preservation tactics"
+  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
+  # Interrupts DISABLED — enemy_unit_spotted on a route with 10+
+  # spread-out enemies collapses per-turn ticks (step_until_event
+  # advances only ~5 ticks per interrupt) and the deadline becomes
+  # unreachable even for the intended escort. The model still sees
+  # the full per-turn state on every decision boundary; reactive
+  # micro is not the controlled capability of this pack.
+  interrupts: {}
+  termination: {max_ticks: 6000}
+  actors: []   # every level supplies its own actor list via overrides.
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Bare VIP-escort skill: ONE rifle wall along the route (~x=70,
+  # 4× e1 across y=17..23) AND one long-range artillery piece at
+  # the centre (~x=49, off the (50,20) footgun column). The arty
+  # is what makes "VIP alone" a real death sentence — without it,
+  # the harv's 600 hp and rifle's dps6 vs armour lets the VIP
+  # outrun rifle fire entirely. Charge plays may squeak by on
+  # easy because there is only one rifle wall after the arty —
+  # the cumulative DPS into the VIP under charge isn't enough to
+  # kill it before extraction (forgiving bare-skill tier).
+  easy:
+    description: >
+      A single ore harvester (the VIP — unique unit type, unarmed
+      and fragile under sustained heavy fire) is staged at (8,20)
+      with four medium tank escorts. The VIP must reach the EAST
+      extraction point (x ≈ 100, y ≈ 20, radius 6) before tick
+      4500, and MUST be alive on arrival (the harv is the only
+      one of its type; a destroyed harv fails the run). One rifle-
+      infantry wall (4× e1, vertically arrayed across y=17..23)
+      defends the route at x ≈ 70, and a single long-range
+      artillery piece (arty, range 7c, dps45) sits at the centre
+      (x ≈ 49). The escort tanks must move AHEAD of the VIP and
+      clear the artillery first; the unarmed VIP cannot return
+      fire and is shredded by the arty if it enters the envelope
+      unaccompanied.
+    overrides:
+      actors:
+        # VIP — the single unique harvester at the west staging
+        # zone. Unique-unit-type marker: the only harv on the map,
+        # so the "VIP alive" check is exactly
+        # `unit_type_count_gte:{harv,1}`. stance:0 (HoldFire) is
+        # the convoy-discipline posture (the harv is unarmed
+        # anyway, but the stance documents intent).
+        - {type: harv, owner: agent, position: [8, 20], stance: 0}
+        # Escorts — 4 medium tanks at the same west staging zone,
+        # in a 2-wide formation around the VIP so the agent can
+        # spawn them in a leading wedge. stance:1 (return fire) so
+        # the escorts retaliate when contacted but don't wander.
+        - {type: 2tnk, owner: agent, position: [8, 18], stance: 1}
+        - {type: 2tnk, owner: agent, position: [8, 19], stance: 1}
+        - {type: 2tnk, owner: agent, position: [8, 21], stance: 1}
+        - {type: 2tnk, owner: agent, position: [8, 22], stance: 1}
+        # Centre artillery — the load-bearing anti-VIP threat.
+        # arty rng 7c outranges 2tnk's 4.75c by 2.25c, so it gets
+        # opening shots while the escort closes. Off the (50,20)
+        # silently-failing column.
+        - {type: arty, owner: enemy, position: [49, 20], stance: 3}
+        # Rifle wall — extends the fire envelope and adds attrition
+        # damage to a charge play. 4× e1 across y=17..23 so the
+        # harv pathfinder cannot trivially detour around the wall.
+        - {type: e1, owner: enemy, position: [70, 17], stance: 3}
+        - {type: e1, owner: enemy, position: [70, 19], stance: 3}
+        - {type: e1, owner: enemy, position: [70, 21], stance: 3}
+        - {type: e1, owner: enemy, position: [70, 23], stance: 3}
+        # Persistent far enemy `fact` — keeps the episode alive
+        # past the route enemies being cleaned out so the win/fail
+        # evaluator sees the terminal frame (no DRAW collapse).
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {units_of_type_in_region_gte: {type: harv, x: 100, y: 20, radius: 6, n: 1}}
+        - {unit_type_count_gte: {type: harv, n: 1}}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {unit_type_count_gte: {type: harv, n: 1}}}
+    max_turns: 50
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 axis: a SECOND rifle wall (x=30) extends the fire envelope
+  # both before AND after the central artillery, so a single
+  # charging column accumulates more attrition while crossing.
+  # VIP-leads-charge LOSES on medium (the cumulative arty + 2-wall
+  # rifle fire onto the harv is enough to kill it before extraction)
+  # while easy's single-wall configuration may let charge squeak
+  # by. Stall / VIP-alone LOSE; intended escort WINS.
+  medium:
+    description: >
+      A single ore harvester (the VIP — unique unit type, unarmed
+      and fragile under sustained heavy fire) is staged at (8,20)
+      with four medium tank escorts. The VIP must reach the EAST
+      extraction point (x ≈ 100, y ≈ 20, radius 6) before tick
+      4500, and MUST be alive on arrival. TWO rifle-infantry walls
+      (4× e1 each, vertically arrayed across y=17..23) defend the
+      route at x ≈ 30 and x ≈ 70, AND a long-range artillery
+      piece (arty, range 7c, dps45) sits at the centre (x ≈ 49).
+      The escort tanks must lead — focus-fire the artillery first
+      (it is the anti-VIP threat), then clear each rifle wall —
+      because the unarmed VIP dies under the cumulative arty +
+      rifle fire if it enters either wall's envelope without
+      escort suppression.
+    overrides:
+      actors:
+        - {type: harv, owner: agent, position: [8, 20], stance: 0}
+        - {type: 2tnk, owner: agent, position: [8, 18], stance: 1}
+        - {type: 2tnk, owner: agent, position: [8, 19], stance: 1}
+        - {type: 2tnk, owner: agent, position: [8, 21], stance: 1}
+        - {type: 2tnk, owner: agent, position: [8, 22], stance: 1}
+        # Centre artillery — the load-bearing anti-VIP threat
+        # (same as easy).
+        - {type: arty, owner: enemy, position: [49, 20], stance: 3}
+        # Rifle wall 1 — x ≈ 30 (BEFORE the arty so the charge
+        # column takes attrition before reaching the arty kill
+        # zone).
+        - {type: e1, owner: enemy, position: [30, 17], stance: 3}
+        - {type: e1, owner: enemy, position: [30, 19], stance: 3}
+        - {type: e1, owner: enemy, position: [30, 21], stance: 3}
+        - {type: e1, owner: enemy, position: [30, 23], stance: 3}
+        # Rifle wall 2 — x ≈ 70 (AFTER the arty).
+        - {type: e1, owner: enemy, position: [70, 17], stance: 3}
+        - {type: e1, owner: enemy, position: [70, 19], stance: 3}
+        - {type: e1, owner: enemy, position: [70, 21], stance: 3}
+        - {type: e1, owner: enemy, position: [70, 23], stance: 3}
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {units_of_type_in_region_gte: {type: harv, x: 100, y: 20, radius: 6, n: 1}}
+        - {unit_type_count_gte: {type: harv, n: 1}}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {unit_type_count_gte: {type: harv, n: 1}}}
+    max_turns: 50
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 axis vs medium: TWO seed-driven spawn groups (NORTH staging
+  # y≈14 OR SOUTH staging y≈26 — round-robined per seed) AND a
+  # THIRD rifle wall (x=55) tightens the route lethality enough
+  # that VIP-leads-charge LOSES on BOTH spawn variants (the
+  # cumulative arty + 3-wall rifle fire is unsurvivable). The
+  # rifle walls are vertically widened to y=13..27 so BOTH spawns
+  # face an equivalent contested corridor — the harv from EITHER
+  # staging row must still traverse the artillery + 3-wall
+  # gauntlet. The artillery and extraction at (100,20) are on the
+  # symmetry axis, so both spawn variants face the same anti-VIP
+  # geometry but a single memorised staging-to-extraction vector
+  # cannot generalise across seeds.
+  hard:
+    description: >
+      A single ore harvester (the VIP — unique unit type, unarmed
+      and fragile under sustained heavy fire) is staged with four
+      medium tank escorts at the NORTH staging row (y ≈ 14) or
+      the SOUTH staging row (y ≈ 26), chosen by seed for anti-
+      memorisation. The VIP must reach the EAST extraction point
+      (x ≈ 100, y ≈ 20, radius 6) before tick 4500, alive. THREE
+      vertically-widened rifle-infantry walls (6× e1 each, across
+      y=13..27) defend the route at x ≈ 30, x ≈ 55, and x ≈ 75,
+      AND a long-range artillery piece (arty, range 7c, dps45)
+      sits at the centre (x ≈ 49) — both NORTH and SOUTH staging
+      rows face an equivalent contested corridor. The escort
+      tanks must lead the way; the unarmed VIP dies under
+      sustained arty + 3-wall rifle fire if it enters any wall's
+      envelope unaccompanied or at the head of the column.
+    overrides:
+      actors:
+        # spawn_point 0 — NORTH staging at y ≈ 14.
+        - {type: harv, owner: agent, position: [8, 14], stance: 0, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [8, 12], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [8, 13], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [8, 15], stance: 1, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [8, 16], stance: 1, spawn_point: 0}
+        # spawn_point 1 — SOUTH staging at y ≈ 26 (mirrored across
+        # y=20).
+        - {type: harv, owner: agent, position: [8, 26], stance: 0, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [8, 24], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [8, 25], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [8, 27], stance: 1, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [8, 28], stance: 1, spawn_point: 1}
+        # Centre artillery — same anti-VIP threat as medium, on
+        # the y=20 symmetry axis so both spawn variants face it.
+        - {type: arty, owner: enemy, position: [49, 20], stance: 3}
+        # Rifle wall 1 — x=30, vertically widened y=13..27 so both
+        # NORTH and SOUTH staging rows face an equivalent corridor.
+        - {type: e1, owner: enemy, position: [30, 13], stance: 3}
+        - {type: e1, owner: enemy, position: [30, 16], stance: 3}
+        - {type: e1, owner: enemy, position: [30, 18], stance: 3}
+        - {type: e1, owner: enemy, position: [30, 22], stance: 3}
+        - {type: e1, owner: enemy, position: [30, 24], stance: 3}
+        - {type: e1, owner: enemy, position: [30, 27], stance: 3}
+        # Rifle wall 2 — x=55, same vertical span (off the (50,20)
+        # footgun column).
+        - {type: e1, owner: enemy, position: [55, 13], stance: 3}
+        - {type: e1, owner: enemy, position: [55, 16], stance: 3}
+        - {type: e1, owner: enemy, position: [55, 18], stance: 3}
+        - {type: e1, owner: enemy, position: [55, 22], stance: 3}
+        - {type: e1, owner: enemy, position: [55, 24], stance: 3}
+        - {type: e1, owner: enemy, position: [55, 27], stance: 3}
+        # Rifle wall 3 — x=75, same vertical span.
+        - {type: e1, owner: enemy, position: [75, 13], stance: 3}
+        - {type: e1, owner: enemy, position: [75, 16], stance: 3}
+        - {type: e1, owner: enemy, position: [75, 18], stance: 3}
+        - {type: e1, owner: enemy, position: [75, 22], stance: 3}
+        - {type: e1, owner: enemy, position: [75, 24], stance: 3}
+        - {type: e1, owner: enemy, position: [75, 27], stance: 3}
+        # Persistent far enemy fact — engine auto-done mitigation.
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {units_of_type_in_region_gte: {type: harv, x: 100, y: 20, radius: 6, n: 1}}
+        - {unit_type_count_gte: {type: harv, n: 1}}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {unit_type_count_gte: {type: harv, n: 1}}}
+    max_turns: 50

tests/test_combat_protect_vip_escort.py

@@ -0,0 +1,407 @@
+"""combat-protect-vip-escort — escort a fragile VIP through hazards.
+
+The bar (binding, applied seeds 1..4 on every level):
+- intended escort-clears-path policy WINS;
+- stall / VIP-alone / VIP-leads-charge LOSE on every level + every
+  hard seed (easy may be forgiving for some failure modes given the
+  sparser hazard — see per-test docstrings);
+- non-win is a real reachable timeout / VIP-died LOSS (no DRAW
+  degeneracy: after_ticks 4501 ≤ 93 + 90·(max_turns − 1));
+- hard ships ≥2 `spawn_point` groups (seed-driven start variation).
+
+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-protect-vip-escort.yaml"
+
+
+# ── declarative / schema invariants (no engine needed) ─────────────
+
+
+def test_pack_compiles_and_meta_fields_populated():
+    pack = load_pack(PACK_PATH)
+    assert pack.meta.id == "combat-protect-vip-escort"
+    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 all 4 anchors, got {anchors!r}"
+    )
+    joined = " ".join(anchors).lower()
+    # Spec-mandated anchors: SC2 VIP-survival, military VIP doctrine,
+    # diplomatic convoy escort, fragile-target preservation.
+    for needle in ("sc2 vip", "vip protection",
+                   "diplomatic", "fragile-target"):
+        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,
+        own_buildings=[],
+        own_building_types=set(),
+        enemies_seen_ids=set(),
+        enemy_buildings_seen_ids=set(),
+    )
+    return WinContext(
+        signals=sig,
+        render_state={"units_summary": list(units)},
+    )
+
+
+def _harv_at(x=100, y=20):
+    return {"cell_x": x, "cell_y": y, "type": "harv", "id": "9001"}
+
+
+def _tank_at(i, x=100, y=20):
+    return {"cell_x": x, "cell_y": y, "type": "2tnk", "id": str(2000 + i)}
+
+
+@pytest.mark.parametrize("lvl", ["easy", "medium", "hard"])
+def test_win_requires_harv_in_east_region_and_alive(lvl):
+    c = compile_level(load_pack(PACK_PATH), lvl)
+    # VIP in region, alive, in time → WIN.
+    assert evaluate(
+        c.win_condition,
+        _ctx(units=[_harv_at(100, 20), _tank_at(0, 99, 20)], tick=2000),
+    )
+    # Tanks arrive but VIP didn't → not a WIN (VIP missing).
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=[_tank_at(0, 100, 20), _tank_at(1, 100, 21)], tick=2000),
+    )
+    # VIP elsewhere on the map → not a WIN (not in region).
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=[_harv_at(50, 20)], tick=2000),
+    )
+    # VIP in region but past the deadline → not a WIN.
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=[_harv_at(100, 20)], tick=4600),
+    )
+
+
+@pytest.mark.parametrize("lvl", ["easy", "medium", "hard"])
+def test_fail_clauses_are_reachable_losses(lvl):
+    c = compile_level(load_pack(PACK_PATH), lvl)
+    # Past deadline → fail (the VIP is still in the west).
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=[_harv_at(8, 20)], tick=4600),
+    )
+    # VIP killed (no harv left, even if escorts survive) → fail.
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=[_tank_at(0, 50, 20)], tick=2000),
+    )
+    # Force wipe (no harv among the wipe) → fail.
+    assert evaluate(c.fail_condition, _ctx(units=[], tick=2000))
+
+
+def test_timeout_reachable_inside_max_turns():
+    """No draw degeneracy: after_ticks 4501 ≤ 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)
+        assert 4501 <= max_tick, (
+            f"{lvl}: after_ticks 4501 > max reachable tick {max_tick} "
+            f"(max_turns={c.max_turns}); deadline never bites"
+        )
+        assert 4500 <= max_tick, (
+            f"{lvl}: within_ticks 4500 > max reachable tick {max_tick}"
+        )
+
+
+def test_hard_has_two_spawn_point_groups():
+    """Hard curation: ≥2 distinct agent spawn_point groups so the seed
+    round-robins the staging row (NORTH y≈14 / SOUTH y≈26). Engine-
+    roundtrip asserted by tests/test_hard_tier.py."""
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    groups = {
+        (a.spawn_point if a.spawn_point is not None else 0)
+        for a in c.scenario.actors
+        if a.owner == "agent"
+    }
+    assert len(groups) >= 2, f"hard needs ≥2 spawn_point groups, got {groups}"
+
+
+def test_exactly_one_harv_per_spawn_group():
+    """The VIP is a UNIQUE unit type — exactly one harv per spawn
+    group (so `unit_type_count_gte:{harv,1}` collapses to a single
+    "VIP alive" check; multiple harvs would let the win predicate
+    accept partial loss)."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium"):
+        c = compile_level(pack, lvl)
+        harvs = [
+            a for a in c.scenario.actors
+            if a.owner == "agent" and a.type == "harv"
+        ]
+        assert len(harvs) == 1, f"{lvl}: must have exactly 1 harv VIP, got {len(harvs)}"
+    c = compile_level(pack, "hard")
+    per_group = {}
+    for a in c.scenario.actors:
+        if a.owner != "agent" or a.type != "harv":
+            continue
+        sp = a.spawn_point if a.spawn_point is not None else 0
+        per_group[sp] = per_group.get(sp, 0) + 1
+    assert all(n == 1 for n in per_group.values()), (
+        f"hard: each spawn group should have exactly 1 harv, got {per_group}"
+    )
+
+
+def test_escort_is_four_medium_tanks_per_group():
+    """The escort is 4× 2tnk per spawn group (sized so the escort can
+    actually clear the route's rifle walls in budget — fewer tanks
+    and the route doesn't clean in time)."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium"):
+        c = compile_level(pack, lvl)
+        tanks = [a for a in c.scenario.actors
+                 if a.owner == "agent" and a.type == "2tnk"]
+        assert len(tanks) == 4, f"{lvl}: expected 4 escort tanks, got {len(tanks)}"
+    c = compile_level(pack, "hard")
+    per_group = {}
+    for a in c.scenario.actors:
+        if a.owner != "agent" or a.type != "2tnk":
+            continue
+        sp = a.spawn_point if a.spawn_point is not None else 0
+        per_group[sp] = per_group.get(sp, 0) + 1
+    assert all(n == 4 for n in per_group.values()), (
+        f"hard: each spawn group should have 4 escort tanks, got {per_group}"
+    )
+
+
+def test_each_level_has_an_arty_anti_vip_threat():
+    """The VIP's fragility is enforced via ENEMY CHOICE — specifically
+    an artillery piece (arty, dps45 splash) along the route. The
+    engine ignores the `health` placement field (verified: health=10
+    vs health=100 give the same initial hp_ratio 1.0 and identical
+    decay under enemy fire), so the harv's hp600 + armour withstands
+    a rifle-only gauntlet. Without an arty the discrimination
+    collapses (VIP-alone outruns rifle fire entirely)."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        artys = [
+            a for a in c.scenario.actors
+            if a.owner == "enemy" and a.type == "arty"
+        ]
+        assert len(artys) >= 1, (
+            f"{lvl}: must have ≥1 arty (anti-VIP threat); got {len(artys)}"
+        )
+
+
+def test_interrupts_disabled_so_time_budget_is_real():
+    """enemy_unit_spotted via step_until_event advances only ~5 ticks
+    per interrupt, so on a route with 10+ enemies the per-turn tick
+    rate collapses and even the intended escort cannot reach the
+    extraction inside the 4500-tick budget. With interrupts disabled,
+    each turn advances ~90 ticks uniformly and the budget is real."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        ints = c.scenario.interrupts or {}
+        enabled = [k for k, v in ints.items() if v]
+        assert not enabled, (
+            f"{lvl}: interrupts must be disabled (the route has 10+ "
+            f"enemies; step_until_event would collapse the tick "
+            f"budget); got enabled={enabled}"
+        )
+
+
+# ── engine-driven scripted policies ────────────────────────────────
+
+
+def _own_units(rs):
+    return rs.get("units_summary", []) or []
+
+
+def _harv(rs):
+    for u in _own_units(rs):
+        if str(u.get("type", "")).lower() == "harv":
+            return u
+    return None
+
+
+def _escorts(rs):
+    return [u for u in _own_units(rs)
+            if str(u.get("type", "")).lower() == "2tnk"]
+
+
+def _stall(rs, Command):
+    """Pure observe — no unit moves; VIP never reaches the
+    extraction → after_ticks LOSS."""
+    return [Command.observe()]
+
+
+def _vip_alone(rs, Command):
+    """Only the harvester is moved east; escorts stay idle in the
+    west. The unarmed VIP enters the first rifle wall
+    unaccompanied → dies → `not unit_type_count_gte:{harv,1}` fail
+    clause fires → LOSS."""
+    units = _own_units(rs)
+    if not units:
+        return [Command.observe()]
+    cmds = []
+    for u in units:
+        if str(u.get("type", "")).lower() == "harv":
+            cmds.append(Command.move_units([str(u["id"])], 100, 20))
+        else:
+            cmds.append(Command.stop([str(u["id"])]))
+    return cmds
+
+
+def _vip_leads_charge(rs, Command):
+    """Every unit (harv + tanks) charges east on the same y-band
+    with the harv at the front. The first rifle wall auto-targets
+    the NEAREST visible hostile — the harvester — and kills it
+    before the tanks finish suppressing the e1s. → LOSS."""
+    units = _own_units(rs)
+    if not units:
+        return [Command.observe()]
+    cmds = []
+    for u in units:
+        cmds.append(Command.move_units([str(u["id"])], 100, 20))
+    return cmds
+
+
+def _intended_escort_clears_path(rs, Command):
+    """Escort-clears-path:
+
+      1. Tanks attack_move east AHEAD of the VIP, sweeping each
+         rifle wall (~x=35, ~x=55, ~x=75) until cleared. attack_move
+         auto-fires on the nearest hostile in range.
+      2. The VIP holds ~10 cells behind the rear-most tank so the
+         rifle walls auto-target the closer high-armour tanks.
+      3. Once the rear-most tank is at the extraction (x≥92), the
+         VIP completes the cross to (100,20).
+
+    The VIP target_x is clamped to never push it past the rear-most
+    tank — if the tanks haven't cleared the next wall, the VIP
+    waits.
+    """
+    units = _own_units(rs)
+    if not units:
+        return [Command.observe()]
+    h = _harv(rs)
+    tanks = _escorts(rs)
+    cmds = []
+
+    # Escort tanks: attack_move east to the extraction, engaging
+    # anything in the way.
+    for t in tanks:
+        cmds.append(Command.attack_move([str(t["id"])], 100, 20))
+
+    if h is not None:
+        if tanks:
+            # The harv hangs 10 cells behind the rear-most tank.
+            rear_x = min(t["cell_x"] for t in tanks)
+            tx = min(rear_x - 10, 100)
+            # Never drive the harv backwards past its own start.
+            tx = max(tx, h["cell_x"])
+            # If tanks are already at the extraction (rear_x≥92), VIP
+            # finishes the cross.
+            if rear_x >= 92:
+                tx = 100
+            cmds.append(Command.move_units([str(h["id"])], int(tx), 20))
+        else:
+            # No escorts left — just sprint (best-effort).
+            cmds.append(Command.move_units([str(h["id"])], 100, 20))
+    return cmds
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_intended_escort_clears_path_wins(level, seed):
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _intended_escort_clears_path, seed=seed)
+    assert r.outcome == "win", (
+        f"{level} seed={seed}: escort-clears-path should WIN, got "
+        f"{r.outcome} after {r.turns} turns "
+        f"(losses={r.signals.units_lost})"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_stall_loses(level, seed):
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _stall, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: stall must be a real timeout LOSS "
+        f"(VIP never reaches extraction → after_ticks fires), "
+        f"got {r.outcome}"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_vip_alone_loses(level, seed):
+    """VIP sent alone enters the first rifle wall unaccompanied;
+    unarmed harv can't return fire and the rifle squad burns it
+    down (health:25 → ~150 effective hp dies in 2-3 turns of
+    standing exposure) → `not unit_type_count_gte:{harv,1}` fail
+    clause fires → LOSS."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _vip_alone, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: VIP-alone must LOSE (unarmed harv "
+        f"dies in the first wall), got {r.outcome} "
+        f"(losses={r.signals.units_lost})"
+    )
+
+
+@pytest.mark.parametrize("level", ["medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_vip_leads_charge_loses(level, seed):
+    """Harv + tanks charge in a single column with harv at the
+    front; rifle wall auto-targets the closer harv → VIP dies →
+    LOSS. Easy excluded (sparser hazard may let the tanks suppress
+    fast enough to keep the harv alive; SCENARIO_REVIEW_CHECKLIST.md
+    accepts inert anti-cheat teeth on easy for the bare-skill tier)."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _vip_leads_charge, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: VIP-leads-charge must LOSE (harv at "
+        f"the front of the column is the nearest target), got "
+        f"{r.outcome} (losses={r.signals.units_lost})"
+    )

tests/test_hard_tier.py

@@ -397,6 +397,10 @@ UPGRADED = [
     # is symmetric across y=20 so both spawns face the same pincer
     # decision.
     "combat-pincer-coordination",
+    # Wave-6 ACTION cell — escort fragile VIP (harv) through cumulative
+    # arty walls; hard tier defines 2 agent spawn_point groups (NORTH y=14
+    # / SOUTH y=26) round-robined by seed.
+    "combat-protect-vip-escort",
     # Wave-6 Group D combat-micro pack: SC2 flank micro / military
     # flank-maneuver doctrine / force-multiplier-through-angle-of-
     # attack anchor. Hard tier defines two agent spawn_point groups