feat(scenario): scout-detect-incoming-army — early-warn intercept (SC2 / NORAD / IDS anchor)

Wave-6 perception pack — early-warning intrusion detection paired with
targeted intercept. The classical scout-for-attack drill: an enemy hunt
squad is inbound from one of two candidate axes (NORTH y=10 or SOUTH
y=30, both ALWAYS placed on medium/hard since enemy actors don't honour
spawn_point), and the agent must (a) push jeep scouts forward to
LOCALISE the threat axis, then (b) re-position the medium-tank
defenders FORWARD on the localised lane so the tank cannon engages
the e1 stack at range BEFORE the squad's e3 rockets close.

Real-world anchors: SC2 early-warn scout / scout-for-attack, NORAD-
style early-warning systems, intrusion detection systems (IDS),
military reconnaissance-in-force / counter-recon screen.

Win predicate (load-bearing across all four axes):
* enemies_discovered_gte:4 (the SPOT bar)
* units_killed_gte:3 (the INTERCEPT bar)
* units_lost_lte:2 (the PRESERVATION bar; 5 starting units)
* units_in_region_gte at the NORTH-flank (45,10) intercept point on
easy; any_of over NORTH (45,10) AND SOUTH (45,30) on medium/hard.
The FORWARD-INTERCEPT clause is what makes scouting load-bearing:
a base-only auto-defence that meets the kill bar still FAILS this
clause because every defender stays west of x≈20.
* within_ticks:2500 + after_ticks:2501 ⇒ real reachable timeout
LOSS (max_turns 50, reachable tick 4503), never a draw.

Hard tier: 2 agent spawn_point groups (NORTH base y=14 / SOUTH base
y=26) round-robined by seed; 2 hunt bands (N+S, 5× e1 each) always
place. A memorised opening cannot generalise; the scout-and-
intercept doctrine does.

Scripted-policy bar (deterministic, no model / no network):
* stall → LOSS (every level/seed)
* no-scout blind → LOSS (every level/seed; mid-lane fails
position clause)
* scout-no-position → LOSS (every level/seed; e3 rockets bust
attrition cap)
* intended → WIN (every level/seed)

Sibling distinction:
* scout-and-survive — discover + return; no intercept step.
* scout-detect-enemy-tech — read building composition, not unit
forces or threat axis.
* def-pre-position-mobile-reserve — both flanks TOLD; tests where
to commit the reserve. This pack tests
the perception step that PRECEDES the
commitment.

Registered in tests/test_hard_tier.py::UPGRADED with the
NORTH/SOUTH spawn-variation rationale.

openra_bench/scenarios/packs/scout-detect-incoming-army.yaml

@@ -0,0 +1,420 @@
+# scout-detect-incoming-army.yaml
+#
+# PERCEPTION capability — Wave-6 early-warning intrusion-detection
+# pack. The classical scout-for-attack drill: an enemy army is
+# inbound from ONE OF TWO DIRECTIONS (NORTH or SOUTH on medium,
+# expanded to two simultaneous bands on hard), and the agent must
+# (a) push scouts out into the unknown to DETECT the approach
+# direction, then (b) re-position the defenders to INTERCEPT the
+# army before it reaches the base. Pure-defence-without-scouting
+# loses on the discovery bar; pure-scouting-without-positioning
+# loses on the kill bar (the army arrives at the base and overruns
+# the un-positioned defenders); stalling loses on the clock.
+#
+# This is the perception-cell sibling of the reasoning pack
+# def-pre-position-mobile-reserve (which TELLS the agent both
+# flanks are active and tests where to commit the reserve). The
+# distinct skill here is the PERCEPTION step: actively READING
+# the unknown by pushing sensors out to LOCALISE the threat axis
+# before committing the defenders.
+#
+# Real-world / benchmark anchors:
+#   - SC2 early-warn scout / scout-for-attack micro: the SC2 idiom
+#     of sacrificing a worker / overlord at a likely approach lane
+#     to detect an incoming army before it hits the base.
+#   - NORAD-style early-warning systems: a sparse network of
+#     sensors at the perimeter detects an inbound threat in time
+#     for the defending force to be vectored to the intercept.
+#   - Intrusion-detection systems (IDS): the perimeter sensor
+#     LOCALISES the breach lane; the response is targeted to that
+#     lane, not the whole perimeter.
+#   - Military reconnaissance-in-force / counter-recon screen:
+#     scouts pushed forward of the main body to detect the enemy
+#     axis of advance so the main body can be deployed on the
+#     correct lane.
+#
+# DISCRIMINATIONS (the bar — every lazy / blind / partial play
+# LOSES, only the intended scout-then-intercept play WINS):
+#
+#   • stall (observe only): tanks and scouts sit at the base. The
+#     hunt squad closes and the e3 rocket soldiers in the squad
+#     focus-fire on tanks at close range, killing ≥3 of the 5
+#     agent units (busts units_lost_lte:2) by the time the kill
+#     bar is met. LOSS.
+#
+#   • no-scout intercept-blind: tanks attack-move forward (eg
+#     east at y=20), no scouts deployed. With 2 candidate
+#     directions on medium and bands always at BOTH lanes, the
+#     mid-y attack-move puts the tanks between the two bands —
+#     they get fired on by both squads' e3s and overrun before
+#     the kill bar is met. LOSS.
+#
+#   • scout-but-no-position: scouts push out and detect (≥4
+#     discovered), but tanks stay at the base. The hunt squad
+#     arrives at the base and the e3s rocket the tanks at close
+#     range; units_lost > 2 ⇒ LOSS even though detection
+#     succeeded.
+#
+#   • intended scout-and-intercept: scouts push out (one N, one
+#     S on medium) to localise the threat axis; when the army is
+#     spotted, tanks are re-positioned (attack_move) FORWARD on
+#     the localised lane so the tank cannon's range (≈5 cells)
+#     engages the e1 stack before the e3s close to rocket range
+#     (≈3 cells). Detection bar met; tanks pick off the e1s at
+#     range; kill bar met with ≤2 lost (typically only the
+#     forward scout).
+#
+# ENGINE FACTS used (CLAUDE.md / SCENARIO_QUALITY.md):
+#   - `hunt` bot: each enemy unit attacks the NEAREST agent unit
+#     (openra-sim/src/scripted_bot.rs::Hunt). With scouts pushed
+#     out toward the hunt squad's spawn lane, the hunt squad
+#     engages the scouts first (giving the tanks time to
+#     re-position); with no scouts the hunt squad walks straight
+#     at the tank cluster.
+#   - Enemy actors with NO spawn_point ALWAYS place regardless
+#     of the agent's spawn group (CLAUDE.md). Medium / hard
+#     ALWAYS place BOTH a NORTH and a SOUTH band; the agent's
+#     spawn_point varies BASE LATITUDE (hard) so a memorised
+#     intercept cell cannot generalise across seeds. The
+#     "2 seeded directions" is encoded as "both flanks active"
+#     — strictly the harder test of the same scout-for-axis
+#     capability (def-pre-position-mobile-reserve uses the same
+#     idiom for the same reason).
+#   - Tanks (2tnk) are stance:1 (ReturnFire) — they don't pursue
+#     out of range but auto-engage hostiles in range. Scouts
+#     (jeep) are stance:0 (HoldFire) so they don't pull aggro
+#     before the model issues an explicit `move_units` forward;
+#     pure-perception role (detect, not engage).
+#   - 2tnk vs e1: CLAUDE.md "2tnk cannon ~1-shots e1". 2tnk
+#     cannon range > e1 rifle range, so a tank pushed forward
+#     to engagement range kills e1s before they fire back. e3
+#     rockets vs 2tnk are damaging but the e3 range is short
+#     (~3 cells); a tank that engages the squad's e1s at cannon
+#     range whittles the squad before the e3s close — that's
+#     the load-bearing geometry the intended policy exploits.
+#   - Inert enemy `fact` marker far east, OFF-AXIS (y=2): anti-
+#     DRAW per CLAUDE.md. Without a persistent enemy actor the
+#     engine auto-`done`s on enemy-elim before the win/fail
+#     evaluator runs. Placed off-axis so it doesn't bias the
+#     hunt path or contaminate enemies_discovered (only enemy
+#     UNITS count toward enemies_discovered, not buildings).
+#   - `enemy_unit_spotted` interrupt: re-decide the instant a
+#     hunt-squad unit becomes visible — the localisation event
+#     fires immediately, not on the next 90-tick decision
+#     boundary.
+#   - `own_unit_destroyed` interrupt: re-decide when a scout or
+#     tank falls so the policy can re-commit the remaining
+#     force.
+#   - Tick budget: ~90 ticks/turn fixed-step. max_turns 50 →
+#     reachable tick 93 + 90·49 = 4503 ≥ 4501, so the
+#     `after_ticks: 4501` fail bites comfortably inside the
+#     turn cap (real reachable LOSS, never a draw).
+#
+# Distinct from siblings:
+#   * scout-and-survive — discover + return alive (no
+#     interception). This pack adds the INTERCEPT step.
+#   * scout-detect-enemy-tech — read building composition (which
+#     buildings = which tech path). This pack reads UNIT FORCES
+#     (where the army is, not what tech tree it's on).
+#   * def-pre-position-mobile-reserve — both flanks ALWAYS
+#     spotted (the agent is TOLD), tests where to commit the
+#     reserve. This pack tests the perception step that
+#     PRECEDES the commitment.
+#   * lh-scout-react-counter — scout-then-attack on the OFFENCE
+#     side (3-phase chain). This pack is purely defensive (3
+#     tank defenders + 2 jeep scouts on the WEST side, all
+#     combat starting units, no build tools).
+#
+# Validate (no model / no network):
+#   python3 -m openra_bench.scenarios.validate \
+#     openra_bench/scenarios/packs/scout-detect-incoming-army.yaml
+
+meta:
+  id: scout-detect-incoming-army
+  title: 'Early Warning — Scout to Detect the Incoming Army Axis, Then Intercept'
+  capability: perception
+  real_world_meaning: >
+    Early-warning intrusion detection paired with a targeted
+    response. An enemy force is inbound and the agent's defenders
+    are at the base, but the agent does NOT know which axis the
+    army will arrive on. Pure defence-without-scouting cannot
+    pre-position the defenders correctly; pure offence-without-
+    scouting commits the defenders to the wrong lane; only a
+    deliberate scout step — push sensors out, READ the approach
+    axis, then re-position the defenders FORWARD on the correct
+    lane — wins. This is the perception decision that precedes
+    a targeted defensive commitment.
+  robotics_analogue: >
+    NORAD-style early-warning network paired with QRF dispatch:
+    sparse perimeter sensors LOCALISE an incoming threat; the
+    response force is then vectored to the localised lane, not
+    spread across the whole perimeter. An IDS that detects the
+    breach lane lets the SecOps response target the right
+    subnet instead of fortifying every host. A reconnaissance-
+    in-force screen detects the enemy axis of advance so the
+    main body deploys on the correct lane.
+  benchmark_anchor:
+    - "SC2 early-warn scout / scout-for-attack"
+    - "NORAD-style early-warning systems"
+    - "intrusion detection systems (IDS)"
+    - "military reconnaissance-in-force detection"
+  author: "openra-bench"
+
+# rush-hour-arena: 128×40 playable. Agent base at the WEST
+# (x≈15, y=20). Two candidate enemy approach lanes: NORTH (y=10)
+# and SOUTH (y=30), spawn at the EAST edge (x≈100). Scouts pushed
+# from the base to a NORTH-forward (50,10) or SOUTH-forward
+# (50,30) cell each cover one of the two candidate axes — see
+# either axis when the army band closes within ~4 cells.
+base_map: rush-hour-arena
+starting_cash: 0
+
+base:
+  agent:
+    faction: allies
+    cash: 0
+  # Hunt bot: each enemy unit attacks the NEAREST agent unit
+  # (scripted_bot.rs::Hunt). With scouts pushed forward the hunt
+  # squad engages the forward scout FIRST (giving the tanks
+  # time to re-position); with no scouts the squad walks straight
+  # at the tank cluster.
+  enemy:
+    faction: soviet
+    cash: 0
+    bot_type: hunt
+  # Pure-combat toolset (NO build / NO harvest): the test is
+  # SCOUT + INTERCEPT positioning, not production.
+  tools:
+    - observe
+    - move_units
+    - attack_unit
+    - attack_move
+    - stop
+  planning: true
+  # React the INSTANT an enemy unit becomes visible (the
+  # localisation event that the SCOUT exists to trigger) or
+  # a scout/tank is lost — the detect-and-redeploy loop is
+  # reactive, not on fixed 90-tick boundaries.
+  interrupts:
+    enemy_unit_spotted: true
+    own_unit_destroyed: true
+  termination:
+    max_ticks: 6000
+  actors: []
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Bare scout-then-intercept skill: ONE hunt band, FIXED direction
+  # (NORTH y=10 every seed — no surprise). The capability is the
+  # PERCEPTION step (push a scout out and detect ≥4 enemy units
+  # early) paired with a targeted INTERCEPT (tanks re-positioned
+  # to the NORTH lane to engage at tank-cannon range BEFORE the
+  # squad's e3 rockets close). Stall loses because the e3s rocket
+  # the 3 tanks at close range and bust units_lost_lte:2 before
+  # the kill bar is met. max_turns 50 → reachable tick 4503 ≥
+  # 4501 (after_ticks fail bites inside the turn cap).
+  easy:
+    description: >
+      An enemy army (6 rifle infantry + 2 rocket soldiers) is
+      inbound from the NORTH (y=10, spawn at the east edge). You
+      have 2 jeep scouts and 3 medium tanks pre-positioned at
+      your WEST base (x≈15, y=20). Push the scouts FORWARD to
+      localise the threat axis (your defenders' vision alone is
+      not enough), then re-position the tanks to intercept the
+      approaching army on its lane BEFORE the rocket soldiers
+      close to short range. Win requires: SPOT ≥4 enemy units
+      AND destroy ≥3 of them AND lose AT MOST 2 of your own
+      units AND finish before tick 4500. Stalling at the base
+      lets the rocket soldiers close on the tanks; attacking
+      blind into the wrong lane misses the army; scouting
+      without re-positioning the tanks leaves them at the base
+      where the rockets bust the attrition cap.
+    overrides:
+      actors:
+        # 2 jeep scouts at the west base — stance:0 (HoldFire)
+        # so they don't pull aggro before the model issues an
+        # explicit forward move; pure-perception role.
+        - {type: jeep, owner: agent, position: [15, 18], stance: 0}
+        - {type: jeep, owner: agent, position: [15, 22], stance: 0}
+        # 3 medium tanks (2tnk) at the west base — stance:1
+        # (ReturnFire) so they auto-defend if the hunt squad
+        # walks into them, but don't pursue out of range. Tanks
+        # dominate e1 at cannon range; e3 rockets close-range
+        # damage is the discriminator that punishes auto-defence
+        # (stall) without forward intercept.
+        - {type: 2tnk, owner: agent, position: [14, 19], stance: 3}
+        - {type: 2tnk, owner: agent, position: [14, 21], stance: 3}
+        - {type: 2tnk, owner: agent, position: [16, 20], stance: 3}
+        # NORTH hunt squad — 5× e1 at the east edge, y=10. The
+        # army size is tuned so the intended forward-intercept
+        # play wipes ≥3 e1s cleanly (tanks dominate per-shot,
+        # cannon outranges e1 rifle so kiting at (40,10) trades
+        # favourably); a stalling defence at the base lets the
+        # army arrive at close range where focus-fire from the
+        # e1 stack on a single tank kills it while the other
+        # tanks pick off only 1-2 enemies.
+        - {type: e1, owner: enemy, position: [100, 10], stance: 3, count: 5}
+        # Inert enemy `fact` marker far east, off-axis (y=2) so
+        # it doesn't bias the hunt path. Anti-DRAW per CLAUDE.md.
+        # Buildings don't count toward enemies_discovered (which
+        # only counts enemy UNITS), so this doesn't inflate the
+        # discovery bar.
+        - {type: fact, owner: enemy, position: [120, 2]}
+    # Win: spec bar (discover ≥4, killed ≥3, lost ≤2, within
+    # tick budget) PLUS a load-bearing FORWARD-INTERCEPT position
+    # clause — ≥1 agent unit within radius 10 of the NORTH-flank
+    # intercept point (45, 10) at win time. Stall keeps every
+    # unit at the base spawn (x≈15) → distance from (45,10) is
+    # >20 → clause fails. The forward clause is what enforces
+    # the SCOUT-AND-INTERCEPT capability: a base-only auto-
+    # defence cannot satisfy the position clause even if it
+    # happens to meet the kill bar.
+    win_condition:
+      all_of:
+        - {enemies_discovered_gte: 4}
+        - {units_killed_gte: 3}
+        - {units_lost_lte: 2}
+        - {units_in_region_gte: {x: 45, y: 10, radius: 10, n: 1}}
+        - {within_ticks: 2500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 2501}
+        - {not: {units_lost_lte: 2}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 50
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 controlled variable: the threat AXIS is UNCERTAIN — two
+  # candidate directions (NORTH y=10 and SOUTH y=30) with BOTH
+  # bands ALWAYS placed (engine constraint: enemy actors don't
+  # honour spawn_point — CLAUDE.md). The discrimination is the
+  # SCOUT step: a defender-only blind commit to one flank
+  # leaves the other band a clear path; the intended policy
+  # sends ONE scout NORTH and ONE scout SOUTH, localises which
+  # band is closer (the immediate threat), and commits the
+  # tanks FORWARD on that lane — engaging the e1s at cannon
+  # range while the OTHER band is still far away.
+  medium:
+    description: >
+      Two enemy army bands are inbound — one from the NORTH
+      (y=10, 4 rifle infantry + 1 rocket soldier) and one from
+      the SOUTH (y=30, 4 rifle infantry + 1 rocket soldier) —
+      both spawning at the east edge. You have 2 jeep scouts and
+      3 medium tanks pre-positioned at your WEST base. Push the
+      scouts FORWARD on BOTH candidate axes (one NORTH, one
+      SOUTH) to localise the threats, then re-position the tanks
+      to intercept on whichever lane is closing first. Win
+      requires: SPOT ≥4 enemy units AND destroy ≥3 of them AND
+      lose AT MOST 2 of your own units AND finish before tick
+      4500. Stalling at the base lets the rockets reach the
+      tanks; blind-committing all tanks mid-lane (y=20) puts
+      them between both squads' fields of fire; scouting without
+      re-positioning the tanks leaves them passively at the
+      base.
+    overrides:
+      actors:
+        - {type: jeep, owner: agent, position: [15, 18], stance: 0}
+        - {type: jeep, owner: agent, position: [15, 22], stance: 0}
+        - {type: 2tnk, owner: agent, position: [14, 19], stance: 3}
+        - {type: 2tnk, owner: agent, position: [14, 21], stance: 3}
+        - {type: 2tnk, owner: agent, position: [16, 20], stance: 3}
+        # NORTH hunt band — 4× e1 at the east edge, y=10.
+        - {type: e1, owner: enemy, position: [100, 10], stance: 3, count: 4}
+        # SOUTH hunt band — 4× e1 at the east edge, y=30.
+        - {type: e1, owner: enemy, position: [100, 30], stance: 3, count: 4}
+        - {type: fact, owner: enemy, position: [120, 2]}
+    # Win: discover + kill + survive + at least 1 unit on EITHER
+    # the NORTH-forward or the SOUTH-forward intercept point.
+    # The `any_of` over the two lanes is what makes this a
+    # PERCEPTION test: the agent commits forward on the lane
+    # the SCOUT has localised; blind-committing all units to
+    # one flank loses the OTHER band's enemies' kills, but
+    # crucially every non-forward position FAILS the clause.
+    win_condition:
+      all_of:
+        - {enemies_discovered_gte: 4}
+        - {units_killed_gte: 3}
+        - {units_lost_lte: 2}
+        - any_of:
+            - {units_in_region_gte: {x: 45, y: 10, radius: 10, n: 1}}
+            - {units_in_region_gte: {x: 45, y: 30, radius: 10, n: 1}}
+        - {within_ticks: 2500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 2501}
+        - {not: {units_lost_lte: 2}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 50
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 controlled variable on top of medium: TWO seed-driven agent
+  # spawn_point groups (base at y=14 vs y=26) round-robined by
+  # seed AND a larger enemy band (5+1 + 5+1 = 12 enemies across
+  # 2 lanes). The threat axes are the same as medium (N+S both
+  # ALWAYS placed), but the agent's BASE LATITUDE varies per
+  # seed so a memorised "send scout to (50,10)" opening cannot
+  # generalise — the doctrine (scout BOTH flanks from THIS base
+  # latitude, commit tanks forward on the localised lane) does.
+  # max_turns 50, same clock as medium — tighter under the
+  # heavier band but still comfortably reachable.
+  hard:
+    description: >
+      Two enemy army bands are inbound — one from the NORTH
+      (y=10, 5 rifle infantry + 1 rocket soldier) and one from
+      the SOUTH (y=30, 5 rifle infantry + 1 rocket soldier) —
+      both spawning at the east edge. You have 2 jeep scouts and
+      3 medium tanks pre-positioned at your WEST base — the
+      base's exact LATITUDE varies per seed (a memorised opening
+      cannot generalise; the scout-and-intercept DOCTRINE still
+      applies from either start). Push the scouts FORWARD on
+      BOTH candidate axes, localise the threats, and re-position
+      the tanks to intercept on the closer lane. Win requires:
+      SPOT ≥4 enemy units AND destroy ≥3 of them AND lose AT
+      MOST 2 of your own units AND finish before tick 4500.
+      Stalling, blind defence, and one-flank-only pre-commits
+      all LOSE.
+    overrides:
+      actors:
+        # spawn_point 0 — base shifted NORTH (y=14). All agent
+        # actors duplicated across BOTH spawn groups (CLAUDE.md:
+        # if ANY agent actor declares spawn_point, every agent
+        # actor WITHOUT spawn_point is filtered OUT — so we tag
+        # every agent actor).
+        - {type: jeep, owner: agent, position: [15, 12], stance: 0, spawn_point: 0}
+        - {type: jeep, owner: agent, position: [15, 16], stance: 0, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [14, 13], stance: 3, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [14, 15], stance: 3, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [16, 14], stance: 3, spawn_point: 0}
+        # spawn_point 1 — base shifted SOUTH (y=26). Symmetric.
+        - {type: jeep, owner: agent, position: [15, 24], stance: 0, spawn_point: 1}
+        - {type: jeep, owner: agent, position: [15, 28], stance: 0, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [14, 25], stance: 3, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [14, 27], stance: 3, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [16, 26], stance: 3, spawn_point: 1}
+        # TWO hunt bands — N (y=10) and S (y=30), 5× e1 each
+        # (10 enemies total; kill bar 3 is achievable with one
+        # successful intercept on whichever lane the agent
+        # commits to). Enemy actors don't honour spawn_point
+        # (CLAUDE.md) so both bands ALWAYS place every seed.
+        - {type: e1, owner: enemy, position: [100, 10], stance: 3, count: 5}
+        - {type: e1, owner: enemy, position: [100, 30], stance: 3, count: 5}
+        - {type: fact, owner: enemy, position: [120, 2]}
+    # Win: discover + kill + survive + at least 1 unit on EITHER
+    # the NORTH-forward or the SOUTH-forward intercept point.
+    # Same load-bearing position clause as medium; spawn-point
+    # variation is the new axis vs medium.
+    win_condition:
+      all_of:
+        - {enemies_discovered_gte: 4}
+        - {units_killed_gte: 3}
+        - {units_lost_lte: 2}
+        - any_of:
+            - {units_in_region_gte: {x: 45, y: 10, radius: 10, n: 1}}
+            - {units_in_region_gte: {x: 45, y: 30, radius: 10, n: 1}}
+        - {within_ticks: 2500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 2501}
+        - {not: {units_lost_lte: 2}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 50

tests/test_hard_tier.py

@@ -405,6 +405,17 @@ UPGRADED = [
     # y=20 so either spawn faces the same flank-vs-frontal decision
     # from a flipped bearing, and no memorised opening generalises.
     "combat-flanking-attack",
+    # Wave-6 perception pack — early-warning intrusion detection
+    # paired with targeted intercept (SC2 early-warn scout /
+    # NORAD early-warning / IDS / military reconnaissance-in-force
+    # anchor). Hard tier defines two agent spawn_point groups
+    # (NORTH base y=14 / SOUTH base y=26) round-robined by seed;
+    # two hunt bands (N y=10 + S y=30) always place (enemy actors
+    # don't honour spawn_point — CLAUDE.md), so the per-seed base
+    # latitude varies but the scout-then-intercept doctrine
+    # generalises. A memorised "send scout to (40,10) + tanks to
+    # (45,10)" opening cannot generalise across seeds.
+    "scout-detect-incoming-army",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation

tests/test_scout_detect_incoming_army.py

@@ -0,0 +1,411 @@
+"""scout-detect-incoming-army — perception pack: early-warning scout
+to localise an incoming army's approach axis + targeted intercept.
+
+The pack tests TWO chained skills:
+
+  1) PERCEPTION (the scout step): push jeeps forward to localise
+     which lane the hunt squad is arriving on (the agent's
+     base-only vision cannot read the eastern frontier in time).
+  2) ACTION (the intercept step): re-position the medium-tank
+     defenders forward on the localised lane so the tank cannon
+     engages the e1 stack at range BEFORE the squad closes to
+     short range and overruns the base.
+
+Win predicate (load-bearing across all four axes):
+  * `enemies_discovered_gte:4`  — the SPOT bar (the SC2 early-warn
+    scout / NORAD / IDS anchor — the agent must SEE ≥4 of the
+    incoming force).
+  * `units_killed_gte:3`         — the INTERCEPT bar (the targeted
+    response must actually kill at least part of the army).
+  * `units_lost_lte:2`           — the PRESERVATION bar (out of 5
+    starting units; a sloppy intercept that bleeds 3+ units busts
+    the attrition cap even if the kill bar is met).
+  * `units_in_region_gte` at the
+    NORTH-flank (45,10) intercept point (easy) OR `any_of` over
+    the NORTH (45,10) AND SOUTH (45,30) intercept points (medium
+    / hard) — the FORWARD-INTERCEPT clause. A base-only auto-
+    defence that satisfies the kill bar still FAILS this clause
+    because every defender stays west of x≈20, well outside the
+    forward intercept radius.
+  * `within_ticks:2500` paired with `after_ticks:2501` ⇒ a non-
+    finisher is a real reachable timeout LOSS (max_turns 50 →
+    reachable tick 93+90·49=4503 ≥ 2501 even in interrupt mode),
+    never a draw degeneracy.
+
+Scripted policies cover the four bar-defining outcomes:
+  * stall              → LOSS (tanks overrun at base, units_lost>2
+                         OR after_ticks fires before the kill bar
+                         and position clause are met)
+  * no-scout blind     → LOSS (units march east at y=20 mid-lane,
+                         position clause unmet on either flank)
+  * scout-no-position  → LOSS (scouts forward but tanks stay at
+                         base, e3 rockets bust the attrition cap)
+  * intended           → WIN (scouts localise the lane, tanks
+                         attack_unit on the squad's e1s at cannon
+                         range, kill ≥3 and keep ≥3 alive)
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+pytest.importorskip("openra_rl_training", 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 / "scout-detect-incoming-army.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+
+# ── scenario-shape invariants ─────────────────────────────────────────
+
+
+def test_pack_compiles_with_three_levels_and_hunt_bot():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "scout-detect-incoming-army"
+    assert pack.meta.capability == "perception"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.map_supported
+        bot = getattr(c.scenario.enemy, "bot_type", None) or getattr(
+            c.scenario.enemy, "bot", None
+        )
+        assert str(bot).lower() == "hunt", (lvl, bot)
+
+
+def test_benchmark_anchor_set():
+    """Wave-6 seed-taxonomy contract: anchors must call out the
+    SC2 early-warn scout / NORAD / IDS / military recon framings."""
+    pack = load_pack(PACK)
+    anchors = pack.meta.benchmark_anchor or []
+    assert any("SC2 early-warn scout" in a for a in anchors), anchors
+    assert any("NORAD" in a for a in anchors), anchors
+    assert any("intrusion detection" in a.lower() for a in anchors), anchors
+    assert any(
+        "reconnaissance" in a.lower() or "recon" in a.lower()
+        for a in anchors
+    ), anchors
+
+
+def test_every_level_has_fail_condition():
+    """No silent draws — every level emits a real LOSS on timeout
+    or attrition or force-wipe."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.fail_condition is not None, f"{lvl} missing fail_condition"
+
+
+def test_tick_budget_aligned_with_max_turns():
+    """within_ticks / after_ticks must be reachable inside max_turns
+    (engine ≤90 ticks/turn → reachable max = 93 + 90·(N-1)).
+    Otherwise the deadline never bites ⇒ DRAW degeneracy."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        max_turns = pack.levels[lvl].max_turns
+        reachable = 93 + 90 * (max_turns - 1)
+        # Collect every within_ticks/after_ticks leaf.
+        def _collect(node, key, out):
+            if isinstance(node, dict):
+                if key in node:
+                    out.append(node[key])
+                for v in node.values():
+                    _collect(v, key, out)
+            elif isinstance(node, list):
+                for v in node:
+                    _collect(v, key, out)
+
+        wts: list[int] = []
+        win = c.win_condition.model_dump(exclude_none=True)
+        _collect(win, "within_ticks", wts)
+        assert wts, f"{lvl} has no within_ticks leaf"
+        for wt in wts:
+            assert wt <= reachable, (
+                f"{lvl} within_ticks={wt} > reachable={reachable} "
+                f"(max_turns={max_turns}) — deadline never bites ⇒ draw"
+            )
+        # The after_ticks fail clause must ALSO be reachable.
+        fts: list[int] = []
+        fc = c.fail_condition.model_dump(exclude_none=True)
+        _collect(fc, "after_ticks", fts)
+        assert fts, f"{lvl} has no after_ticks fail leaf"
+        for ft in fts:
+            assert ft <= reachable, (
+                f"{lvl} after_ticks={ft} > reachable={reachable} "
+                f"(max_turns={max_turns}) — fail never bites ⇒ draw"
+            )
+
+
+def test_forward_position_clause_present_in_win():
+    """The load-bearing perception teeth: every level's win must
+    require ≥1 agent unit in a FORWARD intercept region (not a
+    base-only zone). Without this, stall / no-scout policies that
+    happen to meet the kill bar via base auto-defence could win."""
+    pack = load_pack(PACK)
+
+    def _walk(node, out):
+        if isinstance(node, dict):
+            if "units_in_region_gte" in node:
+                out.append(node["units_in_region_gte"])
+            for v in node.values():
+                _walk(v, out)
+        elif isinstance(node, list):
+            for v in node:
+                _walk(v, out)
+
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        win = c.win_condition.model_dump(exclude_none=True)
+        found: list = []
+        _walk(win, found)
+        assert found, f"{lvl}: missing units_in_region_gte forward clause"
+        # Every region must be FORWARD of the base (x≥30): a clause
+        # at the spawn cells would be satisfied by stall.
+        for region in found:
+            assert region["x"] >= 30, (
+                f"{lvl}: forward region must have x>=30, got {region}"
+            )
+
+
+def test_hard_has_two_spawn_point_groups():
+    """Hard-tier contract: ≥2 distinct seed-driven spawn_point groups
+    so the base latitude varies by seed."""
+    c = compile_level(load_pack(PACK), "hard")
+    groups = {
+        a.spawn_point for a in c.scenario.actors
+        if a.owner == "agent" and a.spawn_point is not None
+    }
+    assert groups == {0, 1}, groups
+    # In-bounds check (rush-hour-arena playable y ≈ 2..38, x ≈ 2..126):
+    for a in c.scenario.actors:
+        x, y = a.position
+        assert 2 <= x <= 126 and 2 <= y <= 38, (a.type, a.position)
+
+
+def test_actor_composition_2_jeeps_3_tanks():
+    """Per-spec actor manifest: 2 jeep scouts + 3 medium tanks PER
+    spawn group at the WEST base. Easy/medium have one implicit
+    group (=2 jeeps + 3 tanks total); hard has TWO declared spawn
+    groups (=4 jeeps + 6 tanks total — the spawn_point filter
+    selects ONE group at reset, leaving exactly 2 jeeps + 3 tanks
+    in play)."""
+    for lvl in LEVELS:
+        c = compile_level(load_pack(PACK), lvl)
+        jeeps = [
+            a for a in c.scenario.actors
+            if a.owner == "agent" and a.type == "jeep"
+        ]
+        tanks = [
+            a for a in c.scenario.actors
+            if a.owner == "agent" and a.type == "2tnk"
+        ]
+        groups = {
+            a.spawn_point for a in c.scenario.actors
+            if a.owner == "agent" and a.spawn_point is not None
+        }
+        n_groups = max(1, len(groups))
+        assert len(jeeps) == 2 * n_groups, (lvl, jeeps)
+        assert len(tanks) == 3 * n_groups, (lvl, tanks)
+
+
+# ── scripted policies ─────────────────────────────────────────────────
+
+
+def _own_units(rs):
+    return rs.get("units_summary") or []
+
+
+def stall(rs, C):
+    """Observe-only — every unit sits at the base spawn. The hunt
+    squad closes and the e3 rockets in the squad shred the tanks
+    at close range; units_lost > 2 → LOSS even if the squad is
+    eventually wiped, AND the forward-position clause is never
+    satisfied."""
+    return [C.observe()]
+
+
+def no_scout_blind_east(rs, C):
+    """No scouting: attack_move all units east at mid-latitude
+    (y=20). The mid-lane line satisfies NEITHER the NORTH-forward
+    (y=10) nor the SOUTH-forward (y=30) position clause, so even
+    when the units accidentally kill enough enemies the win clause
+    is unmet → after_ticks fires → LOSS."""
+    units = _own_units(rs)
+    if not units:
+        return [C.observe()]
+    ids = [str(u["id"]) for u in units]
+    return [C.attack_move(ids, target_x=80, target_y=20)]
+
+
+def scout_but_no_position(rs, C):
+    """Scouts push out (one NORTH, one SOUTH) — detection bar met
+    — but tanks STAY at the base. The hunt squad closes on the
+    tanks; e3 rockets bust the attrition cap → LOSS even though
+    detection succeeded."""
+    units = _own_units(rs)
+    if not units:
+        return [C.observe()]
+    jeeps = [u for u in units if str(u.get("type", "")).lower() == "jeep"]
+    cmds = []
+    if len(jeeps) >= 1:
+        cmds.append(C.move_units([str(jeeps[0]["id"])], target_x=70, target_y=10))
+    if len(jeeps) >= 2:
+        cmds.append(C.move_units([str(jeeps[1]["id"])], target_x=70, target_y=30))
+    if not cmds:
+        cmds.append(C.observe())
+    return cmds
+
+
+def make_intended():
+    """Scout-and-react: jeeps push forward on BOTH candidate lanes
+    on turn 1; the moment any enemy unit is spotted, lock in the
+    commit lane (the one with the closer enemy) and have tanks
+    attack_unit on the nearest visible hostile on that lane (or
+    any hostile if the commit lane has none visible yet). The
+    attack_unit verb keeps tanks engaged rather than parking at
+    a static cell."""
+    state = {"turn": 0, "commit_y": None}
+
+    def policy(rs, C):
+        state["turn"] += 1
+        units = _own_units(rs)
+        if not units:
+            return [C.observe()]
+        defs = [u for u in units if str(u.get("type", "")).lower() == "2tnk"]
+        jeeps = [u for u in units if str(u.get("type", "")).lower() == "jeep"]
+        es = rs.get("enemy_summary") or []
+        rusher_units = [
+            e for e in es
+            if str(e.get("type", "")).lower() in ("e1", "e3")
+        ]
+        # Localise threat axis from the first visible enemy(s).
+        if rusher_units and state["commit_y"] is None:
+            n = [e for e in rusher_units if int(e.get("cell_y", 20)) < 20]
+            s = [e for e in rusher_units if int(e.get("cell_y", 20)) >= 20]
+            if n and s:
+                nx = min(int(e.get("cell_x", 100)) for e in n)
+                sx = min(int(e.get("cell_x", 100)) for e in s)
+                state["commit_y"] = 10 if nx <= sx else 30
+            elif n:
+                state["commit_y"] = 10
+            elif s:
+                state["commit_y"] = 30
+        cmds = []
+        # Turn 1: scout push (one NORTH, one SOUTH).
+        if jeeps and state["turn"] == 1:
+            cmds.append(C.move_units([str(jeeps[0]["id"])], target_x=40, target_y=10))
+            if len(jeeps) > 1:
+                cmds.append(C.move_units([str(jeeps[1]["id"])], target_x=40, target_y=30))
+        # Tanks: attack_unit on nearest visible hostile if any (the
+        # attack_unit verb keeps tanks engaged), else attack_move
+        # forward toward the commit lane (or NORTH by default).
+        if defs:
+            def_ids = [str(d["id"]) for d in defs]
+            if rusher_units:
+                # Filter to the committed lane if known.
+                if state["commit_y"] is not None:
+                    lane = [
+                        e for e in rusher_units
+                        if abs(int(e.get("cell_y", 20)) - state["commit_y"]) < 10
+                    ]
+                    if not lane:
+                        lane = rusher_units
+                else:
+                    lane = rusher_units
+                tx = sum(int(d["cell_x"]) for d in defs) // len(defs)
+                ty = sum(int(d["cell_y"]) for d in defs) // len(defs)
+                tgt = min(
+                    lane,
+                    key=lambda e: (int(e.get("cell_x", 100)) - tx) ** 2
+                    + (int(e.get("cell_y", 20)) - ty) ** 2,
+                )
+                cmds.append(C.attack_unit(def_ids, str(tgt.get("id"))))
+            else:
+                ty = state["commit_y"] if state["commit_y"] is not None else 10
+                cmds.append(C.attack_move(def_ids, target_x=40, target_y=ty))
+        if not cmds:
+            cmds.append(C.observe())
+        return cmds
+
+    return policy
+
+
+# ── solvency: intended WINS every level + every hard seed ─────────────
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_intended_scout_and_intercept_wins(level, seed):
+    c = compile_level(load_pack(PACK), level)
+    r = run_level(c, make_intended(), seed=seed)
+    assert r.outcome == "win", (
+        f"intended scout-and-intercept must WIN on {level} s={seed}; "
+        f"got {r.outcome} (tick={r.signals.game_tick}, "
+        f"kills={r.signals.units_killed}, "
+        f"lost={r.signals.units_lost}, "
+        f"seen={len(r.signals.enemies_seen_ids)})"
+    )
+
+
+# ── no-cheat: every lazy / blind / partial policy LOSES (not draws) ──
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_stall_loses(level, seed):
+    c = compile_level(load_pack(PACK), level)
+    r = run_level(c, stall, seed=seed)
+    assert r.outcome == "loss", (
+        f"stall must LOSE on {level} s={seed}; got {r.outcome} "
+        f"(tick={r.signals.game_tick}, kills={r.signals.units_killed}, "
+        f"lost={r.signals.units_lost})"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_no_scout_blind_east_loses(level, seed):
+    """Blind mid-lane attack-move never satisfies the forward
+    position clause on N or S — even when it accidentally wipes
+    the army it still LOSES."""
+    c = compile_level(load_pack(PACK), level)
+    r = run_level(c, no_scout_blind_east, seed=seed)
+    assert r.outcome == "loss", (
+        f"no-scout blind must LOSE on {level} s={seed}; got {r.outcome} "
+        f"(tick={r.signals.game_tick}, kills={r.signals.units_killed}, "
+        f"lost={r.signals.units_lost})"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_scout_but_no_position_loses(level, seed):
+    """Scouts forward but tanks STAY at the base — the squad
+    closes and the e3 rockets bust the attrition cap → LOSS."""
+    c = compile_level(load_pack(PACK), level)
+    r = run_level(c, scout_but_no_position, seed=seed)
+    assert r.outcome == "loss", (
+        f"scout-no-position must LOSE on {level} s={seed}; got {r.outcome} "
+        f"(tick={r.signals.game_tick}, kills={r.signals.units_killed}, "
+        f"lost={r.signals.units_lost})"
+    )
+
+
+# ── Spawn-variation contract (hard) ───────────────────────────────────
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+def test_hard_seeds_run_to_terminal(seed):
+    """Hard's two spawn_point groups must actually round-robin
+    cleanly — stall on each seed completes deterministically (the
+    cross-seed start-cell distinctness contract is enforced by
+    tests/test_hard_tier.py::test_curated_hard_still_compiles_and_runs)."""
+    c = compile_level(load_pack(PACK), "hard")
+    r = run_level(c, stall, seed=seed)
+    assert r.outcome == "loss"