feat(scenario): scout-deny-enemy-vision — counter-recon, kill enemy scouts before they report (military counter-reconnaissance)

REASONING pack: enemy scouts hold observation posts watching the
agent's base; left alone they complete their report. The agent's
HoldFire strike force must intercept and kill every scout before the
report window (within_ticks) closes. Stall and wrong-path LOSE
(0 kills); committing the whole force to one recon vector LOSES on
medium/hard (the other scout reports). Only splitting to cover every
vector WINS. Hard defines two seed-driven spawn_point base groups.

openra_bench/scenarios/packs/scout-deny-enemy-vision.yaml

@@ -0,0 +1,239 @@
+# scout-deny-enemy-vision — REASONING, counter-reconnaissance:
+# intercept and kill the enemy scout(s) before they report
+# (Wave-12).
+#
+# The capability under test is COUNTER-RECON — denying the enemy
+# vision of your base. An enemy scout has taken up an observation
+# post overlooking the agent's base; left alone it completes its
+# report (it "survives N ticks in sight"). The agent must locate and
+# DESTROY every enemy scout before the report window closes. Sitting
+# still lets the report complete; covering only ONE recon vector
+# leaves the other scout's report intact.
+#
+# Real-world anchors:
+#   • Military counter-reconnaissance: the counter-recon screen
+#     hunts and destroys the enemy's scouts/observation posts before
+#     they can report the main body's disposition.
+#   • SC2 scout denial: killing the opponent's scouting worker /
+#     overlord before it sees your build — deny the information.
+#   • Intrusion prevention: detect and TERMINATE the reconnaissance
+#     probe before it exfiltrates a map of the defended network;
+#     a passive posture that merely watches the probe loses the
+#     information war.
+#
+# Mechanism (the load-bearing design):
+#   • The enemy scouts are `e3` actors at `stance:0` (HoldFire) —
+#     they hold an observation post and do NOT fight or advance, so
+#     the agent must DRIVE every engagement (a stall cannot bait a
+#     free kill, and the scouts cannot self-deliver into the
+#     agent's force).
+#   • The agent's strike force is `stance:0` (HoldFire) too — it
+#     never auto-hunts the map, so a stall / observe-only policy
+#     can NOT clear the scouts for free; the agent must issue the
+#     explicit attack_move + attack_unit interception orders.
+#   • The win is `units_killed_gte:N` (kill EVERY scout) AND
+#     `within_ticks:K` — K is the report window: a scout still
+#     alive at K has "survived N ticks in sight" and completed its
+#     report ⇒ the agent loses.
+#   • On medium/hard there are TWO scouts on TWO separate recon
+#     vectors (a north lane and a south lane). Committing the whole
+#     force to ONE lane kills only one scout — the other completes
+#     its report ⇒ the kill bar (N=2) is unmet ⇒ LOSS. The
+#     counter-recon skill is to cover EVERY vector.
+#
+# Discrimination (four-policy bar — scripted, no model needed):
+#   • stall (observe-only): the HoldFire strike force never engages;
+#     0 kills; every scout survives to K ⇒ the `after_ticks`
+#     deadline bites as a real reachable timeout LOSS.
+#   • one-lane (commit the whole force to a single recon vector):
+#     kills only the scout on that lane; the other scout completes
+#     its report ⇒ the kill bar is unmet ⇒ LOSS (medium/hard).
+#   • wrong-path (sweep the wrong lane / chase the far enemy
+#     marker): never reaches a real scout ⇒ 0 (or too few) kills
+#     ⇒ LOSS.
+#   • intended counter-recon (split the force to cover EVERY recon
+#     vector; attack_move to each scout's post and attack_unit it
+#     to death): every scout killed before K ⇒ WIN.
+#
+# Engine facts used (CLAUDE.md / prompt_v2 codex / verified against
+# the installed openra_train wheel, 2026-05-20):
+#   • `e3` rocket soldiers surface reliably in `enemy_positions` /
+#     `enemy_summary` once in vision (CLAUDE.md notes some `e1`
+#     cells do not surface — `e3` does).
+#   • `stance:0` HoldFire — a unit never auto-engages, even when
+#     attacked. The scouts hold their post; the agent strike force
+#     does not self-deliver. Explicit `attack_unit` / `attack_move`
+#     orders override stance (CLAUDE.md stance semantics).
+#   • Tick alignment (~90 ticks/turn): within_ticks ≤ 93+90·
+#     (max_turns−1); fail after_ticks = within_ticks+1 ⇒ a
+#     non-finisher is a real reachable LOSS, never a DRAW.
+#   • A far inert enemy `fact` marker keeps the engine from
+#     auto-`done`ing on enemy-elimination before the win/fail
+#     evaluator runs (CLAUDE.md auto-done footgun).
+#   • Hard tier: two agent spawn_point groups (NORTH base y=10..14
+#     / SOUTH base y=26..30); the agent's strike force is
+#     duplicated across both groups at the matching latitude. The
+#     two scouts (no spawn_point) place every seed, so a memorised
+#     "sweep these two cells from (20,20)" opening cannot
+#     generalise — the interception geometry flips per seed.
+#
+# Validate (no model / no network):
+#   python3 -m pytest tests/test_scout_deny_enemy_vision.py -q
+
+meta:
+  id: scout-deny-enemy-vision
+  title: 'Counter-Recon — Deny Enemy Vision: Kill the Scouts Before They Report'
+  capability: reasoning
+  real_world_meaning: >
+    An enemy scout has taken up an observation post overlooking your
+    base; left alone it completes its report and the enemy gains a
+    full picture of your disposition. The agent must locate and
+    DESTROY every enemy scout before the report window closes.
+    Sitting still lets the report complete; covering only ONE recon
+    vector leaves the other scout's report intact. The pack tests
+    counter-reconnaissance: actively denying the adversary vision by
+    hunting down EVERY scout, not merely defending one approach.
+  robotics_analogue: >
+    Counter-surveillance / intrusion prevention: an adversary's
+    reconnaissance probes are mapping the defended site, and each
+    probe exfiltrates its findings once it has observed long enough.
+    The defender must detect and neutralise EVERY probe before its
+    report window elapses — a passive posture that merely watches
+    the probes loses the information war, and neutralising one probe
+    while ignoring another still leaks the map.
+  benchmark_anchor:
+    - "military counter-reconnaissance"
+    - "SC2 scout denial"
+    - "intrusion prevention"
+  author: openra-bench
+
+base_map: rush-hour-arena
+
+base:
+  agent: {faction: allies, cash: 0}
+  enemy: {faction: soviet, cash: 0}
+  tools: [observe, move_units, attack_unit, attack_move, stop]
+  planning: true
+  termination: {max_ticks: 9000}
+  actors: []
+
+levels:
+  # ── EASY ────────────────────────────────────────────────────────
+  # The bare counter-recon skill: ONE enemy scout on an observation
+  # post forward of the base. The agent's HoldFire strike force must
+  # drive out and kill it before the report window (within_ticks)
+  # closes. Stall LOSES (HoldFire force never engages; the scout
+  # survives to K). A decisive intercept WINS.
+  easy:
+    description: >
+      An enemy scout (rocket soldier) holds an observation post
+      forward of your base at (55, 20), watching your disposition.
+      Your strike force (2 medium tanks) holds fire — it will not
+      engage on its own. Drive the force out and KILL the scout
+      before tick 1100 (the report window). If the scout is still
+      alive at the deadline it has completed its report and you
+      LOSE. Stalling (observe only) LOSES — the scout survives the
+      window. Sweeping the wrong direction LOSES — you never reach
+      the scout in time.
+    overrides:
+      actors:
+        # Agent strike force — HoldFire so it never auto-hunts; the
+        # agent must issue the interception orders.
+        - {type: 2tnk, owner: agent, position: [20, 19], stance: 0}
+        - {type: 2tnk, owner: agent, position: [20, 21], stance: 0}
+        # Enemy scout — e3 on a HoldFire observation post.
+        - {type: e3, owner: enemy, position: [55, 20], stance: 0}
+        # Far inert enemy marker — anti-DRAW.
+        - {type: fact, owner: enemy, position: [124, 20]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 1}
+        - {within_ticks: 1100}
+    fail_condition:
+      any_of:
+        - {after_ticks: 1101}
+    max_turns: 25
+
+  # ── MEDIUM ──────────────────────────────────────────────────────
+  # +1 controlled variable: TWO enemy scouts on TWO separate recon
+  # vectors (a north lane y=12 and a south lane y=28). The kill bar
+  # rises to 2 — the agent must cover BOTH vectors. Committing the
+  # whole force to one lane kills one scout; the other completes its
+  # report ⇒ LOSS. The strike force is sized so a SPLIT (one
+  # detachment per lane) clears both scouts inside the window.
+  medium:
+    description: >
+      TWO enemy scouts (rocket soldiers) hold observation posts on
+      two separate recon vectors — one on the NORTH lane at
+      (55, 12) and one on the SOUTH lane at (55, 28). Your strike
+      force (4 medium tanks) holds fire. SPLIT the force to cover
+      BOTH vectors and KILL BOTH scouts before tick 1300. Any
+      scout still alive at the deadline has completed its report
+      and you LOSE. Committing the whole force to one lane kills
+      only one scout — the other reports ⇒ LOSS. Stalling LOSES.
+    overrides:
+      actors:
+        # Agent strike force — two detachments, one per lane.
+        - {type: 2tnk, owner: agent, position: [20, 11], stance: 0}
+        - {type: 2tnk, owner: agent, position: [20, 13], stance: 0}
+        - {type: 2tnk, owner: agent, position: [20, 27], stance: 0}
+        - {type: 2tnk, owner: agent, position: [20, 29], stance: 0}
+        # Two enemy scouts on two recon vectors.
+        - {type: e3, owner: enemy, position: [55, 12], stance: 0}
+        - {type: e3, owner: enemy, position: [55, 28], stance: 0}
+        - {type: fact, owner: enemy, position: [124, 20]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 2}
+        - {within_ticks: 1300}
+    fail_condition:
+      any_of:
+        - {after_ticks: 1301}
+    max_turns: 25
+
+  # ── HARD ────────────────────────────────────────────────────────
+  # +2 controlled variables vs medium:
+  #   1. Tighter report window (~1100 ticks instead of ~1300) — the
+  #      counter-recon response must be efficient; a dawdling split
+  #      misses the clock.
+  #   2. TWO agent spawn_point groups (NORTH base y=10..14 / SOUTH
+  #      base y=26..30) round-robined by seed. The two scouts
+  #      (no spawn_point) place every seed at fixed posts, so the
+  #      interception geometry — which detachment is nearer which
+  #      scout — flips per seed; a memorised "north detachment
+  #      takes the north scout" opening cannot generalise.
+  hard:
+    description: >
+      TWO enemy scouts (rocket soldiers) hold observation posts at
+      (55, 12) and (55, 28). Your strike force (4 medium tanks)
+      starts at ONE of two base latitudes (NORTH or SOUTH, chosen
+      by seed) and holds fire. SPLIT the force to cover BOTH recon
+      vectors and KILL BOTH scouts before tick 1100 — a tight
+      report window. Any scout still alive at the deadline has
+      completed its report and you LOSE. Committing the whole force
+      to one lane LOSES; stalling LOSES. The base latitude varies
+      by seed so a memorised interception plan cannot generalise.
+    overrides:
+      actors:
+        # spawn_point 0 — NORTH base (y=9..15)
+        - {type: 2tnk, owner: agent, position: [20,  9], stance: 0, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [22, 11], stance: 0, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [20, 13], stance: 0, spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [22, 15], stance: 0, spawn_point: 0}
+        # spawn_point 1 — SOUTH base (y=25..31)
+        - {type: 2tnk, owner: agent, position: [20, 25], stance: 0, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [22, 27], stance: 0, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [20, 29], stance: 0, spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [22, 31], stance: 0, spawn_point: 1}
+        # Two enemy scouts — fixed posts, place every seed.
+        - {type: e3, owner: enemy, position: [55, 12], stance: 0}
+        - {type: e3, owner: enemy, position: [55, 28], stance: 0}
+        - {type: fact, owner: enemy, position: [124, 20]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 2}
+        - {within_ticks: 1100}
+    fail_condition:
+      any_of:
+        - {after_ticks: 1101}
+    max_turns: 25

tests/test_hard_tier.py

@@ -1450,6 +1450,7 @@ UPGRADED = [
     "coord-cover-and-move",  # hard: 2 agent spawn_point groups
     "combat-kite-and-pull",  # hard: 2 agent spawn_point groups (Wave-12)
     "econ-tech-vs-expand-decision",  # hard: 2 agent spawn_point groups (Wave-12)
+    "scout-deny-enemy-vision",  # hard: 2 agent spawn_point groups (Wave-12)
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation

tests/test_scout_deny_enemy_vision.py

@@ -0,0 +1,325 @@
+"""scout-deny-enemy-vision — REASONING capability validation.
+
+Counter-reconnaissance: enemy scouts hold observation posts watching
+the agent's base; left alone they complete their report. The agent
+must intercept and KILL every scout before the report window closes
+(`within_ticks`). Sitting still lets the report complete; covering
+only ONE recon vector leaves the other scout's report intact.
+
+Bar (CLAUDE.md "no defect, no cheat, no draw"):
+
+  * stall (observe-only) LOSES every tier / every hard seed — the
+    HoldFire strike force never engages; 0 kills; the scouts
+    survive the window → the `after_ticks` deadline bites.
+  * wrong-path (sweep away from the scouts) LOSES every tier /
+    seed — no scout is reached → 0 kills.
+  * one-lane (commit the whole force to a single recon vector)
+    LOSES on medium/hard — kills one scout, the other completes
+    its report → the N=2 kill bar is unmet.
+  * intended counter-recon (split the force to cover EVERY recon
+    vector, attack_unit each scout) WINS every tier / every hard
+    seed.
+  * hard tier defines ≥2 agent spawn_point groups (NORTH / SOUTH
+    base) round-robined by seed so the interception geometry
+    cannot be memorised.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+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
+from openra_bench.scenarios.win_conditions import WinContext, evaluate
+
+PACK = PACKS_DIR / "scout-deny-enemy-vision.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+
+# ── scripted policies ───────────────────────────────────────────────
+
+
+def _tanks(rs):
+    return [u for u in (rs.get("units_summary") or []) if u.get("type") == "2tnk"]
+
+
+def _scouts(rs):
+    return [e for e in (rs.get("enemy_summary") or []) if (e.get("type") or "").lower() == "e3"]
+
+
+def _stall(rs, C):
+    """Observe-only — the HoldFire force never engages → 0 kills →
+    the scouts survive the report window → LOSS."""
+    return [C.observe()]
+
+
+def _wrong_path(rs, C):
+    """Sweep toward the far enemy marker, away from the scouts. No
+    scout is ever reached → 0 kills → LOSS."""
+    own = _tanks(rs)
+    if not own:
+        return [C.observe()]
+    return [C.attack_move([str(u["id"]) for u in own], target_x=110, target_y=20)]
+
+
+def _one_lane(rs, C):
+    """Commit the WHOLE force to a single recon vector (the north
+    scout). On medium/hard the south scout completes its report →
+    the N=2 kill bar is unmet → LOSS."""
+    own = _tanks(rs)
+    if not own:
+        return [C.observe()]
+    scouts = sorted(_scouts(rs), key=lambda e: e["cell_y"])
+    if scouts:
+        return [C.attack_unit([str(u["id"]) for u in own], str(scouts[0]["id"]))]
+    return [C.attack_move([str(u["id"]) for u in own], target_x=55, target_y=12)]
+
+
+def _counter_recon(rs, C):
+    """The intended capability — cover EVERY recon vector. With
+    vision, every tank attacks the nearest scout; without vision,
+    split the force (north half sweeps the north lane, south half
+    the south lane) so both observation posts are reached."""
+    own = _tanks(rs)
+    if not own:
+        return [C.observe()]
+    scouts = _scouts(rs)
+    cmds = []
+    if scouts:
+        for u in own:
+            s = min(
+                scouts,
+                key=lambda e: abs(e["cell_x"] - u["cell_x"])
+                + abs(e["cell_y"] - u["cell_y"]),
+            )
+            cmds.append(C.attack_unit([str(u["id"])], str(s["id"])))
+        return cmds
+    sown = sorted(own, key=lambda u: u["cell_y"])
+    half = len(sown) // 2
+    for u in sown[:half] or sown[:1]:
+        cmds.append(C.attack_move([str(u["id"])], target_x=55, target_y=12))
+    for u in sown[half:]:
+        cmds.append(C.attack_move([str(u["id"])], target_x=55, target_y=28))
+    return cmds
+
+
+# ── structural tests ────────────────────────────────────────────────
+
+
+def test_pack_loads_and_meta_reasoning():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "scout-deny-enemy-vision"
+    assert pack.meta.capability == "reasoning"
+    assert pack.meta.real_world_meaning
+    assert pack.meta.robotics_analogue
+    anchors = " ".join(pack.meta.benchmark_anchor).lower()
+    assert "counter-reconnaissance" in anchors, anchors
+    assert "scout denial" in anchors, anchors
+    assert "intrusion prevention" in anchors, anchors
+
+
+def test_tools_are_combat_only():
+    pack = load_pack(PACK)
+    tools = set(pack.base.get("tools", []) if isinstance(pack.base, dict) else [])
+    for required in ("move_units", "attack_unit", "attack_move", "stop"):
+        assert required in tools, f"missing tool: {required!r}"
+    assert "build" not in tools, "this is a counter-recon combat pack — no build tool"
+
+
+def test_scouts_are_holdfire_e3():
+    """Every level's enemy scouts are e3 at stance:0 (HoldFire) — they
+    hold an observation post and never advance or fight."""
+    pack = load_pack(PACK)
+    counts = {"easy": 1, "medium": 2, "hard": 2}
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        scouts = [
+            a for a in c.scenario.actors if a.owner == "enemy" and a.type == "e3"
+        ]
+        assert len(scouts) == counts[lvl], (
+            f"{lvl}: expected {counts[lvl]} e3 scouts; got {len(scouts)}"
+        )
+        for s in scouts:
+            assert s.stance == 0, f"{lvl}: scout must be stance:0 HoldFire"
+
+
+def test_agent_force_is_holdfire():
+    """The agent strike force is stance:0 so it never auto-hunts —
+    a stall cannot clear the scouts for free."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        tanks = [
+            a for a in c.scenario.actors if a.owner == "agent" and a.type == "2tnk"
+        ]
+        assert tanks, f"{lvl}: agent must have a 2tnk strike force"
+        for t in tanks:
+            assert t.stance == 0, f"{lvl}: agent tank must be stance:0 HoldFire"
+
+
+def test_kill_bar_matches_scout_count():
+    """The win kill bar must equal the number of scouts — every
+    recon vector must be denied."""
+    pack = load_pack(PACK)
+    counts = {"easy": 1, "medium": 2, "hard": 2}
+    for lvl in LEVELS:
+        L = pack.levels[lvl]
+        bar = next(
+            int(c["units_killed_gte"])
+            for c in L.win_condition.model_dump()["all_of"]
+            if "units_killed_gte" in c
+        )
+        assert bar == counts[lvl], f"{lvl}: kill bar {bar} != scout count {counts[lvl]}"
+
+
+def test_every_level_has_reachable_timeout_fail():
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        L = pack.levels[lvl]
+        ceiling = 93 + 90 * (L.max_turns - 1)
+        wt = next(
+            int(c["within_ticks"])
+            for c in L.win_condition.model_dump()["all_of"]
+            if "within_ticks" in c
+        )
+        ft = next(
+            int(c["after_ticks"])
+            for c in L.fail_condition.model_dump()["any_of"]
+            if "after_ticks" in c
+        )
+        assert wt < ceiling, f"{lvl}: within_ticks {wt} >= ceiling {ceiling}"
+        assert ft <= ceiling, f"{lvl}: after_ticks {ft} > ceiling {ceiling}"
+        assert wt + 1 == ft, f"{lvl}: within/after mismatch {wt}/{ft}"
+
+
+def test_every_level_has_a_fail_condition():
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.fail_condition is not None, f"{lvl} needs a fail_condition"
+
+
+def test_hard_has_two_seed_driven_spawn_groups():
+    c = compile_level(load_pack(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 sp == {0, 1}, f"hard must define spawn_point groups {{0,1}}; got {sorted(sp)}"
+
+
+def test_in_bounds_actors_on_every_level():
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        for a in c.scenario.actors:
+            x, y = a.position
+            assert 2 <= x <= 126 and 2 <= y <= 38, (
+                f"{lvl}: actor {a.type} at ({x},{y}) out of bounds"
+            )
+
+
+# ── predicate-level (no engine) ─────────────────────────────────────
+
+
+def _ctx(*, tick=0, killed=0):
+    import types
+
+    sig = types.SimpleNamespace(
+        game_tick=tick,
+        units_killed=killed,
+        units_lost=0,
+        own_buildings=[],
+        own_building_types=set(),
+        enemies_seen_ids=set(),
+        enemy_buildings_seen_ids=set(),
+    )
+    return WinContext(signals=sig, render_state={"units_summary": []})
+
+
+def test_predicates_enforce_kill_before_window():
+    pe = compile_level(load_pack(PACK), "easy")
+    # kill 1 scout in time → WIN
+    assert evaluate(pe.win_condition, _ctx(tick=600, killed=1))
+    # 0 kills → not win
+    assert not evaluate(pe.win_condition, _ctx(tick=600, killed=0))
+    # kill but past the window → not win
+    assert not evaluate(pe.win_condition, _ctx(tick=1101, killed=1))
+    # past after_ticks → fail
+    assert evaluate(pe.fail_condition, _ctx(tick=1101, killed=0))
+    # in-window → not fail
+    assert not evaluate(pe.fail_condition, _ctx(tick=600, killed=0))
+
+    pm = compile_level(load_pack(PACK), "medium")
+    # only 1 of 2 scouts killed → not win, and the deadline still fails
+    assert not evaluate(pm.win_condition, _ctx(tick=600, killed=1))
+    assert evaluate(pm.win_condition, _ctx(tick=600, killed=2))
+    assert evaluate(pm.fail_condition, _ctx(tick=1302, killed=1))
+
+
+# ── engine-driven: every lazy/wrong policy LOSES, intended WINS ──────
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", SEEDS)
+def test_stall_loses_every_tier_and_seed(level, seed):
+    c = compile_level(load_pack(PACK), level)
+    r = run_level(c, _stall, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level}/seed{seed}: stall must LOSE; got {r.outcome} "
+        f"killed={r.signals.units_killed} tick={r.signals.game_tick}"
+    )
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", SEEDS)
+def test_wrong_path_loses_every_tier_and_seed(level, seed):
+    c = compile_level(load_pack(PACK), level)
+    r = run_level(c, _wrong_path, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level}/seed{seed}: wrong-path must LOSE; got {r.outcome} "
+        f"killed={r.signals.units_killed} tick={r.signals.game_tick}"
+    )
+
+
+@pytest.mark.parametrize("level", ("medium", "hard"))
+@pytest.mark.parametrize("seed", SEEDS)
+def test_one_lane_loses_on_multi_vector_tiers(level, seed):
+    """Committing the whole force to one recon vector kills only one
+    scout; the other completes its report → LOSS on medium/hard."""
+    c = compile_level(load_pack(PACK), level)
+    r = run_level(c, _one_lane, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level}/seed{seed}: one-lane must LOSE; got {r.outcome} "
+        f"killed={r.signals.units_killed} tick={r.signals.game_tick}"
+    )
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", SEEDS)
+def test_counter_recon_wins_every_tier_and_seed(level, seed):
+    """The intended capability — cover EVERY recon vector — WINS
+    every tier and every hard seed."""
+    c = compile_level(load_pack(PACK), level)
+    r = run_level(c, _counter_recon, seed=seed)
+    assert r.outcome == "win", (
+        f"{level}/seed{seed}: counter-recon must WIN; got {r.outcome} "
+        f"killed={r.signals.units_killed} tick={r.signals.game_tick}"
+    )
+
+
+def test_counter_recon_run_is_deterministic_per_seed():
+    c = compile_level(load_pack(PACK), "medium")
+    a = run_level(c, _counter_recon, seed=2)
+    b = run_level(c, _counter_recon, seed=2)
+    assert (a.outcome, a.turns, a.signals.units_killed) == (
+        b.outcome, b.turns, b.signals.units_killed
+    )