feat(scenario): build-tech-skip-decision — skip the unneeded tech tier (PlanBench step-pruning / YAGNI anchor)

openra_bench/scenarios/packs/build-tech-skip-decision.yaml

@@ -0,0 +1,278 @@
+# build-tech-skip-decision — skip an unnecessary tech tier (YAGNI)
+#
+# REASONING capability — PlanBench unnecessary-step PRUNING. The
+# objective only needs BASIC infantry (e1, $100, trainable from turn 1
+# off the pre-placed tent). Climbing the full tech chain to a war
+# factory and medium tanks (powr → proc → weap + fix → 2tnk) is a
+# whole tech tier the objective never asks for: it wastes cash AND —
+# critically — the clock. The agent must recognise the goal does not
+# require high tech and skip STRAIGHT to the cheap e1-swarm path.
+#
+# Real-world anchors:
+#   • PlanBench unnecessary-step pruning — find the plan that omits
+#     every action the goal does not require, not merely SOME plan.
+#   • Lean process / muda elimination — do not add a production step
+#     the deliverable never consumes.
+#   • YAGNI ("You Aren't Gonna Need It") — do not build capability the
+#     requirement does not call for; it costs time and budget now.
+#
+# THE DECISION (the whole test):
+#   The agent starts with a Construction Yard (fact) + an Allied
+#   barracks (tent) already standing — so `e1` rifle infantry are
+#   buildable from turn 1 with NO prior tech step. A light enemy
+#   garrison of rifle infantry is incoming from the east (stance 3,
+#   AttackAnything — it advances on the agent base). Killing K of them
+#   is the objective. An e1 swarm (cost $100 each) clears a light
+#   infantry garrison comfortably when massed at the base and left to
+#   auto-fire as the garrison closes; the agent need only keep
+#   training e1 and rallying them at the base front.
+#
+#   The TECH-FULL-CHAIN play instead spends the budget and the clock
+#   building powr → proc → weap (+ fix) to reach medium tanks. That is
+#   a whole tech tier the garrison never required: by the deadline the
+#   tech play has only powr+proc standing and ZERO army — no tank has
+#   fielded — so the kill bar is unmet ⇒ LOSS on the clock. Stalling
+#   never kills anything ⇒ LOSS on the clock.
+#
+# Engine facts used (RA ruleset / prompt_v2 codex / CLAUDE.md):
+#   • e1 rifle infantry: cost $100, trainable from a barracks/tent.
+#     The tent is PRE-PLACED, so e1 is buildable on turn 1 with no
+#     prerequisite build — the cheap path is immediately actionable.
+#   • Full tech chain to medium tanks: powr ($300) → proc ($1400,
+#     prereq anypower) → weap ($2000, prereq proc); 2tnk ($850,
+#     prereq weap + fix). Three structures + a service depot before a
+#     single tank — many turns of placement + queue time; measured,
+#     the tech play has only reached powr+proc by the deadline.
+#   • A `stance:3` (AttackAnything) enemy advances toward the nearest
+#     visible foe (CLAUDE.md stance semantics) — so the garrison
+#     closes on the agent base on its own; the intended play just
+#     masses e1 at the base front and lets them auto-fire as
+#     defenders (concentrated fire beats the strung-out attacker).
+#   • `place_building` has no adjacency requirement (CLAUDE.md): the
+#     tech play's LOSS is from time cost, not placement difficulty.
+#   • Tick alignment: the engine advances ~90 ticks per decision turn,
+#     so within_ticks ≤ 93 + 90·(max_turns − 1). fail_condition uses
+#     after_ticks = within_ticks + 1 so a non-finisher LOSES one tick
+#     past the window — a real reachable timeout, never a DRAW.
+#   • A persistent unarmed enemy `fact` marker far east keeps the
+#     episode alive past the last garrison death so a non-winner
+#     reaches the deadline as a real LOSS (CLAUDE.md auto-done
+#     footgun).
+#   • `building_count_gte` (counts the live own_buildings list) is
+#     used for the fact-alive clause instead of `has_building`
+#     (CLAUDE.md own-elimination footgun).
+#   • Hard tier: the `spawn_point` filter applies ONLY to agent
+#     actors, and ANY agent actor with spawn_point filters out agent
+#     actors WITHOUT one (CLAUDE.md oramap.rs footgun). So the whole
+#     agent base (fact + tent) is duplicated across both spawn_point
+#     groups; the garrison + far enemy marker carry no spawn_point
+#     and always place.
+#
+# DISCRIMINATIONS (CLAUDE.md bar — no defect, no cheat, no draw):
+#   • stall (only observe): LOSS — 0 kills, the after_ticks deadline
+#     bites as a real reachable timeout.
+#   • tech-full-chain (build powr → proc → weap → fix, then 2tnk):
+#     LOSS — the unneeded tech tier burns the clock; by the deadline
+#     only powr+proc stand and no tank has fielded ⇒ kill bar unmet.
+#   • intended skip-to-e1-swarm (train e1 from the pre-placed tent
+#     from turn 1, rally them at the base front, let them auto-fire
+#     on the closing garrison): WIN — the kill bar is met AND the
+#     fact survives, well inside the deadline.
+#
+# Validate (no model / no network):
+#   python3 -m pytest tests/test_build_tech_skip_decision.py -q
+
+meta:
+  id: build-tech-skip-decision
+  title: 'Skip the Unneeded Tech Tier — Clear a Light Garrison with a Basic e1 Swarm'
+  capability: reasoning
+  real_world_meaning: >
+    The objective only requires basic units. The agent starts with a
+    Construction Yard and an Allied barracks already standing, so cheap
+    rifle infantry (e1) are trainable from turn 1 with no prior tech
+    step, and a light enemy garrison — also basic infantry — is
+    incoming. An e1 swarm clears a light infantry garrison comfortably.
+    The trap is to climb the full tech chain (power plant → refinery →
+    war factory → service depot → medium tanks) to bring a higher tech
+    tier online that the objective never asked for: that whole tier
+    costs budget and, critically, clock — by the deadline no tank has
+    fielded at all. The pack tests whether the model recognises that
+    the goal does not require high tech and skips straight to the
+    cheap path.
+  robotics_analogue: >
+    Right-sizing the plan to the task. A delivery only needs a basic
+    pick-and-place cell that is already commissioned; provisioning a
+    full high-precision assembly line (extra power, feedstock, an
+    assembly station, a calibration depot) before starting work is a
+    whole capability tier the job never required — it burns budget and
+    blows the cycle-time deadline. The competent planner prunes every
+    step the goal does not consume and executes the minimal plan with
+    the capability already on hand.
+  benchmark_anchor:
+    - "PlanBench unnecessary-step pruning"
+    - "lean process"
+    - "YAGNI"
+  author: openra-bench
+
+base_map: rush-hour-arena
+# Cash covers a generous e1 swarm ($100 each) many times over AND, on
+# its own, a full tech chain (powr 300 + proc 1400 + weap 2000 + fix +
+# a 2tnk) — so the budget is NOT the binding constraint. The CLOCK is:
+# the tech tier simply cannot come online in time. Cash is kept ample
+# so the tech play's LOSS attributes cleanly to the wasted tier
+# (time), not to running out of money.
+starting_cash: 6000
+
+base:
+  agent: {faction: allies}
+  # No scripted bot — the garrison is a fixed group of stance:3
+  # (AttackAnything) rifle infantry that advances on the agent base
+  # on its own. The intended e1 swarm fights it as a base defender.
+  enemy: {faction: soviet, bot_type: '', cash: 0}
+  tools: [observe, build, place_building, move_units, attack_move, stop]
+  spawn_mcvs: false
+  planning: true
+  # Re-decide the instant a garrison unit is spotted or one of our own
+  # is destroyed — the skip-to-cheap-path call is made from the live
+  # threat reading, not on fixed cadence.
+  interrupts:
+    enemy_unit_spotted: true
+    own_unit_destroyed: true
+  termination: {max_ticks: 12000}
+  actors: []
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Bare step-pruning skill. Pre-placed fact + tent ⇒ e1 buildable
+  # turn 1. A light garrison of 5 rifle infantry (stance 3) advances
+  # from x=52. Training e1 and rallying them at the base front clears
+  # the 4-kill bar by ~tick 633 — a wide buffer under tick 1800. The
+  # tech-full-chain play has only powr+proc standing by the deadline
+  # and zero army ⇒ LOSS. max_turns 25 → reachable tick 93 + 90·24 =
+  # 2253 > 1801 ✓ (the deadline bites as a real LOSS).
+  easy:
+    description: >
+      Your base already has a Construction Yard (fact) and an Allied
+      barracks (tent) — so rifle infantry (e1, $100 each) are
+      buildable from turn 1 with NO prior tech step. A light enemy
+      garrison of 5 rifle infantry is advancing from the east. The
+      objective needs only basic units: train an e1 swarm and rally it
+      at your base front to meet the garrison. Do NOT climb the tech
+      chain to a war factory and tanks — that is a whole tech tier the
+      objective never asked for and it overruns the clock. Win when
+      ≥4 enemy units are killed AND your fact still stands, before
+      tick 1800. Stalling or teching to tanks both LOSE on the clock.
+    starting_cash: 6000
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 20]}
+        - {type: tent, owner: agent, position: [13, 20]}
+        # Light garrison — 5× e1, stance 3 (AttackAnything ⇒ advances
+        # on the agent base). An e1 swarm massed at the base clears
+        # them; the tech play never fields a tank in time.
+        - {type: e1, owner: enemy, position: [52, 20], stance: 3, count: 5}
+        # Far unarmed enemy fact marker — anti-DRAW. Keeps the
+        # episode alive past the last garrison death so a
+        # non-winner reaches the deadline as a real LOSS.
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 4}
+        - {building_count_gte: {type: fact, n: 1}}
+        - {within_ticks: 1800}
+    fail_condition:
+      any_of:
+        - {after_ticks: 1801}
+        - {not: {building_count_gte: {type: fact, n: 1}}}
+    max_turns: 25
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 controlled variable: a LARGER garrison (7× e1) AND a TIGHTER
+  # deadline (tick 1600). The e1-swarm play still wins comfortably
+  # (~tick 633); the tech-full-chain play loses by an even wider
+  # margin. Same base. max_turns 23 → reachable tick 93 + 90·22 =
+  # 2073 > 1601 ✓.
+  medium:
+    description: >
+      Same base (fact + tent pre-placed, e1 buildable from turn 1) but
+      a larger enemy garrison (7 rifle infantry) and a tighter
+      deadline. The objective still needs only basic units: train an
+      e1 swarm and rally it at your base front. Climbing the tech
+      chain to a war factory and tanks is an unnecessary tier that
+      overruns the clock. Win when ≥6 enemy units are killed AND your
+      fact still stands, before tick 1600. Stalling or teching to
+      tanks both LOSE on the clock.
+    starting_cash: 6000
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 20]}
+        - {type: tent, owner: agent, position: [13, 20]}
+        - {type: e1, owner: enemy, position: [52, 20], stance: 3, count: 7}
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 6}
+        - {building_count_gte: {type: fact, n: 1}}
+        - {within_ticks: 1600}
+    fail_condition:
+      any_of:
+        - {after_ticks: 1601}
+        - {not: {building_count_gte: {type: fact, n: 1}}}
+    max_turns: 23
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 controlled variable on top of medium: TWO agent spawn_point
+  # groups (NORTH base y=14 / SOUTH base y=26) round-robined by seed.
+  # The whole base (fact + tent) is duplicated at both latitudes so
+  # the e1 rally geometry must be read from the actual base position —
+  # a memorised opening cannot generalise. The garrison is duplicated
+  # at BOTH latitudes (enemy actors don't honour spawn_point —
+  # CLAUDE.md) so whichever spawn is chosen faces an equivalent
+  # garrison; the garrison at the agent's latitude advances on the
+  # base, the other angles toward the nearest foe. Same 6-kill bar
+  # and same tight tick-1600 deadline as medium. max_turns 23 →
+  # reachable tick 2073 > 1601 ✓.
+  hard:
+    description: >
+      Same step-pruning call as medium (clear a 7-rifle garrison with
+      a basic e1 swarm before tick 1600; skip the unnecessary war-
+      factory tech tier) but your base may begin in the NORTH band
+      (y≈14) or the SOUTH band (y≈26) depending on the seed. Read
+      your barracks' actual position from the observation, train the
+      e1 swarm and rally it at your base front. Win when ≥6 enemy
+      units are killed AND your fact still stands, before tick 1600.
+      Stalling or teching to tanks both LOSE on the clock.
+    starting_cash: 6000
+    overrides:
+      actors:
+        # ── AGENT spawn 0 — NORTH base (y=14) ─────────────────────
+        - {type: fact, owner: agent, position: [10, 14], spawn_point: 0}
+        - {type: tent, owner: agent, position: [13, 14], spawn_point: 0}
+        # Inert spawn-witness e1 (HoldFire, stance 0): required for
+        # the hard-tier units_summary spawn-variation check (the
+        # base is otherwise building-only). Placed base-adjacent;
+        # stance 0 means it never opens fire — it does not change
+        # the skip-vs-tech decision, only surfaces per-spawn data.
+        - {type: e1, owner: agent, position: [11, 14], spawn_point: 0, stance: 0}
+        # ── AGENT spawn 1 — SOUTH base (y=26) ─────────────────────
+        - {type: fact, owner: agent, position: [10, 26], spawn_point: 1}
+        - {type: tent, owner: agent, position: [13, 26], spawn_point: 1}
+        - {type: e1, owner: agent, position: [11, 26], spawn_point: 1, stance: 0}
+        # Garrison duplicated at both latitudes — enemy actors don't
+        # honour spawn_point, so both place every seed; the garrison
+        # at the agent's latitude advances on the base.
+        - {type: e1, owner: enemy, position: [52, 14], stance: 3, count: 7}
+        - {type: e1, owner: enemy, position: [52, 26], stance: 3, count: 7}
+        # Far unarmed enemy fact marker — anti-DRAW (no spawn_point
+        # ⇒ always places).
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {units_killed_gte: 6}
+        - {building_count_gte: {type: fact, n: 1}}
+        - {within_ticks: 1600}
+    fail_condition:
+      any_of:
+        - {after_ticks: 1601}
+        - {not: {building_count_gte: {type: fact, n: 1}}}
+    max_turns: 23

tests/test_build_tech_skip_decision.py

@@ -0,0 +1,365 @@
+"""build-tech-skip-decision — REASONING capability validation.
+
+Skip an unnecessary tech tier (PlanBench unnecessary-step pruning /
+lean process / YAGNI). The objective only needs BASIC infantry: the
+agent starts with a pre-placed Construction Yard (fact) + Allied
+barracks (tent), so rifle infantry (e1, $100) are trainable from turn
+1 with no prior tech step. A light enemy garrison of rifle infantry
+(stance 3, AttackAnything) advances on the base. Training e1 and
+rallying them at the base front clears the kill bar comfortably.
+
+The trap is to climb the full tech chain to medium tanks
+(powr -> proc -> weap + fix -> 2tnk) — a whole tech tier the
+objective never asked for. It burns the clock: by the deadline the
+tech play has only powr+proc standing and ZERO army.
+
+Bar (CLAUDE.md "no defect, no cheat, no draw"):
+
+  * stall (observe-only) LOSES every tier / every hard seed —
+    0 kills, the `after_ticks` deadline bites.
+  * tech-full-chain (build powr -> proc -> weap -> fix, then 2tnk)
+    LOSES every tier / every hard seed — the unneeded tier burns the
+    clock; no tank fields before the deadline, kill bar unmet.
+  * intended skip-to-e1 (train e1 from the pre-placed tent from turn
+    1, rally them at the base front, let them auto-fire on the
+    closing garrison) WINS every tier / every hard seed — the kill
+    bar is met AND the fact survives, well inside the deadline.
+  * hard tier defines >=2 agent spawn_point groups (NORTH base y=14
+    / SOUTH base y=26) round-robined by seed; the garrison is
+    duplicated at both latitudes (enemy actors don't honour
+    spawn_point — CLAUDE.md), so a memorised base-latitude opening
+    cannot generalise.
+"""
+
+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 / "build-tech-skip-decision.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+
+# ── scripted policies ───────────────────────────────────────────────
+
+
+def _stall(rs, C):
+    """Observe-only — no production. 0 kills, the after_ticks
+    deadline bites -> LOSS."""
+    return [C.observe()]
+
+
+def _tech_full_chain(rs, C):
+    """The wrong call: climb the full tech chain (powr -> proc ->
+    weap -> fix -> 2tnk) instead of training basic infantry. The
+    unneeded tier burns the clock — no tank fields before the
+    deadline -> the kill bar is unmet -> LOSS."""
+    ob = rs.get("own_buildings") or []
+    bt = {b.get("type") for b in ob}
+    fy = 20
+    for b in ob:
+        if b.get("type") == "fact":
+            fy = int(b["cell_y"])
+    prod = [p.get("item") for p in (rs.get("production") or []) if isinstance(p, dict)]
+    cmds = []
+    if "powr" not in bt:
+        if "powr" not in prod:
+            cmds.append(C.build("powr"))
+        cmds.append(C.place_building("powr", 17, fy))
+    elif "proc" not in bt:
+        if "proc" not in prod:
+            cmds.append(C.build("proc"))
+        cmds.append(C.place_building("proc", 20, fy))
+    elif "weap" not in bt:
+        if "weap" not in prod:
+            cmds.append(C.build("weap"))
+        cmds.append(C.place_building("weap", 23, fy))
+    elif "fix" not in bt:
+        if "fix" not in prod:
+            cmds.append(C.build("fix"))
+        cmds.append(C.place_building("fix", 23, fy + 4))
+    else:
+        cmds.append(C.build("2tnk"))
+    return cmds or [C.observe()]
+
+
+def _skip_to_e1(rs, C):
+    """The intended capability — skip the tech tier. Train e1 from
+    the pre-placed tent from turn 1 and rally them at the base front;
+    they auto-fire on the closing garrison and clear the kill bar."""
+    units = rs.get("units_summary") or []
+    ob = rs.get("own_buildings") or []
+    fy = 20
+    for b in ob:
+        if b.get("type") == "tent":
+            fy = int(b["cell_y"])
+    ids = [u.get("id") for u in units if u.get("type") == "e1"]
+    cmds = [C.build("e1")]
+    if ids:
+        cmds.append(C.move_units(ids, 18, fy))
+    return cmds
+
+
+# ── structural tests ────────────────────────────────────────────────
+
+
+def test_pack_loads_and_meta_active():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "build-tech-skip-decision"
+    assert pack.meta.capability == "reasoning"
+    assert pack.meta.real_world_meaning
+    assert pack.meta.robotics_analogue
+    anchors = " ".join(pack.meta.benchmark_anchor).lower()
+    assert "planbench" in anchors, anchors
+    assert "pruning" in anchors, anchors
+    assert "yagni" in anchors, anchors
+    assert "lean process" in anchors, anchors
+
+
+def test_tools_include_build_and_combat_surface():
+    """Pack must expose [observe, build, place_building, move_units,
+    attack_move, stop] — the build-and-engage interaction surface."""
+    pack = load_pack(PACK)
+    tools = set(pack.base.get("tools", []) if isinstance(pack.base, dict) else [])
+    for required in ("observe", "build", "place_building", "move_units",
+                     "attack_move", "stop"):
+        assert required in tools, f"missing tool: {required!r}"
+
+
+def test_preplaced_base_is_fact_plus_tent_no_higher_tech():
+    """Every level pre-places fact + tent for the agent — the cheap
+    e1 path must be actionable on turn 1 (tent present) with NO
+    higher-tech building (powr / proc / weap / fix) handed to the
+    agent: building the tech tier is what the agent must AVOID. The
+    hard tier additionally carries an inert HoldFire e1 spawn-witness
+    per spawn group (units_summary spawn-variation contract)."""
+    pack = load_pack(PACK)
+    higher_tech = {"powr", "proc", "weap", "fix", "dome", "apwr"}
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        agent_types = {a.type for a in c.scenario.actors if a.owner == "agent"}
+        assert "fact" in agent_types, f"{lvl}: agent base missing fact"
+        assert "tent" in agent_types, f"{lvl}: agent base missing tent"
+        assert not (agent_types & higher_tech), (
+            f"{lvl}: agent must NOT start with a higher-tech building; "
+            f"got {sorted(agent_types & higher_tech)}"
+        )
+        # only fact / tent / (hard) the inert e1 witness
+        assert agent_types <= {"fact", "tent", "e1"}, (
+            f"{lvl}: unexpected agent actor types {sorted(agent_types)}"
+        )
+
+
+def test_garrison_is_light_infantry_stance3():
+    """The enemy garrison is basic rifle infantry (e1) at stance 3
+    (AttackAnything — advances on the agent base). No tanks / no
+    higher-tech enemy units."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        garrison = [
+            a for a in c.scenario.actors
+            if a.owner == "enemy" and a.type == "e1"
+        ]
+        assert garrison, f"{lvl}: must have an e1 garrison"
+        for a in garrison:
+            assert a.stance == 3, (
+                f"{lvl}: garrison e1 must be stance 3 (AttackAnything); "
+                f"got {a.stance}"
+            )
+        # only e1 + the far fact marker on the enemy side
+        enemy_types = {a.type for a in c.scenario.actors if a.owner == "enemy"}
+        assert enemy_types == {"e1", "fact"}, (
+            f"{lvl}: enemy actors must be {{e1, fact}}; got {sorted(enemy_types)}"
+        )
+
+
+def test_far_enemy_fact_marker_present():
+    """A persistent unarmed enemy fact marker far east keeps the
+    episode alive past the last garrison death (CLAUDE.md auto-done
+    footgun) so a non-winner reaches the deadline as a real LOSS."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        far = [
+            a for a in c.scenario.actors
+            if a.owner == "enemy" and a.type == "fact" and a.position[0] >= 100
+        ]
+        assert far, f"{lvl}: missing far enemy fact marker (anti-DRAW)"
+
+
+def test_every_level_has_reachable_timeout_fail():
+    """`after_ticks` fail must bite WITHIN max_turns (so stall / tech
+    are a real reachable LOSS, not a draw). within_ticks + 1 ==
+    after_ticks so a non-finisher LOSES one tick past the window."""
+    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_ticks {wt} / after_ticks {ft} mismatch "
+            "(boundary non-finisher must LOSE, not draw)"
+        )
+
+
+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 exactly {{0, 1}}; got {sorted(sp)}"
+
+
+def test_in_bounds_actors_on_every_level():
+    """rush-hour-arena playable bounds ~ x:2..126, y:2..38."""
+    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, kills=0, own_buildings=()):
+    import types
+
+    sig = types.SimpleNamespace(
+        game_tick=tick,
+        units_killed=kills,
+        units_lost=0,
+        cash=0,
+        resources=0,
+        own_buildings=list(own_buildings),
+        own_building_types={str(t).lower() for (t, _, _) in own_buildings},
+        enemies_seen_ids=set(),
+        enemy_buildings_seen_ids=set(),
+    )
+    return WinContext(signals=sig, render_state={"units_summary": []})
+
+
+def test_predicates_enforce_capability():
+    """Win requires (kill bar AND fact alive AND in time); fail fires
+    on timeout OR fact destroyed."""
+    c = compile_level(load_pack(PACK), "easy")
+    base_b = [("fact", 10, 20), ("tent", 13, 20)]
+
+    # Intended: 4 kills, fact alive, in time -> WIN
+    assert evaluate(c.win_condition, _ctx(tick=900, kills=4, own_buildings=base_b))
+    # 3 kills (under bar) -> not win
+    assert not evaluate(
+        c.win_condition, _ctx(tick=900, kills=3, own_buildings=base_b)
+    )
+    # 4 kills but past within_ticks -> not win
+    assert not evaluate(
+        c.win_condition, _ctx(tick=1801, kills=4, own_buildings=base_b)
+    )
+    # 4 kills but fact destroyed -> not win
+    assert not evaluate(
+        c.win_condition, _ctx(tick=900, kills=4, own_buildings=base_b[1:])
+    )
+    # Past after_ticks deadline -> fail
+    assert evaluate(
+        c.fail_condition, _ctx(tick=1900, kills=0, own_buildings=base_b)
+    )
+    # Fact destroyed -> fail
+    assert evaluate(
+        c.fail_condition, _ctx(tick=900, kills=4, own_buildings=base_b[1:])
+    )
+    # Within deadline, fact alive -> not fail
+    assert not evaluate(
+        c.fail_condition, _ctx(tick=900, kills=0, own_buildings=base_b)
+    )
+
+
+# ── 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):
+    """Observe-only -> 0 kills + the after_ticks deadline bites ->
+    a real reachable LOSS, not a draw."""
+    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"tick={r.signals.game_tick} kills={r.signals.units_killed}"
+    )
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", SEEDS)
+def test_tech_full_chain_loses_every_tier_and_seed(level, seed):
+    """Climbing the full tech chain (powr -> proc -> weap -> fix ->
+    2tnk) burns the clock on a tier the objective never required -> no
+    tank fields before the deadline -> kill bar unmet -> LOSS."""
+    c = compile_level(load_pack(PACK), level)
+    r = run_level(c, _tech_full_chain, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level}/seed{seed}: tech-full-chain must LOSE (clock); "
+        f"got {r.outcome} tick={r.signals.game_tick} "
+        f"kills={r.signals.units_killed}"
+    )
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize("seed", SEEDS)
+def test_skip_to_e1_wins_every_tier_and_seed(level, seed):
+    """The intended capability — skip the unneeded tech tier, train
+    e1 from the pre-placed tent and rally them at the base front.
+    Wins every tier and every hard seed, well inside the deadline."""
+    c = compile_level(load_pack(PACK), level)
+    r = run_level(c, _skip_to_e1, seed=seed)
+    assert r.outcome == "win", (
+        f"{level}/seed{seed}: skip-to-e1 must WIN; got {r.outcome} "
+        f"tick={r.signals.game_tick} kills={r.signals.units_killed}"
+    )
+
+
+# ── determinism ─────────────────────────────────────────────────────
+
+
+def test_skip_to_e1_run_is_deterministic_per_seed():
+    """Same seed, same policy -> identical outcome / kills / turns."""
+    c = compile_level(load_pack(PACK), "medium")
+    a = run_level(c, _skip_to_e1, seed=3)
+    b = run_level(c, _skip_to_e1, seed=3)
+    assert (a.outcome, a.turns, a.signals.units_killed) == (
+        b.outcome, b.turns, b.signals.units_killed
+    )