feat(scenario): scout-and-report — recon and extract (military intelligence / SC2 / drone-surveillance anchor)

openra_bench/scenarios/packs/scout-and-report.yaml

@@ -0,0 +1,254 @@
+# scout-and-report.yaml
+#
+# PERCEPTION capability — reconnaissance-and-EXTRACT cell. The agent
+# must (a) reach a specific FAR enemy building to surface it AND
+# (b) bring the WHOLE scout team back to the base region. Distinct
+# from the sibling perception packs:
+#
+#   * scout-and-survive       — 1 jeep, ANY return; the SCOUT must
+#                               survive the discovery round-trip.
+#   * scout-detect-enemy-tech — observe N distinct enemy buildings;
+#                               NO return-to-base clause.
+#   * perception-frontier-reading — discover N fog pockets, no return.
+#   * perception-target-vs-fog    — infer WHICH pocket holds the target.
+#
+# This pack is the only perception cell that requires BOTH:
+#   (i) a discovered enemy building (reveal a SPECIFIC far target), AND
+#   (ii) the full team (n:2) returns to the base region INTACT (no
+#       losses — `units_lost_lte:0`).
+#
+# Real-world anchor: military reconnaissance with mandatory recovery
+# AND full-team intact extraction (intel-and-extract ops); SC2 recon-
+# and-report where losing any unit ruins the report channel; drone
+# surveillance with return-to-base + zero-attrition acceptance.
+#
+# Win idiom: `buildings_discovered_gte:1 AND units_in_region_gte
+# {start, n:2} AND within_ticks:K AND units_lost_lte:0`. The discovery
+# clause forces the round-trip out to the far fact; the n:2 return
+# clause forces the WHOLE team back (one jeep stranded east = LOSS);
+# units_lost_lte:0 forces a NO-LOSS extraction (any jeep dies = LOSS).
+# Brute-attacking the en-route defenders kills at least one jeep
+# (jeeps vs an e1 stack — low DPS, fragile chassis) → bust the
+# units_lost_lte:0 tooth. Stalling busts the clock. One-way commit
+# busts the n:2 return clause.
+#
+# Validate:
+#   cd /Users/berta/Projects/OpenRA-Bench && \
+#   python3 -m openra_bench.scenarios.validate \
+#     openra_bench/scenarios/packs/scout-and-report.yaml
+
+meta:
+  id: scout-and-report
+  title: 'Scout and Report — Reveal the Far Target, Then Extract the Team'
+  capability: perception
+  real_world_meaning: >
+    Military intelligence reconnaissance with mandatory full-team
+    recovery. The scout team must surface a specific FAR enemy
+    installation AND bring the entire team back INTACT for the
+    intelligence to be delivered. Real intel-and-extract doctrine
+    treats neither bare discovery NOR a partial-team return as a
+    success — the channel is the report (requires return) AND the
+    asset is the team (requires zero losses). The pack tests
+    whether the agent treats "saw the target" or "one jeep made it
+    home" as success rather than the binding "discovered AND full
+    team extracted" criterion.
+  robotics_analogue: >
+    Multi-drone reconnaissance overflight with return-to-base + zero-
+    attrition acceptance: the mission counts as a success only if the
+    platforms reveal the named target AND ALL platforms recover. A
+    one-way commit that surfaces the target but loses any drone is a
+    partial failure, not a win — the report channel requires both the
+    data AND the platforms back at base for the next mission.
+  benchmark_anchor:
+    - "military intelligence reconnaissance (recon-and-extract)"
+    - "SC2 scout-and-return for info"
+    - "drone surveillance with return-to-base"
+    - "intel ops: gather then withdraw"
+  author: "openra-bench"
+
+base_map: rush-hour-arena
+
+base:
+  # The advertised tool surface includes attack_unit (the model CAN
+  # try to attack), but using it on the defenders is the failure
+  # mode the pack is designed to punish — any combat engagement
+  # with the e1 stacks bleeds at least one jeep and busts
+  # units_lost_lte:0.
+  agent: {faction: allies}
+  enemy: {faction: soviet}
+  tools: [move_units, attack_unit, stop]
+  planning: true
+  termination: {max_ticks: 10000}
+  actors:
+    # 2× jeep scout team at the west spawn — the start region the
+    # team must return to (centre of the units_in_region clause on
+    # easy/medium; spawn-matched corner regions on hard).
+    - {type: jeep, owner: agent, position: [10, 20], stance: 1, count: 2}
+
+levels:
+  # ── EASY ────────────────────────────────────────────────────────
+  # 2 stationary infantry pickets on the direct east lane (y=20).
+  # The fact (discovery target) sits at the far east at (110, 20).
+  # Pickets are easy to detour around (one row north or south
+  # clears them). Generous clock — even a slow detour-and-return
+  # by both jeeps wins. Bruting bleeds a jeep; stalling busts the
+  # clock; reaching the fact but stopping east loses on n:2 return.
+  easy:
+    description: >
+      Two jeep scouts at the west (10, 20). The discovery target —
+      a specific far enemy fact — sits at (110, 20). Two enemy
+      rifle infantry block the direct east lane (around x=60, y=20).
+      Drive AROUND the pickets, reveal the fact, and bring BOTH
+      jeeps BACK to the start region (radius 5 around (10, 20))
+      before the clock expires. Any jeep loss FAILS the mission
+      (zero attrition). Bruting the pickets bleeds a jeep (low
+      jeep DPS vs infantry); stopping after the discovery in
+      enemy territory loses on the n:2 return clause; stalling
+      loses on the clock.
+    overrides:
+      actors:
+        - {type: jeep, owner: agent, position: [10, 20], stance: 1, count: 2}
+        # Two stationary pickets directly on the y=20 lane — react
+        # if approached but don't push (stance:1).
+        - {type: e1, owner: enemy, position: [60, 20], stance: 1}
+        - {type: e1, owner: enemy, position: [62, 21], stance: 1}
+        # Discovery target — the FAR fact (unarmed, persistent so
+        # the episode does not auto-end on accidental nearby kills).
+        - {type: fact, owner: enemy, position: [110, 20]}
+        # A second persistent enemy building so destroying the fact
+        # alone can't auto-`done` the run before the return + no-
+        # loss clauses are evaluated.
+        - {type: barr, owner: enemy, position: [113, 22]}
+    win_condition:
+      all_of:
+        - {buildings_discovered_gte: 1}
+        - {units_in_region_gte: {x: 10, y: 20, radius: 5, n: 2}}
+        - {units_lost_lte: 0}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {units_lost_lte: 0}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 52
+
+  # ── MEDIUM ──────────────────────────────────────────────────────
+  # +1 controlled variable: a DEFENDED BOTTLENECK. Four stationary
+  # infantry pickets span y=18..22 around x=60 — the central lane
+  # is closed, the scout pair MUST detour through y<14 or y>26 to
+  # make the round trip. The clock still admits the long detour by
+  # both jeeps, but not a stall and not a brute attempt (4× e1
+  # kills a jeep easily).
+  medium:
+    description: >
+      Two jeep scouts at the west (10, 20). The discovery target —
+      a specific far enemy fact — sits at (110, 20). FOUR enemy
+      rifle infantry form a defended bottleneck across the central
+      lane (around x=58..62, y=16..22), closing the direct east
+      route. Detour AROUND the bottleneck (y<14 or y>26), reveal
+      the fact, and bring BOTH jeeps BACK to the start region
+      (radius 5 around (10, 20)) before the clock. Any jeep loss
+      FAILS the mission. Bruting four e1 with jeeps loses; the
+      central lane is closed. Stalling loses on the clock; one-way
+      commits that strand a jeep east lose on the n:2 return.
+    overrides:
+      actors:
+        - {type: jeep, owner: agent, position: [10, 20], stance: 1, count: 2}
+        # Four-infantry bottleneck spanning the central lane.
+        # stance:1 — react/defend in place; they don't pursue out
+        # of range, but a jeep that walks into the cluster eats
+        # four-on-one and dies.
+        - {type: e1, owner: enemy, position: [58, 18], stance: 1}
+        - {type: e1, owner: enemy, position: [60, 20], stance: 1}
+        - {type: e1, owner: enemy, position: [62, 22], stance: 1}
+        - {type: e1, owner: enemy, position: [60, 16], stance: 1}
+        - {type: fact, owner: enemy, position: [110, 20]}
+        - {type: barr, owner: enemy, position: [113, 22]}
+    win_condition:
+      all_of:
+        - {buildings_discovered_gte: 1}
+        - {units_in_region_gte: {x: 10, y: 20, radius: 5, n: 2}}
+        - {units_lost_lte: 0}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {units_lost_lte: 0}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 52
+
+  # ── HARD ────────────────────────────────────────────────────────
+  # +1 more controlled variable: TWO SEED-VARIED SPAWN GROUPS
+  # (N start vs S start) AND a SECOND SCATTERED DEFENDER GROUP so
+  # the in-route geometry differs per seed. The bottleneck is also
+  # THICKENED with two flank pickets so the inner detour bands
+  # (y≈12 / y≈28) are no longer safe — only the FAR edge of the
+  # map matching the spawn corner (y≈4 for N start, y≈35 for S
+  # start) clears the bottleneck. The two return regions are
+  # disjoint (N is (10, 8), S is (10, 32)); a wrong-corner return
+  # doesn't satisfy the clause. The discovery target plus a second
+  # persistent enemy building remain at the eastern edge so the
+  # engine doesn't auto-`done` on a chance kill.
+  hard:
+    description: >
+      Two jeep scouts at the west, started at the NORTH (10, 8) or
+      SOUTH (10, 32) corner by seed. The discovery target — a
+      specific far enemy fact — sits at (110, 20). SIX stationary
+      infantry thicken the central bottleneck (spanning y=14..24
+      around x=58..62) and TWO additional flank pickets (one
+      north, one south) sit forward at x≈50 so the inner detour
+      bands are also contested. The scout team must pick the FAR
+      edge of the map matching its spawn corner (y≈4 lane for a
+      NORTH start, y≈35 lane for a SOUTH start), weave east to
+      surface the fact, climb back to that edge, and RETURN BOTH
+      jeeps to the matching corner region (radius 5 around (10, 8)
+      NORTH or (10, 32) SOUTH). Any jeep loss FAILS the mission.
+      Bruting the bottleneck loses; the wrong-corner edge attrites
+      the jeeps before they cross; stalling loses on the clock.
+    overrides:
+      actors:
+        # Two seed-varied agent spawn corners (N vs S). count:2 at
+        # each so each spawn group gets a 2-jeep team.
+        - {type: jeep, owner: agent, position: [10, 8],  stance: 1, count: 2, spawn_point: 0}
+        - {type: jeep, owner: agent, position: [10, 32], stance: 1, count: 2, spawn_point: 1}
+        # Thickened central bottleneck: four central pickets (as in
+        # medium) plus two flank pickets at y=14 / y=24 so the
+        # inner detour bands (y≈12 / y≈28) cannot weave through in
+        # e1's react range (~5 cells). The far-edge bands at
+        # y≈4..5 (north) and y≈34..35 (south) remain safely clear.
+        - {type: e1, owner: enemy, position: [58, 18], stance: 1}
+        - {type: e1, owner: enemy, position: [60, 20], stance: 1}
+        - {type: e1, owner: enemy, position: [62, 22], stance: 1}
+        - {type: e1, owner: enemy, position: [60, 16], stance: 1}
+        - {type: e1, owner: enemy, position: [60, 14], stance: 1}
+        - {type: e1, owner: enemy, position: [60, 24], stance: 1}
+        # Second scattered defender group — one forward picket per
+        # band at x≈50, placed in the INNER detour band (y=12 /
+        # y=28) so they punish a near-edge weave (y≈10 / y≈30) but
+        # stay safely OUT of react range from the FAR edge lanes
+        # the intended policy uses: y=12 → y=4 is 8 cells (clear),
+        # y=28 → y=35 is 7 cells (clear), both well past the
+        # ~5-cell e1 react radius. A scout that tries to cut a
+        # shorter inner detour walks right into them.
+        - {type: e1, owner: enemy, position: [50, 12], stance: 1}
+        - {type: e1, owner: enemy, position: [50, 28], stance: 1}
+        - {type: fact, owner: enemy, position: [110, 20]}
+        - {type: barr, owner: enemy, position: [113, 22]}
+    # Hard win: discover + return BOTH jeeps to the spawn-matching
+    # corner. `any_of` over the two corners — the team returns to
+    # its OWN corner. The full-team-intact bar (units_lost_lte:0)
+    # still applies.
+    win_condition:
+      all_of:
+        - {buildings_discovered_gte: 1}
+        - any_of:
+            - {units_in_region_gte: {x: 10, y: 8,  radius: 5, n: 2}}
+            - {units_in_region_gte: {x: 10, y: 32, radius: 5, n: 2}}
+        - {units_lost_lte: 0}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {units_lost_lte: 0}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 52

tests/test_hard_tier.py

@@ -387,6 +387,19 @@ UPGRADED = [
     # and a memorised "always defend at y=N" opening cannot
     # generalise.
     "econ-contention-with-enemy",
+    # Wave-6 perception pack — military intelligence reconnaissance
+    # (recon-and-extract) / SC2 scout-and-return for info / drone
+    # surveillance with return-to-base / intel ops: gather then withdraw.
+    # Sibling of scout-and-survive (which permits ANY return of a single
+    # jeep); this pack requires the WHOLE 2-jeep team to extract INTACT
+    # (`units_lost_lte:0` + `units_in_region_gte n:2`) AFTER revealing
+    # the specific far enemy fact. Hard defines two agent spawn_point
+    # groups (NORTH (10,8) / SOUTH (10,32)) round-robined by seed; the
+    # win clause is `any_of` over the two matching corner-return
+    # regions, and a second scattered defender group at the inner
+    # bands (y=12 / y=28) punishes the near-edge shortcut so a
+    # memorised single-detour-band opening cannot generalise.
+    "scout-and-report",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation

tests/test_scout_and_report.py

@@ -0,0 +1,371 @@
+"""scout-and-report — perception pack with REVEAL + FULL-TEAM EXTRACT.
+
+Sibling to scout-and-survive (which requires only ANY return of a
+single jeep). This pack adds the BOTH-jeep extraction bar and the
+specific-far-target reveal bar:
+
+  * 2× jeep scout team (one jeep = the asset, two = the report channel)
+  * far enemy fact at (110, 20) (the specific target)
+  * win = buildings_discovered_gte:1 AND n:2 units in start region
+          AND units_lost_lte:0 AND within_ticks:4500
+
+Scripted policies cover the four bar-defining outcomes per CLAUDE.md
+"no defect, no cheat":
+
+  * stall                          → LOSS (clock; nothing discovered)
+  * one-way scout (no return)      → LOSS (n:2 return clause unmet)
+  * brute attack the defenders     → LOSS (units_lost_lte:0 — jeep
+                                     dies to picket return-fire)
+  * intended discover-and-return   → WIN (every level, seeds 1..4)
+
+Hard tier additionally rotates the agent spawn corner between NORTH
+(10, 8) and SOUTH (10, 32) by seed; the intended policy routes per-
+corner and returns BOTH jeeps to the SAME corner. The pack's hard
+win clause is `any_of` over the two corner regions so a correct
+round trip to either corner satisfies it.
+"""
+
+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 compile_level
+
+PACK_PATH = (
+    Path(__file__).parent.parent
+    / "openra_bench"
+    / "scenarios"
+    / "packs"
+    / "scout-and-report.yaml"
+)
+
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+
+# ── Pack-shape tests (cheap; no engine) ───────────────────────────
+
+
+def test_pack_compiles_with_three_levels():
+    pack = load_pack(PACK_PATH)
+    assert pack.meta.id == "scout-and-report"
+    assert pack.meta.capability == "perception"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+
+
+def test_meta_benchmark_anchor_set():
+    """Seed-taxonomy contract: anchors must call out the military-
+    intel / SC2 recon-and-report / drone-surveillance framing."""
+    pack = load_pack(PACK_PATH)
+    anchors = pack.meta.benchmark_anchor or []
+    assert any("military intelligence" in a for a in anchors), anchors
+    assert any("SC2 scout" in a for a in anchors), anchors
+    assert any("drone surveillance" in a for a in anchors), anchors
+    assert any("intel ops" in a for a in anchors), anchors
+
+
+def test_every_level_has_fail_condition():
+    """No silent draws — every level emits a real LOSS on timeout
+    or scout-death."""
+    pack = load_pack(PACK_PATH)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.fail_condition is not None, f"{lvl} missing fail_condition"
+
+
+def test_hard_tier_has_seed_driven_spawn_groups():
+    """Hard must define ≥2 agent spawn_point groups (the binding
+    contract from tests/test_hard_tier.py::UPGRADED)."""
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    sp = {a.spawn_point for a in c.scenario.actors if a.owner == "agent"}
+    assert len(sp) >= 2, f"hard needs ≥2 spawn groups, got {sp}"
+
+
+def test_tick_budget_aligned_with_max_turns():
+    """within_ticks/after_ticks must be reachable inside max_turns.
+    Engine advances ~90 ticks/turn → reachable max = 93 + 90·(N-1)."""
+    pack = load_pack(PACK_PATH)
+    for lvl in LEVELS:
+        level_def = pack.levels[lvl]
+        max_turns = level_def.max_turns
+        reachable = 93 + 90 * (max_turns - 1)
+        win = compile_level(pack, lvl).win_condition.model_dump(exclude_none=True)
+
+        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] = []
+        _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"
+            )
+
+
+def test_return_clause_n2_present_in_win():
+    """Defining feature: the win must enforce n:2 (full-team) return
+    at the start region, not just ANY jeep returning."""
+    pack = load_pack(PACK_PATH)
+    for lvl in LEVELS:
+        win = compile_level(pack, lvl).win_condition.model_dump(exclude_none=True)
+        found: list = []
+
+        def _walk(node):
+            if isinstance(node, dict):
+                if "units_in_region_gte" in node:
+                    found.append(node["units_in_region_gte"])
+                for v in node.values():
+                    _walk(v)
+            elif isinstance(node, list):
+                for v in node:
+                    _walk(v)
+
+        _walk(win)
+        assert found, f"{lvl}: missing units_in_region_gte return clause"
+        for spec in found:
+            assert int(spec.get("n", 1)) >= 2, (
+                f"{lvl}: units_in_region_gte must require n>=2 (full team), "
+                f"got {spec}"
+            )
+
+
+def test_units_lost_lte_zero_in_win():
+    """The full-team-intact bar: units_lost_lte:0 must be a win clause
+    (the no-attrition extraction teeth)."""
+    pack = load_pack(PACK_PATH)
+    for lvl in LEVELS:
+        win = compile_level(pack, lvl).win_condition.model_dump(exclude_none=True)
+        found: list = []
+
+        def _walk(node):
+            if isinstance(node, dict):
+                if "units_lost_lte" in node:
+                    found.append(node["units_lost_lte"])
+                for v in node.values():
+                    _walk(v)
+            elif isinstance(node, list):
+                for v in node:
+                    _walk(v)
+
+        _walk(win)
+        assert found, f"{lvl}: missing units_lost_lte clause (no attrition teeth)"
+        assert 0 in [int(x) for x in found], (
+            f"{lvl}: units_lost_lte must include 0 (zero-attrition extract); "
+            f"got {found}"
+        )
+
+
+# ── Scripted policies ─────────────────────────────────────────────
+
+
+def _stall(_rs, Command):
+    return [Command.observe()]
+
+
+def _one_way_scout(rs, Command):
+    """Push BOTH jeeps east to near the fact and STOP there. Discovers
+    the fact but never returns ⇒ units_in_region_gte clause unmet ⇒
+    LOSS. Models the "discovery is the goal" misread that the pack
+    exists to catch."""
+    units = rs.get("units_summary", []) or []
+    if not units:
+        return [Command.observe()]
+    cmds = []
+    for u in units:
+        uid = str(u["id"])
+        ux, _uy = u["cell_x"], u["cell_y"]
+        if ux < 50:
+            # Climb to the y=4 edge lane to get past the central
+            # bottleneck (works on every level), then run east.
+            cmds.append(Command.move_units([uid], target_x=50, target_y=4))
+        elif ux < 105:
+            cmds.append(Command.move_units([uid], target_x=108, target_y=4))
+        elif ux < 108:
+            # Dip down to the fact's row to reveal it.
+            cmds.append(Command.move_units([uid], target_x=110, target_y=20))
+        else:
+            # ARRIVED — stop in enemy territory, never return.
+            cmds.append(Command.stop([uid]))
+    return cmds
+
+
+def _brute_attack(rs, Command):
+    """Drive both jeeps straight east through the picket stack at
+    x=58..62, y=18..22. The jeeps auto-fire opportunistically in
+    range and draw return fire from the picket stack. Jeep DPS vs an
+    infantry stack is poor; at least one jeep dies before crossing,
+    so units_lost_lte:0 fires the LOSS clause."""
+    units = rs.get("units_summary", []) or []
+    if not units:
+        return [Command.observe()]
+    cmds = []
+    for u in units:
+        uid = str(u["id"])
+        cmds.append(Command.move_units([uid], target_x=110, target_y=20))
+    return cmds
+
+
+def _intended_discover_and_return(rs, Command):
+    """Both jeeps: climb to the spawn-matching edge lane, run east,
+    dip down to (110, 20) to surface the fact, climb back to the
+    edge lane, traverse west, drop to the spawn cell. The team
+    returns INTACT to the SAME spawn corner.
+
+    Phases:
+      1. Outbound — climb to edge lane (y≈4 from NORTH, y≈35 from
+         SOUTH), run east, dip to reveal the fact at (110, 20).
+      2. Return — climb back to the edge lane (so the west traverse
+         doesn't pass through the central bottleneck at y=14..24
+         on hard), traverse west on the edge, drop to the start
+         cell.
+    """
+    state = _intended_discover_and_return._state  # type: ignore[attr-defined]
+    units = rs.get("units_summary", []) or []
+    if not units:
+        return [Command.observe()]
+
+    # Latch each jeep's start cell once (its actual spawn) so the
+    # return trip targets its OWN spawn corner.
+    if not state["starts"]:
+        # Use ALL units' spawn cells (the agent's persistent ID set
+        # is stable across turns).
+        for u in units:
+            state["starts"][str(u["id"])] = (u["cell_x"], u["cell_y"])
+
+    # Detect discovery (fact in enemy_buildings_summary).
+    eb = rs.get("enemy_buildings_summary", []) or []
+    if any(b.get("type") == "fact" for b in eb):
+        state["discovered"] = True
+
+    cmds = []
+    for u in units:
+        uid = str(u["id"])
+        ux, uy = u["cell_x"], u["cell_y"]
+        sx, sy = state["starts"].get(uid, (ux, uy))
+        # Spawn-matching edge lane.
+        edge_y = 35 if sy >= 26 else 4
+
+        if not state["discovered"]:
+            if ux < 25:
+                cmds.append(Command.move_units([uid], target_x=25, target_y=edge_y))
+            elif ux < 105:
+                cmds.append(Command.move_units([uid], target_x=108, target_y=edge_y))
+            else:
+                # Final dip down to the fact's row to reveal it.
+                cmds.append(Command.move_units([uid], target_x=110, target_y=20))
+        else:
+            # Return: climb back to edge lane first, then traverse
+            # west, then drop to the start cell.
+            if abs(uy - edge_y) > 4 and ux > 100:
+                cmds.append(Command.move_units([uid], target_x=ux, target_y=edge_y))
+            elif ux > 25:
+                cmds.append(Command.move_units([uid], target_x=20, target_y=edge_y))
+            else:
+                cmds.append(Command.move_units([uid], target_x=sx, target_y=sy))
+    return cmds
+
+
+_intended_discover_and_return._state = {  # type: ignore[attr-defined]
+    "starts": {},
+    "discovered": False,
+}
+
+
+def _reset_intended_state():
+    _intended_discover_and_return._state["starts"] = {}  # type: ignore[attr-defined]
+    _intended_discover_and_return._state["discovered"] = False  # type: ignore[attr-defined]
+
+
+# ── Solvency: intended WINS every (level, seed) ───────────────────
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_intended_discover_and_return_wins(level, seed):
+    _reset_intended_state()
+    c = compile_level(load_pack(PACK_PATH), level)
+    res = run_level(c, _intended_discover_and_return, seed=seed)
+    assert res.outcome == "win", (
+        f"intended discover+return must WIN on {level} s={seed}; "
+        f"got {res.outcome} tick={res.signals.game_tick} "
+        f"bds={len(res.signals.enemy_buildings_seen_ids)} "
+        f"lost={res.signals.units_lost}"
+    )
+
+
+# ── Stability: every non-win pattern is a real reachable LOSS ─────
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_stall_loses(level, seed):
+    c = compile_level(load_pack(PACK_PATH), level)
+    res = run_level(c, _stall, seed=seed)
+    assert res.outcome == "loss", (
+        f"stall must LOSE on {level} s={seed}; got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_one_way_scout_loses(level, seed):
+    """One-way commit: discovers the fact but stops in enemy
+    territory. The n:2 return clause is never satisfied ⇒ LOSS on
+    the clock, never a draw."""
+    c = compile_level(load_pack(PACK_PATH), level)
+    res = run_level(c, _one_way_scout, seed=seed)
+    assert res.outcome == "loss", (
+        f"one-way scout must LOSE on {level} s={seed}; got {res.outcome} "
+        f"bds={len(res.signals.enemy_buildings_seen_ids)} "
+        f"lost={res.signals.units_lost}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", ["medium", "hard"])
+def test_brute_attack_loses_medium_and_hard(level, seed):
+    """Brute through the picket stack: jeep DPS is insufficient vs
+    the 4+× e1 bottleneck (medium/hard); at least one jeep dies to
+    return-fire ⇒ units_lost_lte:0 fires ⇒ LOSS.
+
+    Easy is intentionally permissive (only 2 pickets) — a brute
+    play CAN survive on easy. The strict bar is medium/hard."""
+    c = compile_level(load_pack(PACK_PATH), level)
+    res = run_level(c, _brute_attack, seed=seed)
+    assert res.outcome == "loss", (
+        f"brute attack must LOSE on {level} s={seed}; got {res.outcome} "
+        f"lost={res.signals.units_lost} "
+        f"bds={len(res.signals.enemy_buildings_seen_ids)}"
+    )
+
+
+# ── Spawn variation contract (hard) ───────────────────────────────
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+def test_hard_seeds_produce_distinct_starts(seed):
+    """Hard's two spawn_point groups must actually round-robin —
+    seeds 1..4 collectively must produce ≥2 distinct starts. The
+    spawn-variation contract is enforced cross-seed by
+    tests/test_hard_tier.py::test_curated_hard_still_compiles_and_runs."""
+    c = compile_level(load_pack(PACK_PATH), "hard")
+    res = run_level(c, _stall, seed=seed)
+    assert res.outcome == "loss"
+    sp = {a.spawn_point for a in c.scenario.actors if a.owner == "agent"}
+    assert len(sp) >= 2