feat(scenario): rob-unit-loss-recovery — rebuild force after attrition (PlanBench replanning / SC2 force-regen anchor)

Wave-6 ROBUSTNESS / reasoning capability pack. Agent loses 1+ tank to
an opening-tick enemy salvo and must commission replacements while
continuing the eastward assault. Salvaged from untracked files dropped
in main worktree by W6 agent rob-unit-loss-recovery.

openra_bench/scenarios/packs/rob-unit-loss-recovery.yaml

@@ -0,0 +1,309 @@
+# rob-unit-loss-recovery — rebuild force structure after attrition
+#
+# REASONING capability — react to an exogenous COMBAT-UNIT loss event by
+# (1) recognising the surviving force is below establishment, (2)
+# commissioning replacements from the war-factory with the reserve cash,
+# and (3) executing the original offensive (kill the eastern garrison
+# defending the enemy fact) — fast enough that the deadline still bites.
+#
+# Real-world anchor: PlanBench replanning after exogenous loss (gold
+# standard); SC2 rebuild-after-trade; military force-regen / unit
+# replacement under mid-mission attrition; ScienceWorld error recovery.
+#
+# Discrimination (the four-script policy bar):
+#   • stall (only `observe`): the enemy strike force walks into the
+#     pre-placed agent column, kills 1-4 of the agent's combat tanks,
+#     and the enemy garrison at x=80 is never touched → kill bar (5)
+#     unmet → after_ticks 5401 fires → LOSS.
+#   • no-rebuild (attack_move east but skip `build`): the strike force
+#     kills ≥1 combat tank on the way past; the surviving 3tnks reach
+#     the garrison and clear the kill bar, BUT the type-count clause
+#     (`unit_type_count_gte: {type: 3tnk, n: 4}`) is busted because the
+#     dead tank was never replaced → LOSS.
+#   • intended (rebuild + attack_move east): build('3tnk') whenever the
+#     3tnk count drops below 4, attack_move the live force east. The
+#     replacement budget covers the per-tier expected losses; the
+#     fresh-built tank rejoins the column before the deadline, the
+#     garrison falls, and unit-type-count and kill-bar both pass → WIN.
+#
+# ENGINE NOTES (verified 2026-05-20 with scripted run_level + raw smoke):
+#  - Combat unit is `3tnk` (heavy tank, Soviet faction). Production
+#    requires `fact + weap + fix`. Cost 1150 cr per replacement.
+#  - The enemy uses the `turtle` scripted bot (botgen.py / scripted_
+#    bot.rs) so the eastern e1 garrison HOLDS POSITION instead of
+#    surging west; this isolates the loss event to the pre-placed
+#    `4tnk` striker(s) at x=24 and keeps the kill bar reachable from
+#    a single east-bound assault.
+#  - Strikers are stance:3 (AttackAnything) so they fire on the agent
+#    column from tick 0 — the loss event lands BEFORE the agent's
+#    first decision turn (~tick 90), so even a perfectly-timed flee
+#    cannot fully evade.
+#  - The far enemy `fact` at (120,20) is the engine-auto-done guard
+#    (CLAUDE.md): without a persistent MustBeDestroyed enemy, the
+#    engine ends the episode the moment the last garrison e1 falls,
+#    which can collapse a clean run to DRAW before the win/fail
+#    evaluator sees the terminal frame.
+#  - Tick budget (CLAUDE.md): max_turns=60 ⇒ ceiling tick 5403 ⇒
+#    within_ticks 5400 + after_ticks 5401 both reachable; a non-
+#    finisher LOSES (not draws).
+#  - `not own_units_gte: 1` mis-fires on turn 1 when the agent starts
+#    unit-less (CLAUDE.md footgun). This pack starts with 4 3tnks +
+#    fact, so `own_units_gte: 1` is safe.
+
+meta:
+  id: rob-unit-loss-recovery
+  title: 'Force-Regen After Attrition — Rebuild Combat Force Mid-Episode'
+  capability: reasoning
+  real_world_meaning: >
+    Reactive replan after an exogenous combat-unit loss. An ongoing
+    offensive operation has its force structure unexpectedly cut by an
+    enemy strike (2 units of 4 die in the opening); the agent has just
+    enough reserve cash to commission replacements from the war
+    factory; the offensive deadline is real. The model must notice the
+    loss (units_summary shows fewer combat tanks than the establishment
+    of 4), commit the reserve to rebuilding the combat type (not to a
+    different unit or to nothing), AND continue the original mission
+    (clear the eastern garrison defending the enemy construction yard)
+    fast enough that the deadline still bites.
+  robotics_analogue: >
+    Military force-regen / SC2 rebuild-after-trade. A theater operation
+    loses combat assets to an enemy strike mid-mission; the supervisor
+    has a discrete replacement budget for new units from the rear-area
+    production base; the operational objective and timeline are fixed.
+    The discrimination is whether the model recognises the gap in the
+    advertised force structure AND issues the production order in time
+    to keep the offensive on schedule; ignoring the loss (continuing
+    with a reduced force) under-strengths the assault and busts the
+    establishment bar; spending the budget on the wrong unit type
+    breaks the offensive composition; doing nothing busts the deadline.
+  benchmark_anchor:
+    - "PlanBench replanning under exogenous loss"
+    - "ScienceWorld error recovery"
+    - "military force-regen / unit replacement"
+    - "SC2 rebuild-after-trade"
+  author: "openra-bench"
+
+base_map: rush-hour-arena
+starting_cash: 1500  # per-level override below
+
+base:
+  agent:
+    faction: soviet
+  enemy:
+    faction: allies
+    # `turtle` (Wave-2 scripted bot) — enemy units hold position and
+    # return fire only. This keeps the eastern e1 garrison at x=80
+    # from surging west, so the kill bar is satisfied by an eastbound
+    # assault rather than by absorbing waves into the base. The
+    # pre-placed `4tnk` strikers (stance:3 AttackAnything) handle the
+    # loss event independently — they fire on contact at tick 0.
+    bot_type: turtle
+  tools:
+    - observe
+    - build
+    - place_building
+    - move_units
+    - attack_unit
+    - attack_move
+    - stop
+  planning: true
+  termination:
+    max_ticks: 7000
+
+levels:
+  # ── EASY ────────────────────────────────────────────────────────
+  # The bare skill: 1 expected loss (2 strikers land ~1 tank kill
+  # under stall; intended attack-move + rebuild restores the
+  # establishment of 4 3tnks well inside the budget). Generous
+  # garrison (5 e1) means the kill bar is easily reachable.
+  easy:
+    description: >
+      You command 4 heavy tanks (3tnk) at a forward staging area
+      (x=22, y=18..24) with a production base (fact + powr + weap +
+      fix) behind you. Two enemy heavy tanks (4tnk) are staged at the
+      lane mouth (x=24) and will engage the moment the episode starts
+      — expect ONE of your tanks to die in the opening salvo. An
+      eastern garrison of 5 rifle infantry (e1) at x=80 defends the
+      enemy construction yard. Your reserve cash (1500 cr) covers ONE
+      replacement heavy tank (1150 cr); the intended play is to build
+      a replacement once your 3tnk count drops below 4 AND attack_move
+      east to clear the garrison. Win when you have killed ≥5 enemy
+      units AND you have ≥4 heavy tanks alive AND your construction
+      yard is intact, before tick 5400. Stalling, or assaulting
+      without replacing the loss, both LOSE.
+    starting_cash: 1500
+    overrides:
+      actors:
+        # Agent base: fact + powr + weap + fix at the west edge.
+        - {type: fact, owner: agent, position: [8, 18]}
+        - {type: powr, owner: agent, position: [10, 18]}
+        - {type: weap, owner: agent, position: [12, 18]}
+        - {type: fix,  owner: agent, position: [14, 18]}
+        # 4 combat tanks (3tnk) at the forward staging line.
+        - {type: '3tnk', owner: agent, position: [22, 18], stance: 2}
+        - {type: '3tnk', owner: agent, position: [22, 20], stance: 2}
+        - {type: '3tnk', owner: agent, position: [22, 22], stance: 2}
+        - {type: '3tnk', owner: agent, position: [22, 24], stance: 2}
+        # Strike force: 2× 4tnk at the lane mouth (stance:3 fire on
+        # contact; range 5 covers the agent column at x=22).
+        - {type: '4tnk', owner: enemy, position: [24, 19], stance: 3}
+        - {type: '4tnk', owner: enemy, position: [24, 23], stance: 3}
+        # Eastern garrison: 5 rifle infantry defending the enemy fact.
+        # Stance:1 ReturnFire so they hold but engage when fired upon.
+        - {type: e1, owner: enemy, position: [80, 18], stance: 1}
+        - {type: e1, owner: enemy, position: [80, 20], stance: 1}
+        - {type: e1, owner: enemy, position: [80, 22], stance: 1}
+        - {type: e1, owner: enemy, position: [80, 24], stance: 1}
+        - {type: e1, owner: enemy, position: [82, 20], stance: 1}
+        # Persistent enemy `fact` far east (engine auto-done guard).
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {unit_type_count_gte: {type: '3tnk', n: 4}}
+        - {units_killed_gte: 5}
+        - {has_building: fact}
+        - {within_ticks: 5400}
+    fail_condition:
+      any_of:
+        - {after_ticks: 5401}
+        - {not: {own_units_gte: 1}}
+        - {not: {has_building: fact}}
+    max_turns: 60
+
+  # ── MEDIUM ──────────────────────────────────────────────────────
+  # +1 controlled variable: TIGHTER strike (3× 4tnk strikers instead
+  # of 2) AND larger garrison (6 e1 vs 5). The replacement budget is
+  # held at 1500 cr — STILL one replacement, so the agent must absorb
+  # the same expected single-tank loss but the strike is harder to
+  # outrun and the kill bar requires a longer dwell at the garrison.
+  medium:
+    description: >
+      Tougher version: THREE enemy heavy tanks (4tnk) are staged at
+      the lane mouth (x=24, y=18..24) and will engage the moment the
+      episode starts — expect ONE of your tanks to die in the opening
+      salvo (the additional strikers spread fire, but still resolve to
+      ~1 lost agent tank against the same 4-tank establishment). The
+      eastern garrison is now 6 rifle infantry at x=80. Reserve cash
+      (1500 cr) still covers ONE replacement 3tnk. Win when you have
+      killed ≥5 enemy units AND you have ≥4 heavy tanks alive AND
+      your construction yard is intact, before tick 5400. Stalling
+      and assault-without-rebuild both LOSE.
+    starting_cash: 1500
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [8, 18]}
+        - {type: powr, owner: agent, position: [10, 18]}
+        - {type: weap, owner: agent, position: [12, 18]}
+        - {type: fix,  owner: agent, position: [14, 18]}
+        - {type: '3tnk', owner: agent, position: [22, 18], stance: 2}
+        - {type: '3tnk', owner: agent, position: [22, 20], stance: 2}
+        - {type: '3tnk', owner: agent, position: [22, 22], stance: 2}
+        - {type: '3tnk', owner: agent, position: [22, 24], stance: 2}
+        # 3-tank strike: spreads fire across the agent column for a
+        # broader engagement footprint than easy.
+        - {type: '4tnk', owner: enemy, position: [24, 18], stance: 3}
+        - {type: '4tnk', owner: enemy, position: [24, 21], stance: 3}
+        - {type: '4tnk', owner: enemy, position: [24, 24], stance: 3}
+        # Garrison: 6 e1 at x=80..82.
+        - {type: e1, owner: enemy, position: [80, 18], stance: 1}
+        - {type: e1, owner: enemy, position: [80, 20], stance: 1}
+        - {type: e1, owner: enemy, position: [80, 22], stance: 1}
+        - {type: e1, owner: enemy, position: [80, 24], stance: 1}
+        - {type: e1, owner: enemy, position: [82, 20], stance: 1}
+        - {type: e1, owner: enemy, position: [82, 22], stance: 1}
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {unit_type_count_gte: {type: '3tnk', n: 4}}
+        - {units_killed_gte: 5}
+        - {has_building: fact}
+        - {within_ticks: 5400}
+    fail_condition:
+      any_of:
+        - {after_ticks: 5401}
+        - {not: {own_units_gte: 1}}
+        - {not: {has_building: fact}}
+    max_turns: 60
+
+  # ── HARD ────────────────────────────────────────────────────────
+  # +2 controlled variables vs medium:
+  #   1. TWO seed-driven AGENT spawn_point groups (NORTH y=14 vs
+  #      SOUTH y=28 e1 scout). The central combat force (4× 3tnk at
+  #      y=18..24) and base buildings are SHARED across the two
+  #      groups so the strike geometry is symmetric, but a memorised
+  #      opening cannot generalise: the scout's location flips per
+  #      seed and reveals it. (CLAUDE.md: enemy actors are NOT
+  #      spawn-filtered, so the 3 strikers + garrison + far fact
+  #      always place; only AGENT actors honour `spawn_point`, and
+  #      ANY agent actor with a spawn_point causes every agent
+  #      actor WITHOUT one to be filtered out — so base buildings
+  #      are duplicated across BOTH spawn groups at identical cells.)
+  #   2. Larger replacement budget (3450 cr ⇒ 3× 3tnk rebuilds) to
+  #      absorb the staggered strike (3 strikers spread fire across
+  #      the column for a broader engagement — empirically still
+  #      lands ~1 tank kill on intended-attack-move, but the budget
+  #      lets the agent rebuild aggressively if more are lost).
+  hard:
+    description: >
+      Hard tier: TWO seed-driven base orientations (a NORTH-flank
+      scout at (16,14) on spawn 0; a SOUTH-flank scout at (16,28) on
+      spawn 1) keep the strike geometry symmetric but defeat a
+      memorised opening. Three enemy heavy tanks (4tnk) strike the
+      central column; the eastern garrison is 6 rifle infantry at
+      x=80. Reserve cash (3450 cr) covers up to THREE replacement
+      heavy tanks. Win when you have killed ≥5 enemy units AND you
+      have ≥4 heavy tanks alive AND your construction yard is intact,
+      before tick 5400. Stalling and assault-without-rebuild both
+      LOSE; the intended play is to rebuild every fallen tank AND
+      attack_move east in parallel.
+    starting_cash: 3450
+    overrides:
+      actors:
+        # SPAWN 0 — NORTH-flank scout at (16,14).
+        # Base buildings + central combat force duplicated across
+        # both spawn groups (per CLAUDE.md: ANY agent actor with a
+        # spawn_point causes agent actors WITHOUT spawn_point to be
+        # filtered out — so EVERY agent actor must declare
+        # spawn_point).
+        - {type: fact, owner: agent, position: [8, 18], spawn_point: 0}
+        - {type: powr, owner: agent, position: [10, 18], spawn_point: 0}
+        - {type: weap, owner: agent, position: [12, 18], spawn_point: 0}
+        - {type: fix,  owner: agent, position: [14, 18], spawn_point: 0}
+        - {type: '3tnk', owner: agent, position: [22, 18], stance: 2, spawn_point: 0}
+        - {type: '3tnk', owner: agent, position: [22, 20], stance: 2, spawn_point: 0}
+        - {type: '3tnk', owner: agent, position: [22, 22], stance: 2, spawn_point: 0}
+        - {type: '3tnk', owner: agent, position: [22, 24], stance: 2, spawn_point: 0}
+        - {type: e1, owner: agent, position: [16, 14], stance: 0, spawn_point: 0}
+        # SPAWN 1 — SOUTH-flank scout at (16,28).
+        - {type: fact, owner: agent, position: [8, 18], spawn_point: 1}
+        - {type: powr, owner: agent, position: [10, 18], spawn_point: 1}
+        - {type: weap, owner: agent, position: [12, 18], spawn_point: 1}
+        - {type: fix,  owner: agent, position: [14, 18], spawn_point: 1}
+        - {type: '3tnk', owner: agent, position: [22, 18], stance: 2, spawn_point: 1}
+        - {type: '3tnk', owner: agent, position: [22, 20], stance: 2, spawn_point: 1}
+        - {type: '3tnk', owner: agent, position: [22, 22], stance: 2, spawn_point: 1}
+        - {type: '3tnk', owner: agent, position: [22, 24], stance: 2, spawn_point: 1}
+        - {type: e1, owner: agent, position: [16, 28], stance: 0, spawn_point: 1}
+        # 3-tank strike (enemy actors place on every seed).
+        - {type: '4tnk', owner: enemy, position: [24, 18], stance: 3}
+        - {type: '4tnk', owner: enemy, position: [24, 21], stance: 3}
+        - {type: '4tnk', owner: enemy, position: [24, 24], stance: 3}
+        - {type: e1, owner: enemy, position: [80, 18], stance: 1}
+        - {type: e1, owner: enemy, position: [80, 20], stance: 1}
+        - {type: e1, owner: enemy, position: [80, 22], stance: 1}
+        - {type: e1, owner: enemy, position: [80, 24], stance: 1}
+        - {type: e1, owner: enemy, position: [82, 20], stance: 1}
+        - {type: e1, owner: enemy, position: [82, 22], stance: 1}
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - {unit_type_count_gte: {type: '3tnk', n: 4}}
+        - {units_killed_gte: 5}
+        - {has_building: fact}
+        - {within_ticks: 5400}
+    fail_condition:
+      any_of:
+        - {after_ticks: 5401}
+        - {not: {own_units_gte: 1}}
+        - {not: {has_building: fact}}
+    max_turns: 60

tests/test_hard_tier.py

@@ -522,6 +522,23 @@ UPGRADED = [
     # the surprise wave arrives FROM flips per seed and a memorised
     # "expect Wave 2 from NE" disposition cannot generalise.
     "rob-unexpected-enemy-spawn",
+    # Wave-6 ROBUSTNESS / reasoning seed — PlanBench replanning under
+    # exogenous loss / SC2 rebuild-after-trade / military force-regen /
+    # ScienceWorld error recovery anchor. Agent commands 4 heavy tanks
+    # (3tnk) + a production base (fact + powr + weap + fix); a pre-
+    # placed enemy 4tnk strike force at the lane mouth lands its
+    # opening salvo on tick 0 (stance:3) and kills 1+ agent tanks;
+    # the agent must commission replacements from the war factory with
+    # the reserve cash AND continue the eastward assault to clear the
+    # e1 garrison. Hard tier defines two agent spawn_point groups
+    # (NORTH-flank scout (16,14) vs SOUTH-flank scout (16,28)) round-
+    # robined by seed; the central combat force + base buildings are
+    # SHARED across both groups (per CLAUDE.md, base buildings are
+    # duplicated under both spawn_points because ANY agent actor with
+    # a spawn_point causes agent actors WITHOUT a spawn_point to be
+    # filtered out), so the strike geometry is symmetric but a
+    # memorised opening cannot generalise.
+    "rob-unit-loss-recovery",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation

tests/test_rob_unit_loss_recovery.py

@@ -0,0 +1,310 @@
+"""rob-unit-loss-recovery — REASONING capability validation.
+
+Real-world anchor: PlanBench replanning under exogenous loss (gold
+standard); SC2 rebuild-after-trade; military force-regen / unit
+replacement; ScienceWorld error recovery. The agent starts with 4
+combat heavy tanks (3tnk) + a production base (fact + powr + weap +
+fix) and a discrete reserve cash budget; an enemy 4tnk strike force
+staged at the lane mouth (stance:3 AttackAnything) lands its opening
+salvo on tick 0 and kills 1-4 agent tanks. The agent must
+   1. notice the establishment is below 4 (units_summary count drops),
+   2. build('3tnk') to commission replacements from the war factory
+      with the indivisible reserve cash, AND
+   3. continue the eastward offensive to clear the e1 garrison
+      defending the enemy fact at x=120,
+so the kill bar (5 enemy units) + the establishment bar (≥4 3tnks) +
+the construction-yard intact bar all pass before the tick deadline.
+
+Bar (CLAUDE.md "no defect, no cheat"):
+   - stall LOSES every tier / every hard seed (no attack, no kills →
+     kill bar unmet → after_ticks 5401 fires → timeout LOSS).
+   - no_rebuild LOSES every tier (the strike kills ≥1 agent 3tnk; the
+     surviving 3 tanks clear the kill bar but the type-count clause
+     `unit_type_count_gte: {type: 3tnk, n: 4}` is busted because the
+     dead tank was never replaced → LOSS even though kills ≥ 5).
+   - intended-rebuild-and-attack WINS every tier / seed.
+   - hard tier defines ≥2 agent spawn_point groups (NORTH-flank scout
+     vs SOUTH-flank scout) so a memorised 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 / "rob-unit-loss-recovery.yaml"
+
+
+# ── policies ────────────────────────────────────────────────────────
+
+
+def _stall(rs, Command):
+    """Pure observe — no orders → no kills → kill bar unmet →
+    after_ticks 5401 fires → timeout LOSS."""
+    return [Command.observe()]
+
+
+def _no_rebuild(rs, Command):
+    """Attack-move east WITHOUT ever issuing build. The strike kills
+    ≥1 3tnk on the way past (the agent now has <4 of the combat type);
+    the surviving force reaches the garrison and clears the kill bar
+    BUT the `unit_type_count_gte: {type: 3tnk, n: 4}` clause is busted
+    → LOSS even though kills ≥ 5."""
+    units = rs.get("units_summary", []) or []
+    tanks = [u for u in units if u.get("type") == "3tnk"]
+    if not tanks:
+        return [Command.observe()]
+    ids = [str(u["id"]) for u in tanks]
+    return [Command.attack_move(ids, 80, 20)]
+
+
+def _intended(rs, Command):
+    """React to the loss: if 3tnk count drops below 4, commission a
+    replacement via build('3tnk'); always attack_move the live 3tnk
+    force toward the eastern garrison at (80,20). The replacement
+    budget covers the per-tier expected losses; the fresh-built tank
+    rejoins the column before the deadline; the type-count + kill-bar
+    + construction-yard bars all pass → WIN."""
+    units = rs.get("units_summary", []) or []
+    tanks = [u for u in units if u.get("type") == "3tnk"]
+    cmds = []
+    if len(tanks) < 4:
+        cmds.append(Command.build("3tnk"))
+    ids = [str(u["id"]) for u in tanks]
+    if ids:
+        cmds.append(Command.attack_move(ids, 80, 20))
+    return cmds or [Command.observe()]
+
+
+# ── helpers ─────────────────────────────────────────────────────────
+
+
+def _run(level, policy, seed=1):
+    c = compile_level(load_pack(PACK), level)
+    assert c.map_supported, "rush-hour-arena terrain must be present"
+    return c, run_level(c, policy, seed=seed)
+
+
+# ── structural ──────────────────────────────────────────────────────
+
+
+def test_pack_loads_and_meta_active():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "rob-unit-loss-recovery"
+    assert pack.meta.capability == "reasoning"
+    assert pack.meta.real_world_meaning
+    assert pack.meta.robotics_analogue
+    anchors = pack.meta.benchmark_anchor
+    joined = " ".join(anchors).lower()
+    assert "planbench" in joined
+    assert "scienceworld" in joined
+    assert "sc2" in joined
+    assert "force-regen" in joined or "force regen" in joined or "rebuild" in joined
+
+
+def test_uses_turtle_bot():
+    """The pack must declare the Wave-2 `turtle` bot — the holding-
+    in-place idiom is what isolates the loss event to the pre-placed
+    strikers and keeps the kill bar reachable from a single eastbound
+    assault (a surging garrison would either overrun the base or be
+    killed without the agent moving, breaking both bars)."""
+    pack = load_pack(PACK)
+    enemy = pack.base.get("enemy") if isinstance(pack.base, dict) else None
+    assert enemy is not None
+    bot = enemy.get("bot_type") or enemy.get("bot")
+    assert bot == "turtle", f"expected turtle bot, got {bot!r}"
+
+
+def test_all_tiers_have_reachable_deadlines():
+    """tick-alignment idiom: within_ticks ≤ ceiling AND
+    after_ticks ≤ ceiling AND within_ticks + 1 == after_ticks (so a
+    non-finisher LOSES, not draws)."""
+    pack = load_pack(PACK)
+    for lvl in ("easy", "medium", "hard"):
+        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 "
+            "(non-finisher must LOSE, not draw — fail clause one tick"
+            " past win clause)"
+        )
+
+
+def test_hard_has_two_seed_driven_spawn_groups():
+    """Hard tier: ≥2 distinct agent spawn_point groups so engine
+    round-robins start by seed. The central combat force + base
+    buildings are SHARED across both groups so the strike geometry is
+    symmetric, but the spawn-distinguishing scout (NORTH (16,14) vs
+    SOUTH (16,28)) reveals which seed the engine picked — a memorised
+    opening cannot generalise."""
+    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 len(sp) >= 2, (
+        f"hard must define ≥2 agent spawn_point groups; got {sorted(sp)}"
+    )
+
+
+def test_fail_condition_present_on_every_tier():
+    pack = load_pack(PACK)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        assert c.fail_condition is not None, f"{lvl} needs a fail_condition"
+
+
+def test_tools_match_spec():
+    """The advertised toolset is exactly the rebuild-and-assault kit:
+    observe + build + place_building + move_units + attack_unit +
+    attack_move + stop. No `harvest` (this is a no-economy scenario —
+    the rebuild budget is the starting_cash reserve)."""
+    pack = load_pack(PACK)
+    tools = set(pack.base.get("tools", []))
+    expected = {
+        "observe", "build", "place_building", "move_units",
+        "attack_unit", "attack_move", "stop",
+    }
+    assert tools == expected, f"tools mismatch: got {sorted(tools)}"
+
+
+# ── predicate-level (no engine) ─────────────────────────────────────
+
+
+def _ctx(*, units=(), tick=1000, kills=0, lost=0, own_buildings=()):
+    import types
+
+    sig = types.SimpleNamespace(
+        game_tick=tick,
+        units_killed=kills,
+        units_lost=lost,
+        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": list(units)},
+    )
+
+
+def test_predicates_enforce_capability():
+    """Win requires (≥4 3tnks AND ≥5 kills AND fact alive) AND in-time;
+    fail fires on timeout OR all-units-dead OR fact destroyed."""
+    c = compile_level(load_pack(PACK), "medium")
+    four_tanks = [{"cell_x": 22, "cell_y": 18 + 2 * i, "type": "3tnk"} for i in range(4)]
+    fact = [("fact", 8, 18)]
+
+    # Intended: 4 3tnks, 5 kills, fact alive, in time → WIN
+    assert evaluate(
+        c.win_condition,
+        _ctx(units=four_tanks, tick=2000, kills=5, own_buildings=fact),
+    )
+    # Only 3 3tnks (didn't rebuild after a loss) → not a win
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=four_tanks[:3], tick=2000, kills=5, own_buildings=fact),
+    )
+    # Only 4 kills (didn't clear the garrison) → not a win
+    assert not evaluate(
+        c.win_condition,
+        _ctx(units=four_tanks, tick=2000, kills=4, own_buildings=fact),
+    )
+    # All units dead → real fail (capability collapses)
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=[], tick=2000, kills=5, own_buildings=fact),
+    )
+    # Timeout (tick past after_ticks): bar unmet → fail
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=four_tanks, tick=5402, kills=0, own_buildings=fact),
+    )
+    # Construction yard destroyed → fail
+    assert evaluate(
+        c.fail_condition,
+        _ctx(units=four_tanks, tick=2000, kills=5, own_buildings=[]),
+    )
+
+
+# ── engine-driven policies (the no-cheat bar) ───────────────────────
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_stall_loses_every_tier_and_seed(level, seed):
+    """No orders → no kills → kill bar unmet → timeout LOSS via
+    after_ticks. The strike force kills 1-4 agent tanks during the
+    grind, but the agent neither rebuilds nor advances on the
+    garrison."""
+    _, r = _run(level, _stall, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level}/seed{seed}: stall must LOSE (no kills, no rebuild); "
+        f"got {r.outcome} kills={r.signals.units_killed} "
+        f"losses={r.signals.units_lost} turns={r.turns}"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_no_rebuild_loses(level, seed):
+    """Assault-without-rebuild: the strike kills ≥1 3tnk; the surviving
+    force clears the garrison so kills ≥ 5, but the type-count clause
+    busts because the dead tank was never replaced → LOSS even with a
+    cleared kill bar. This is the canonical 'forgot to replace the
+    casualty' failure mode the scenario is designed to catch."""
+    _, r = _run(level, _no_rebuild, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level}/seed{seed}: no-rebuild must LOSE (type-count busted "
+        f"by unreplaced casualty); got {r.outcome} "
+        f"kills={r.signals.units_killed} losses={r.signals.units_lost}"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_intended_rebuild_and_attack_wins(level, seed):
+    """The intended capability — build replacements whenever the
+    establishment drops below 4 AND attack_move the live force east —
+    WINS every tier and every hard seed well inside the tick budget."""
+    _, r = _run(level, _intended, seed=seed)
+    assert r.outcome == "win", (
+        f"{level}/seed{seed}: intended rebuild-and-attack should WIN; "
+        f"got {r.outcome} kills={r.signals.units_killed} "
+        f"losses={r.signals.units_lost} turns={r.turns}"
+    )
+
+
+def test_outcomes_are_deterministic_per_seed():
+    """Same seed, same policy → identical outcome."""
+    c = compile_level(load_pack(PACK), "medium")
+    a = run_level(c, _intended, seed=2)
+    b = run_level(c, _intended, seed=2)
+    assert (a.outcome, a.turns, a.signals.units_killed, a.signals.units_lost) == (
+        b.outcome, b.turns, b.signals.units_killed, b.signals.units_lost
+    )