feat(scenarios): merge PR #8 from yiyu-tian — 4 new packs (rebased onto Wave 1+2)

Cherry-picks the 4 scenario packs from PR #8 onto current main (the PR
was based on commit 1400f05 pre-Wave 1; merging as-is would have
deleted the 17 Wave 1+2 packs and 4 engine PRs).

New packs (each adds a transfer-anchored bench cell):

- perception-count-the-threat-small-k (renamed from -the-threat to
avoid collision with Wave 1 A7). Different stress axis from A7:
K=2/3/4 with psychologically non-obvious hidden positions vs A7's
K=4..7 seeded with 2 spawn groups. Both ship; complementary.
Anchor: ERQA / POMDP / ScienceWorld / ICU triage.
- coordination-ordered-rendezvous. Complements A5 staggered-window:
this one tests visit ORDER via waypoint_sequence (n=2) across 2/3/4
waypoints. Anchor: Watch-And-Help / SMAC / PERT / supply-chain
ordered handoff.
- tempo-strike-window. Complements A6 double-window: this one is the
single-band canonical cat-c11 tempo design (forced lull then kill
quota in follow-up window). Anchor: TextStarCraft II / OSWorld /
PlanBench temporal goals.
- risk-blockade-bypass. New cell (no overlap with reasoning-risk-
route): heavy corridor vs light detour with attrition cap making
brute-force infeasible. Anchor: MicroRTS route-risk / PlanBench
cost-vs-survival / field-robotics convoy routing.

Per-pack additions vs PR #8 source:
- meta.benchmark_anchor: list[str] populated (the new schema
requirement we added in Wave 2 foundation, commit 17f024b — post
the PR's base).
- All 4 packs added to tests/test_hard_tier.py::NOT_APPLICABLE with
documented reasons (none use spawn_point variation on hard; each
tightens one decision axis per tier instead).
- perception-count-the-threat-small-k renamed (lowercase 'k' to
satisfy the slug validator; meta.id, test file, and references
all updated).
- author: yiyu-tian on each (credit preserved).

NOT cherry-picked from PR #8:
- The "importorskip on 18 pre-existing test files" infrastructure
commit (cbf068c) — touches files unrelated to the scenarios; the
local suite passes without it (719 pre-PR, 759 post-merge).

Test suite: 719 → 759 passing (+40 — 4 new packs × ~10 tests each).

Closes #8.

openra_bench/scenarios/packs/coordination-ordered-rendezvous.yaml

@@ -0,0 +1,152 @@
+# Validate: python -m openra_bench.scenarios.validate \
+#   openra_bench/scenarios/packs/coordination-staggered-window.yaml
+# See ../CONTRIBUTING.md for the full win-condition grammar.
+#
+# ACTION focus, ORDERED parallel rendezvous. Two/three squads must
+# deliver >=2 units to a sequence of regions IN ORDER (W1 before W2
+# before W3), within a tight overall deadline. Order is enforced by
+# `waypoint_sequence` (stateful latch: W2 only counts after W1 was
+# satisfied at some prior tick). The deadline is tight enough that
+# a single column cannot tour all waypoints in time — parallel
+# columns are required AND the deposit at W1 must come first.
+#
+# Differs from action-multiunit-coordination (simultaneous delivery
+# to N regions at one deadline) on the ORDER axis: this scenario
+# fails if W2 is reached before W1, even if both end up satisfied.
+# Same axis across easy/medium/hard — only the number of waypoints
+# and the deadline tighten.
+
+meta:
+  id: coordination-ordered-rendezvous
+  title: 'Ordered Rendezvous — Deliver Squads to Waypoints In Sequence'
+  capability: action
+  real_world_meaning: >
+    Parallel multi-team delivery under an ordering constraint:
+    waypoint A must be reached before waypoint B before waypoint C,
+    each requiring two or more units present, all within one tight
+    overall window. Skipping or out-of-order delivery does not
+    count. Single-column tours blow the deadline; only concurrent
+    dispatch with leg-by-leg ordering succeeds.
+  robotics_analogue: >
+    Sequenced multi-depot fleet dispatch with a precedence
+    constraint: team A must arrive at depot 1 before team B may be
+    credited for arriving at depot 2 (e.g. handoff / supply chain),
+    and the overall window does not permit a single team to do all
+    legs in series.
+  benchmark_anchor:
+    - "Watch-And-Help concurrent multi-agent with sequenced sub-tasks"
+    - "SMAC asymmetric squad sequencing"
+    - "PERT/CPM precedence-constrained dispatch"
+    - "supply-chain ordered handoff: depot A before depot B"
+  author: yiyu-tian
+
+base_map: rush-hour-arena
+
+base:
+  agent: {faction: allies}
+  enemy: {faction: soviet}
+  tools: [move_units, attack_unit, stop_units]
+  planning: true
+  termination: {max_ticks: 6000}
+  actors:
+    - {type: 2tnk, owner: agent, position: [5, 8],  count: 3}
+    - {type: 1tnk, owner: agent, position: [7, 32], count: 3}
+
+levels:
+  easy:
+    description: >
+      Two waypoints in sequence: W1 NE (110, 8) before W2 SE
+      (110, 32), each requiring >=2 units, all within 2200 ticks.
+      A single column tour from spawn through both legs exceeds
+      2200 ticks; parallel columns with W1 finishing first
+      (squad A delivers, squad B holds short of W2 until W1 latches)
+      makes it. Out-of-order (B arrives at W2 first) never satisfies
+      waypoint_sequence's W1→W2 latch.
+    overrides:
+      actors:
+        - {type: 2tnk, owner: agent, position: [5, 8],  count: 3}
+        - {type: 1tnk, owner: agent, position: [7, 32], count: 3}
+    win_condition:
+      all_of:
+        - waypoint_sequence:
+            id: coord-easy
+            n: 2
+            radius: 7
+            points:
+              - {x: 110, y: 8,  label: "W1 north-east rendezvous"}
+              - {x: 110, y: 32, label: "W2 south-east rendezvous"}
+        - within_ticks: 2200
+    fail_condition:
+      any_of:
+        - after_ticks: 2201
+        - not: {own_units_gte: 1}
+    max_turns: 40
+
+  medium:
+    description: >
+      Three waypoints in sequence: W1 NE, W2 bottom-left
+      (south-west detour), W3 SE — each n>=2, all within 3000
+      ticks. The detour leg through the south-west adds tour cost a
+      single column cannot absorb. Enemy pickets contest the two
+      eastern lanes. Loss cap 2.
+    overrides:
+      actors:
+        - {type: 2tnk, owner: agent, position: [5, 6],  count: 3}
+        - {type: 1tnk, owner: agent, position: [7, 10], count: 3}
+        - {type: jeep, owner: agent, position: [5, 14], count: 2}
+        - {type: e1, owner: enemy, position: [55, 8],  stance: 2, count: 2}
+        - {type: e1, owner: enemy, position: [55, 32], stance: 2, count: 2}
+    win_condition:
+      all_of:
+        - waypoint_sequence:
+            id: coord-medium
+            n: 2
+            radius: 7
+            points:
+              - {x: 115, y: 6,  label: "W1 north-east"}
+              - {x: 20,  y: 36, label: "W2 south-west detour"}
+              - {x: 115, y: 34, label: "W3 south-east"}
+        - within_ticks: 3000
+        - units_lost_lte: 2
+    fail_condition:
+      any_of:
+        - after_ticks: 3001
+        - not: {own_units_gte: 1}
+        - not: {units_lost_lte: 2}
+    max_turns: 48
+
+  hard:
+    description: >
+      Four waypoints in sequence with a strict ordering, 3200-tick
+      deadline, loss cap 1. Even with three squads, no single
+      column can absorb a full tour; the ordering forces W1 to
+      finish before W2 can be credited, etc., so squads must
+      stagger their arrivals naturally. Failure isolates *ordered*
+      parallel coordination — both simultaneous-only and serial
+      strategies miss.
+    overrides:
+      actors:
+        - {type: 2tnk, owner: agent, position: [5, 6],  count: 3}
+        - {type: 1tnk, owner: agent, position: [7, 10], count: 3}
+        - {type: jeep, owner: agent, position: [5, 14], count: 3}
+        - {type: e1, owner: enemy, position: [55, 8],  stance: 2, count: 2}
+        - {type: e3, owner: enemy, position: [55, 32], stance: 2, count: 2}
+    win_condition:
+      all_of:
+        - waypoint_sequence:
+            id: coord-hard
+            n: 2
+            radius: 6
+            points:
+              - {x: 115, y: 6,  label: "W1 north-east"}
+              - {x: 20,  y: 36, label: "W2 south-west"}
+              - {x: 115, y: 34, label: "W3 south-east"}
+              - {x: 60,  y: 20, label: "W4 mid-east handoff"}
+        - within_ticks: 3200
+        - units_lost_lte: 1
+    fail_condition:
+      any_of:
+        - after_ticks: 3201
+        - not: {own_units_gte: 1}
+        - not: {units_lost_lte: 1}
+    max_turns: 52

openra_bench/scenarios/packs/perception-count-the-threat-small-k.yaml

@@ -0,0 +1,137 @@
+# Validate: python -m openra_bench.scenarios.validate \
+#   openra_bench/scenarios/packs/perception-count-the-threat.yaml
+# See ../CONTRIBUTING.md for the full win-condition grammar.
+#
+# PERCEPTION focus, EXACT-COUNT variant: the win is set to the actual
+# hidden enemy count K. The model must scout enough to see all K — no
+# more, no less — within a tight clock. Under-scouting fails the
+# enemies_discovered_gte bar; over-scouting (sweeping the whole map)
+# blows the clock or the units_lost_lte cap because reaching the
+# trailing decoys costs ticks/casualties. The model has to REASON
+# about WHERE the K-th enemy could be hiding from the partial scout
+# so far, not just expand fog area-greedily.
+
+meta:
+  id: perception-count-the-threat-small-k
+  title: 'Count the Threat (small-K) — Discover Exactly K Hidden Enemy Squads'
+  capability: perception
+  real_world_meaning: >
+    State-estimation under partial observability with a precise count
+    target: identify the exact number of hidden entities by inferring
+    where the remaining ones must be, given what has already been
+    cleared, before the clock runs out and without burning the force
+    on irrelevant ground.
+  robotics_analogue: >
+    Sensor-budgeted search for a known target count: locate all K
+    survivors / contraband / contacts in a bounded area, where missing
+    one fails the mission and over-searching exhausts the energy
+    budget on already-cleared zones.
+  benchmark_anchor:
+    - "ERQA state-estimation under partial observability"
+    - "POMDP exact-count sub-tasks"
+    - "ScienceWorld inventory before-commit"
+    - "ICU triage exact census"
+  author: yiyu-tian
+  # Companion to `perception-count-the-threat` (Wave 1 A7): both test
+  # the same cell (exact-K perception) but along different stress axes.
+  # A7 uses K=5 fixed medium / K seed-varied 4..7 hard with 2 spawn
+  # groups (count discrimination + spawn robustness). This pack uses
+  # K=2/3/4 with psychologically non-obvious hidden positions (the
+  # "where could the K-th be hiding?" inference axis).
+
+base_map: rush-hour-arena
+
+base:
+  agent: {faction: allies}
+  enemy: {faction: soviet}
+  tools: [move_units, attack_unit, stop_units]
+  planning: true
+  termination: {max_ticks: 12000}
+  actors:
+    - {type: jeep, owner: agent, position: [6, 5], count: 3}
+    - {type: 1tnk, owner: agent, position: [8, 8], count: 2}
+
+levels:
+  # Tick budgets aligned to 93 + 90·(max_turns - 1) so the timeout
+  # fail actually fires within the run loop (eval_core.run_level
+  # iterates max_turns, not termination.max_ticks — without this
+  # alignment the after_ticks clause is unreachable and unmet wins
+  # exit as draw, not loss; see CLAUDE.md).
+  easy:
+    description: >
+      Exactly 2 enemy squads hidden in fog (one near-east, one
+      far-east). Find both within 2200 ticks losing <=1 unit. Both
+      are roughly on the same lane — a straight east sweep finds
+      them. Missing one or losing too many = loss.
+    overrides:
+      actors:
+        - {type: jeep, owner: agent, position: [6, 5], count: 3}
+        - {type: 1tnk, owner: agent, position: [8, 8], count: 2}
+        # Two distinct enemy squads, deliberately count K=2.
+        - {type: e1, owner: enemy, position: [55, 15], stance: 2, count: 2}
+        - {type: e3, owner: enemy, position: [105, 18], stance: 2, count: 2}
+    win_condition:
+      all_of:
+        - enemies_discovered_gte: 2
+        - within_ticks: 2200
+        - units_lost_lte: 1
+    fail_condition:
+      any_of:
+        - after_ticks: 2201
+        - not: {own_units_gte: 1}
+        - not: {units_lost_lte: 1}
+    max_turns: 26   # ceiling 93 + 90·25 = 2343 > 2201 ✓
+
+  medium:
+    description: >
+      Exactly 3 enemy squads scattered in three different directions
+      (north-east, south-east, and a non-obvious mid-north pocket).
+      Find all 3 within 2800 ticks losing <=2. A naive east-only
+      sweep finds 2 of 3 and runs out the clock searching the wrong
+      half of the map; the model must read where the remaining
+      unexplored mass is after each contact and commit there.
+    overrides:
+      actors:
+        - {type: jeep, owner: agent, position: [6, 5], count: 3}
+        - {type: 1tnk, owner: agent, position: [8, 8], count: 2}
+        - {type: e1, owner: enemy, position: [105, 8], stance: 2, count: 2}    # NE
+        - {type: e3, owner: enemy, position: [105, 32], stance: 2, count: 2}   # SE
+        - {type: dog, owner: enemy, position: [55, 4], stance: 2, count: 2}    # mid-N
+    win_condition:
+      all_of:
+        - enemies_discovered_gte: 3
+        - within_ticks: 2800
+        - units_lost_lte: 2
+    fail_condition:
+      any_of:
+        - after_ticks: 2801
+        - not: {own_units_gte: 1}
+    max_turns: 32   # ceiling 2883 > 2801 ✓
+
+  hard:
+    description: >
+      Exactly 4 enemy squads. Two are "obvious" (along the natural
+      east-bound axes the spawn pushes toward), one is in the far-NW
+      strip behind the spawn, and one is in a tight south-of-mid
+      pocket. Loss cap is 2, clock is 3500. A best-effort sweep
+      finds 2–3; only inferring from which fog masses remain after
+      each contact identifies all 4 in time. Over-scouting (visiting
+      every remaining fog cell) blows the clock.
+    overrides:
+      actors:
+        - {type: jeep, owner: agent, position: [6, 5], count: 3}
+        - {type: 1tnk, owner: agent, position: [8, 8], count: 2}
+        - {type: e1, owner: enemy, position: [105, 8], stance: 2, count: 2}
+        - {type: e3, owner: enemy, position: [105, 32], stance: 2, count: 2}
+        - {type: dog, owner: enemy, position: [115, 4], stance: 2, count: 2}    # far-NW relative to push
+        - {type: e2, owner: enemy, position: [60, 28], stance: 2, count: 2}     # south-of-mid pocket
+    win_condition:
+      all_of:
+        - enemies_discovered_gte: 4
+        - within_ticks: 3500
+        - units_lost_lte: 2
+    fail_condition:
+      any_of:
+        - after_ticks: 3501
+        - not: {own_units_gte: 1}
+    max_turns: 40   # ceiling 3603 > 3501 ✓

openra_bench/scenarios/packs/risk-blockade-bypass.yaml

@@ -0,0 +1,151 @@
+# Validate: python -m openra_bench.scenarios.validate \
+#   openra_bench/scenarios/packs/risk-blockade-bypass.yaml
+# See ../CONTRIBUTING.md for the full win-condition grammar.
+#
+# REASONING / RISK focus. The objective region is reachable via two
+# axes: (a) the SHORT central corridor, blocked by a heavy enemy
+# garrison that out-trades the agent's force; (b) a LONGER but
+# lightly-defended detour. With a units_lost_lte cap and a clock
+# that is tight but not too tight, the dominant strategy is the
+# detour. Brute-forcing the corridor reduces the force below the
+# attrition cap before reaching the objective.
+#
+# Difficulty escalates the cost of the wrong call: easy allows a
+# slim head-on (loss <=4); medium tightens the cap; hard introduces
+# a smaller forward force AND a tempo gate (the objective only
+# scores after tick t0, so committing too early through the corridor
+# and arriving wounded fails the after_ticks-then-attrition combo).
+
+meta:
+  id: risk-blockade-bypass
+  title: 'Blockade Bypass — Reach the Objective by the Survivable Detour'
+  capability: reasoning
+  real_world_meaning: >
+    Route-risk assessment with a visibly hard direct path and a
+    longer survivable alternative under a binding attrition cap.
+    The cap punishes brute force; the clock punishes infinite
+    detour. The decision is committing the force to the route that
+    actually makes the deadline alive.
+  robotics_analogue: >
+    Field-robot mission routing rejecting a hazardous shortest path
+    for a survivable longer one within a time window — but the
+    longer path is not free, so the model must weigh attrition vs
+    deadline rather than always preferring the safe option.
+  benchmark_anchor:
+    - "MicroRTS route-risk / hazardous-corridor sub-tasks"
+    - "PlanBench cost-vs-survival route planning"
+    - "field-robotics: contested vs detour route under SLA"
+    - "convoy routing with attrition budget"
+  author: yiyu-tian
+  # Distinct from `reasoning-risk-route` (single-path hazard vs
+  # detour). This pack adds the explicit corridor-vs-detour
+  # bifurcation with an attrition cap binding tight enough that
+  # head-on brute-force fails the cap before reaching the goal.
+
+base_map: rush-hour-arena
+
+base:
+  agent:
+    faction: allies
+    cash: 0
+  enemy:
+    faction: soviet
+    cash: 0
+    bot_type: ''
+  interrupts:
+    enemy_unit_spotted: true
+  tools: [move_units, attack_unit, stop_units]
+  planning: true
+  termination: {max_ticks: 14000}
+  actors:
+    # Agent force, mid-west.
+    - {type: 2tnk, owner: agent, position: [8, 20],  stance: 3, count: 3}
+    - {type: 1tnk, owner: agent, position: [8, 22],  stance: 3, count: 3}
+    - {type: jeep, owner: agent, position: [6, 18],  stance: 3, count: 2}
+    # Heavy CORRIDOR garrison (the wrong way): trades well, expensive
+    # to clear. Combination of e3 (rockets) + defensive gun.
+    - {type: e3,  owner: enemy, position: [55, 20], stance: 2, count: 4}
+    - {type: gun, owner: enemy, position: [57, 22], stance: 3, count: 1}
+    - {type: e1,  owner: enemy, position: [55, 22], stance: 2, count: 3}
+    # Light DETOUR garrison (the right way, top-N): one infantry
+    # picket; clears at low cost.
+    - {type: e1,  owner: enemy, position: [55, 5],  stance: 2, count: 2}
+    # Objective region marker: a static enemy building in the east.
+    - {type: fact, owner: enemy, position: [110, 20]}
+
+# Tick budgets aligned to 93 + 90·(max_turns - 1) so the timeout fail
+# fires within the run loop (eval_core.run_level iterates max_turns,
+# not termination.max_ticks). The capability axis is route-risk under
+# attrition cap; difficulty ladders on (clock, cap, force size) only —
+# no orthogonal mechanic (e.g. tempo gate) introduced on hard, per
+# CLAUDE.md "one new controlled variable per tier".
+levels:
+  easy:
+    description: >
+      Reach the objective region near (110, 20) within 3500 ticks
+      losing <=4 units. The central corridor garrison (heavy at
+      (55, 20–22)) out-trades you 1-for-1; pushing through is
+      possible but spends the whole loss budget and may run the
+      clock. The northern detour (light picket at (55, 5)) costs
+      ~600 extra ticks but only ~1 unit. Decision is route choice.
+    overrides: {}
+    win_condition:
+      all_of:
+        - reach_region: {x: 110, y: 20, radius: 6}
+        - within_ticks: 3500
+        - units_lost_lte: 4
+    fail_condition:
+      any_of:
+        - after_ticks: 3501
+        - not: {own_units_gte: 1}
+        - not: {units_lost_lte: 4}
+    max_turns: 40   # ceiling 93 + 90·39 = 3603 > 3501 ✓
+
+  medium:
+    description: >
+      Same map, tighter cap (<=2 lost), 2800-tick deadline. The
+      corridor route is now infeasible — losses against the heavy
+      garrison exceed the cap deterministically. The detour is the
+      only path with positive margin, but it must be committed
+      promptly; dithering near the corridor before bouncing burns
+      ticks.
+    overrides: {}
+    win_condition:
+      all_of:
+        - reach_region: {x: 110, y: 20, radius: 6}
+        - within_ticks: 2800
+        - units_lost_lte: 2
+    fail_condition:
+      any_of:
+        - after_ticks: 2801
+        - not: {own_units_gte: 1}
+        - not: {units_lost_lte: 2}
+    max_turns: 32   # ceiling 2883 > 2801 ✓
+
+  hard:
+    description: >
+      Smaller agent force, attrition cap <=1, deadline 2400 ticks.
+      Pushing the corridor with the reduced force fails the cap
+      deterministically; the detour is the only path with positive
+      margin and it must be executed cleanly inside the budget.
+    overrides:
+      actors:
+        - {type: 2tnk, owner: agent, position: [8, 20],  stance: 3, count: 2}
+        - {type: 1tnk, owner: agent, position: [8, 22],  stance: 3, count: 2}
+        - {type: jeep, owner: agent, position: [6, 18],  stance: 3, count: 2}
+        - {type: e3,  owner: enemy, position: [55, 20], stance: 2, count: 4}
+        - {type: gun, owner: enemy, position: [57, 22], stance: 3, count: 1}
+        - {type: e1,  owner: enemy, position: [55, 22], stance: 2, count: 3}
+        - {type: e1,  owner: enemy, position: [55, 5],  stance: 2, count: 2}
+        - {type: fact, owner: enemy, position: [110, 20]}
+    win_condition:
+      all_of:
+        - reach_region: {x: 110, y: 20, radius: 6}
+        - within_ticks: 2400
+        - units_lost_lte: 1
+    fail_condition:
+      any_of:
+        - after_ticks: 2401
+        - not: {own_units_gte: 1}
+        - not: {units_lost_lte: 1}
+    max_turns: 28   # ceiling 2523 > 2401 ✓

openra_bench/scenarios/packs/tempo-strike-window.yaml

@@ -0,0 +1,144 @@
+# Validate: python -m openra_bench.scenarios.validate \
+#   openra_bench/scenarios/packs/tempo-strike-window.yaml
+# See ../CONTRIBUTING.md for the full win-condition grammar.
+#
+# TEMPO focus, FORCED-LULL strike window. The agent must NOT engage
+# before tick t0 (a "lull" / staging window) and then deliver the
+# kill quota within a tight follow-up band before tick t1. Engaging
+# early uses up the units against unfavourable spacing; waiting
+# until t0 then committing is the dominant strategy.
+#
+# This is the cat-c11 canonical tempo design (after_ticks + kill bar
+# + within_ticks), the one the audit said the suite still needs.
+# Same axis across easy/medium/hard — only the lull length and the
+# follow-up window tighten.
+#
+# Honestly NOT a true double-window (P2-3 happened-before predicate
+# would be required to express "kill N1 in band 1 AND kill N2 in
+# band 2 with a forced gap"). What this CAN express with current
+# predicates: a single strike window after a forced wait, with
+# attrition pressure.
+
+meta:
+  id: tempo-strike-window
+  title: 'Strike Window — Wait for the Lull, Then Hit the Quota'
+  capability: reasoning
+  real_world_meaning: >
+    Timing discipline in a single strike window: do not engage
+    before the lull elapses, then deliver a kill quota inside the
+    follow-up band while staying under the attrition cap. Premature
+    engagement squanders the force; late engagement misses the
+    deadline.
+  robotics_analogue: >
+    Pulsed-mission timing: a UAV/team must hold station through a
+    no-action interval (e.g. avoiding detection / waiting for a
+    handoff window) before committing to its sortie, then complete
+    the engagement inside a hard window.
+  benchmark_anchor:
+    - "TextStarCraft II tempo / timed strike"
+    - "OSWorld scheduled-task chains"
+    - "PlanBench temporally-extended goals with hold-then-act"
+    - "pulsed-mission timing (UAV / fire-mission window)"
+  author: yiyu-tian
+  # Companion to `tempo-double-window` (Wave 1 A6). A6 is double-band
+  # (strike → lull-with-tsla → second strike). This pack is single-
+  # band with a forced pre-lull (no kills allowed before the gate)
+  # and a tight follow-up window — the cat-c11 canonical tempo design.
+
+base_map: rush-hour-arena
+
+base:
+  agent:
+    faction: allies
+    cash: 0
+  enemy:
+    faction: soviet
+    cash: 0
+    bot_type: ''
+  interrupts:
+    enemy_unit_spotted: true
+    own_unit_destroyed: true
+  tools: [move_units, attack_unit, stop_units]
+  planning: true
+  termination: {max_ticks: 12000}
+  actors:
+    - {type: 2tnk, owner: agent, position: [6, 18], stance: 3, count: 3}
+    - {type: 1tnk, owner: agent, position: [6, 22], stance: 3, count: 3}
+    - {type: jeep, owner: agent, position: [6, 14], stance: 3, count: 2}
+    # Enemy cluster positioned so the dominant strike is one
+    # coordinated push after the lull.
+    - {type: e1, owner: enemy, position: [40, 20], stance: 3, count: 4}
+    - {type: e3, owner: enemy, position: [42, 20], stance: 3, count: 2}
+
+levels:
+  # Tick budgets aligned to 93 + 90·(max_turns - 1) so the timeout
+  # fail fires within the run loop (eval_core.run_level iterates
+  # max_turns, not termination.max_ticks).
+  easy:
+    description: >
+      Hold station, then strike. Do not have >=2 kills before tick
+      2000 (early-engagement fail). After tick 2000, deliver >=4
+      kills before tick 4200, losing <=3. The lull is long enough
+      that pre-positioning is rewarded; the follow-up band is loose.
+    win_condition:
+      all_of:
+        - after_ticks: 2000
+        - units_killed_gte: 4
+        - within_ticks: 4200
+        - units_lost_lte: 3
+    fail_condition:
+      any_of:
+        - after_ticks: 4201
+        - not: {own_units_gte: 1}
+        - not: {units_lost_lte: 3}
+        # premature engagement: more than 1 kill before tick 2000
+        # is taken as "did not wait for the lull"
+        - all_of:
+            - units_killed_gte: 2
+            - within_ticks: 1999
+    max_turns: 48   # ceiling 93 + 90·47 = 4323 > 4201 ✓
+
+  medium:
+    description: >
+      Tighter pacing: no kills before tick 1800, then >=5 kills
+      before tick 3600, losing <=2. The lull is shorter and the
+      follow-up window narrower — pre-positioning during the lull
+      is required, not optional.
+    win_condition:
+      all_of:
+        - after_ticks: 1800
+        - units_killed_gte: 5
+        - within_ticks: 3600
+        - units_lost_lte: 2
+    fail_condition:
+      any_of:
+        - after_ticks: 3601
+        - not: {own_units_gte: 1}
+        - not: {units_lost_lte: 2}
+        - all_of:
+            - units_killed_gte: 1
+            - within_ticks: 1799
+    max_turns: 52
+
+  hard:
+    description: >
+      Aggressive lull-then-burst: no engagement at all before tick
+      1500 (any kill = premature-fail), then >=6 kills before tick
+      3000, losing <=1. The post-lull band is only 1500 ticks wide;
+      only an agent that has used the lull to assemble its force
+      at a launch point can hit the kill bar inside the window.
+    win_condition:
+      all_of:
+        - after_ticks: 1500
+        - units_killed_gte: 6
+        - within_ticks: 3000
+        - units_lost_lte: 1
+    fail_condition:
+      any_of:
+        - after_ticks: 3001
+        - not: {own_units_gte: 1}
+        - not: {units_lost_lte: 1}
+        - all_of:
+            - units_killed_gte: 1
+            - within_ticks: 1499
+    max_turns: 56

tests/test_coordination_ordered_rendezvous.py

@@ -0,0 +1,162 @@
+"""coordination-ordered-rendezvous: ordered multi-waypoint delivery.
+
+Structural tests verify the win predicate uses waypoint_sequence (not
+parallel units_in_region clauses) so order is enforced — and that the
+overall deadline binds. A pure-predicate unit test on waypoint_sequence
+also confirms the order-violation case (later waypoint visited first
+does NOT satisfy the sequence).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+# openra_bench.scenarios eagerly imports the Rust adapter at module
+# load (schema.py:15), so collection fails without the wheel. Skip the
+# whole module if the env is missing — matches test_building_planning.
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import compile_level
+from openra_bench.scenarios.win_conditions import WinContext, evaluate
+
+PACK = (
+    Path(__file__).parent.parent
+    / "openra_bench"
+    / "scenarios"
+    / "packs"
+    / "coordination-ordered-rendezvous.yaml"
+)
+
+EXPECTED_WAYPOINTS = {"easy": 2, "medium": 3, "hard": 4}
+
+
+def _win_clauses(c):
+    return dict(c.win_condition.__pydantic_extra__ or {})["all_of"]
+
+
+def _fail_clauses(c):
+    return dict(c.fail_condition.__pydantic_extra__ or {})["any_of"]
+
+
+def _seq_value(c):
+    for cl in _win_clauses(c):
+        if "waypoint_sequence" in cl:
+            return cl["waypoint_sequence"]
+    return None
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_level_uses_waypoint_sequence_not_simultaneous_regions(level):
+    pack = load_pack(PACK)
+    assert pack.meta.capability == "action"
+    c = compile_level(pack, level)
+
+    win = _win_clauses(c)
+    seq = _seq_value(c)
+    assert seq is not None, f"{level}: must use waypoint_sequence for order"
+    assert seq["n"] == 2, f"{level}: each leg requires >=2 units"
+    assert len(seq["points"]) == EXPECTED_WAYPOINTS[level], (
+        f"{level}: expected {EXPECTED_WAYPOINTS[level]} waypoints, got {len(seq['points'])}"
+    )
+    # critically NOT using simultaneous units_in_region (the
+    # action-multiunit-coordination shape) — that doesn't enforce order
+    assert not any("units_in_region_gte" in cl for cl in win), (
+        f"{level}: should use waypoint_sequence, not units_in_region_gte"
+    )
+
+    # deadline binds
+    wt = [cl["within_ticks"] for cl in win if "within_ticks" in cl][0]
+    assert wt < c.max_turns * 90, f"{level}: within_ticks {wt} doesn't bind"
+
+    # every level can LOSE
+    fail = _fail_clauses(c)
+    assert any("after_ticks" in cl for cl in fail), (
+        f"{level}: missing timeout in fail_condition"
+    )
+
+
+def test_waypoint_count_scales_with_difficulty():
+    pack = load_pack(PACK)
+    counts = []
+    for level in ("easy", "medium", "hard"):
+        c = compile_level(pack, level)
+        counts.append(len(_seq_value(c)["points"]))
+    assert counts == [2, 3, 4], f"waypoint count should ladder 2->3->4, got {counts}"
+
+
+# ---- pure-Python predicate unit tests on waypoint_sequence ordering ----
+
+
+class _FakeSignals:
+    def __init__(self):
+        self.game_tick = 100
+        self.seq_progress: dict = {}
+
+
+def _ctx(units):
+    return WinContext(signals=_FakeSignals(), render_state={"units_summary": units})
+
+
+def test_waypoint_sequence_advances_only_in_order():
+    sig = _FakeSignals()
+    pts = [{"x": 110, "y": 8}, {"x": 110, "y": 32}]
+    spec = {"waypoint_sequence": {"id": "t", "n": 2, "radius": 7, "points": pts}}
+
+    # Visit W2 first — must NOT satisfy
+    ctx = WinContext(
+        signals=sig,
+        render_state={"units_summary": [
+            {"cell_x": 110, "cell_y": 32}, {"cell_x": 111, "cell_y": 32},
+        ]},
+    )
+    assert evaluate(spec, ctx) is False
+    # idx must still be 0 (no premature advance from W2-only presence)
+    assert sig.seq_progress.get("t", 0) == 0
+
+    # Now visit W1
+    ctx = WinContext(
+        signals=sig,
+        render_state={"units_summary": [
+            {"cell_x": 110, "cell_y": 8}, {"cell_x": 111, "cell_y": 8},
+        ]},
+    )
+    assert evaluate(spec, ctx) is False  # W1 advances; W2 not yet
+    assert sig.seq_progress["t"] == 1
+
+    # Then visit W2 — sequence completes
+    ctx = WinContext(
+        signals=sig,
+        render_state={"units_summary": [
+            {"cell_x": 110, "cell_y": 32}, {"cell_x": 111, "cell_y": 32},
+        ]},
+    )
+    assert evaluate(spec, ctx) is True
+    assert sig.seq_progress["t"] == 2
+
+
+def test_waypoint_sequence_requires_min_n_units():
+    sig = _FakeSignals()
+    pts = [{"x": 110, "y": 8}, {"x": 110, "y": 32}]
+    spec = {"waypoint_sequence": {"id": "t2", "n": 2, "radius": 7, "points": pts}}
+
+    # Only 1 unit at W1 — does not advance
+    ctx = WinContext(
+        signals=sig,
+        render_state={"units_summary": [{"cell_x": 110, "cell_y": 8}]},
+    )
+    assert evaluate(spec, ctx) is False
+    assert sig.seq_progress.get("t2", 0) == 0
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_pack_runs_and_donothing_loses(level):
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK), level)
+    assert c.map_supported
+    res = run_level(c, lambda rs, C: [C.observe()], seed=1)
+    assert res.outcome == "loss", (
+        f"{level}: do-nothing should LOSE on timeout, got {res.outcome}"
+    )

tests/test_hard_tier.py

@@ -82,6 +82,22 @@ NOT_APPLICABLE = {
     "instead of handed coordinates). Adding seed-driven spawn variation "
     "would introduce a second uncontrolled variable and break the clean "
     "medium→hard attribution.",
+    # PR #8 from yiyu-tian: 4 packs that tighten one decision axis per
+    # tier rather than per-spawn variation. UPGRADED would force a
+    # second variable per tier and break the clean attribution model.
+    "perception-count-the-threat-small-k": "hard tightens K (2→3→4) "
+    "and the positional non-obviousness of each squad — adding spawn "
+    "variation would dilute the count-and-infer signal. Companion to "
+    "perception-count-the-threat (UPGRADED above), which IS spawn-varied.",
+    "coordination-ordered-rendezvous": "hard tightens the waypoint "
+    "count (2→3→4) and the overall deadline; spawn variation would "
+    "compete with the order-enforcement axis for attribution.",
+    "tempo-strike-window": "hard tightens the lull length, follow-up "
+    "window, and attrition cap (cat-c11 canonical tempo design). "
+    "Spawn variation would dilute the tempo-discipline signal.",
+    "risk-blockade-bypass": "hard adds a tempo gate (after_ticks) and "
+    "shrinks the attrition cap; spawn variation would muddy the "
+    "corridor-vs-detour route-choice signal.",
 }
 
 # No-adversary maps: spawn variation applies but a force-loss

tests/test_perception_count_the_threat_small_k.py

@@ -0,0 +1,106 @@
+"""perception-count-the-threat: exact-K enemy discovery under fog.
+
+Structural tests assert the predicate shape — each level discriminates
+by the exact K (enemies_discovered_gte) and has a real fail_condition.
+Run-smoke test confirms the pack loads and a do-nothing agent loses on
+the timeout (proves fail_condition is wired through compile()).
+
+Module-level importorskip because openra_bench.scenarios imports the
+Rust adapter at import time (schema.py:15), so even pure-Python
+structural tests need the wheel to load the package. Same pattern as
+test_building_planning.py.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import compile_level
+
+PACK = (
+    Path(__file__).parent.parent
+    / "openra_bench"
+    / "scenarios"
+    / "packs"
+    / "perception-count-the-threat-small-k.yaml"
+)
+
+EXPECTED_K = {"easy": 2, "medium": 3, "hard": 4}
+
+
+def _win_clauses(c):
+    return dict(c.win_condition.__pydantic_extra__ or {})["all_of"]
+
+
+def _fail_clauses(c):
+    return dict(c.fail_condition.__pydantic_extra__ or {})["any_of"]
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_level_predicates_isolate_exact_count(level):
+    pack = load_pack(PACK)
+    assert pack.meta.capability == "perception"
+    c = compile_level(pack, level)
+
+    win = _win_clauses(c)
+    # exact K target for this level
+    ks = [cl["enemies_discovered_gte"] for cl in win if "enemies_discovered_gte" in cl]
+    assert ks == [EXPECTED_K[level]], (
+        f"{level}: expected enemies_discovered_gte={EXPECTED_K[level]}, got {ks}"
+    )
+    # tight clock binds (< max_turns * 90)
+    wt = [cl["within_ticks"] for cl in win if "within_ticks" in cl][0]
+    assert wt < c.max_turns * 90, f"{level}: within_ticks {wt} doesn't bind"
+    # attrition cap present
+    assert any("units_lost_lte" in cl for cl in win), (
+        f"{level}: missing units_lost_lte attrition cap"
+    )
+
+    # every level can LOSE (timeout-fail at min)
+    fail = _fail_clauses(c)
+    assert any("after_ticks" in cl for cl in fail), (
+        f"{level}: missing timeout in fail_condition"
+    )
+
+
+def test_k_increases_monotonically_with_difficulty():
+    pack = load_pack(PACK)
+    ks = []
+    for level in ("easy", "medium", "hard"):
+        c = compile_level(pack, level)
+        ks.append([cl["enemies_discovered_gte"] for cl in _win_clauses(c) if "enemies_discovered_gte" in cl][0])
+    assert ks == sorted(ks) and ks[0] < ks[-1], (
+        f"K must scale with difficulty; got {ks}"
+    )
+
+
+def test_hidden_actor_count_matches_K():
+    """K hidden enemies must actually exist on the map — otherwise the
+    win is unsatisfiable."""
+    pack = load_pack(PACK)
+    for level in ("easy", "medium", "hard"):
+        c = compile_level(pack, level)
+        enemy_actors = [a for a in c.scenario.actors if a.owner == "enemy"]
+        # count distinct enemy *positions* (each group is a discoverable squad)
+        positions = {(a.position[0], a.position[1]) for a in enemy_actors}
+        assert len(positions) >= EXPECTED_K[level], (
+            f"{level}: only {len(positions)} enemy positions on map, "
+            f"win needs {EXPECTED_K[level]}"
+        )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_pack_runs_and_donothing_loses(level):
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK), level)
+    assert c.map_supported
+    res = run_level(c, lambda rs, C: [C.observe()], seed=1)
+    # do-nothing must lose on the timeout (proves fail_condition is live)
+    assert res.outcome == "loss", (
+        f"{level}: do-nothing should LOSE on timeout, got {res.outcome}"
+    )

tests/test_risk_blockade_bypass.py

@@ -0,0 +1,116 @@
+"""risk-blockade-bypass: route-risk decision with two visible routes
+(heavy corridor vs longer detour).
+
+Structural tests verify the win predicate combines a positional
+objective (reach_region) with a binding attrition cap and clock —
+the three pieces that make this a risk decision, not a navigation
+or combat test. Hard adds a tempo gate (after_ticks) tightening the
+risk calculus (can't speedrun).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+# openra_bench.scenarios eagerly imports the Rust adapter at module
+# load (schema.py:15), so collection fails without the wheel. Skip the
+# whole module if the env is missing — matches test_building_planning.
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import compile_level
+
+PACK = (
+    Path(__file__).parent.parent
+    / "openra_bench"
+    / "scenarios"
+    / "packs"
+    / "risk-blockade-bypass.yaml"
+)
+
+# (deadline, loss_cap, after_ticks_gate_or_None)
+# Tempo gate dropped from hard to keep the difficulty axis on route-
+# risk only (CLAUDE.md C.10: one new controlled variable per tier).
+EXPECTED = {
+    "easy":   (3500, 4, None),
+    "medium": (2800, 2, None),
+    "hard":   (2400, 1, None),
+}
+
+
+def _win_clauses(c):
+    return dict(c.win_condition.__pydantic_extra__ or {})["all_of"]
+
+
+def _fail_clauses(c):
+    return dict(c.fail_condition.__pydantic_extra__ or {})["any_of"]
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_level_encodes_reach_with_attrition_and_clock(level):
+    pack = load_pack(PACK)
+    assert pack.meta.capability == "reasoning"
+    c = compile_level(pack, level)
+
+    win = _win_clauses(c)
+    reach = [cl["reach_region"] for cl in win if "reach_region" in cl]
+    deadline = [cl["within_ticks"] for cl in win if "within_ticks" in cl]
+    loss_cap = [cl["units_lost_lte"] for cl in win if "units_lost_lte" in cl]
+    after = [cl["after_ticks"] for cl in win if "after_ticks" in cl]
+
+    assert len(reach) == 1, f"{level}: must reach exactly one region"
+    assert reach[0]["x"] == 110, f"{level}: objective should be at the east marker"
+    assert len(deadline) == 1 and len(loss_cap) == 1, (
+        f"{level}: must have both within_ticks and units_lost_lte"
+    )
+
+    exp_deadline, exp_loss, exp_after = EXPECTED[level]
+    assert deadline[0] == exp_deadline
+    assert loss_cap[0] == exp_loss
+    if exp_after is None:
+        assert after == [], f"{level}: should not have an after_ticks gate"
+    else:
+        assert after == [exp_after], f"{level}: expected after_ticks={exp_after}, got {after}"
+
+
+def test_attrition_cap_tightens_with_difficulty():
+    caps = [EXPECTED[lv][1] for lv in ("easy", "medium", "hard")]
+    assert caps == [4, 2, 1] and caps == sorted(caps, reverse=True), (
+        f"attrition cap must tighten 4->2->1: {caps}"
+    )
+
+
+def test_deadline_tightens_with_difficulty():
+    deadlines = [EXPECTED[lv][0] for lv in ("easy", "medium", "hard")]
+    assert deadlines == sorted(deadlines, reverse=True), (
+        f"deadline must tighten: {deadlines}"
+    )
+
+
+def test_both_routes_visibly_present_on_map():
+    """The map must contain BOTH the heavy-corridor garrison (mid-east)
+    and the light-detour picket (north) — otherwise it isn't a route
+    choice scenario."""
+    pack = load_pack(PACK)
+    for level in ("easy", "medium", "hard"):
+        c = compile_level(pack, level)
+        enemy = [a for a in c.scenario.actors if a.owner == "enemy"]
+        # heavy corridor garrison at y~20 (mid-latitude)
+        corridor = [a for a in enemy if 15 <= a.position[1] <= 25 and 40 <= a.position[0] <= 70]
+        # light detour picket at y~5 (top)
+        detour = [a for a in enemy if a.position[1] <= 10 and 40 <= a.position[0] <= 70]
+        assert corridor, f"{level}: missing heavy corridor garrison"
+        assert detour, f"{level}: missing light detour picket"
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_pack_runs_and_donothing_loses(level):
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK), level)
+    assert c.map_supported
+    res = run_level(c, lambda rs, C: [C.observe()], seed=1)
+    assert res.outcome == "loss", (
+        f"{level}: do-nothing should LOSE on timeout, got {res.outcome}"
+    )

tests/test_tempo_strike_window.py

@@ -0,0 +1,118 @@
+"""tempo-strike-window: forced lull then kill quota.
+
+Structural tests verify every level encodes (a) an after_ticks lull
+gate, (b) a kill quota, (c) a within_ticks deadline, (d) an attrition
+cap, AND (e) a "premature engagement" fail clause keyed off
+units_killed_gte inside the lull window.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+# openra_bench.scenarios eagerly imports the Rust adapter at module
+# load (schema.py:15), so collection fails without the wheel. Skip the
+# whole module if the env is missing — matches test_building_planning.
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import compile_level
+
+PACK = (
+    Path(__file__).parent.parent
+    / "openra_bench"
+    / "scenarios"
+    / "packs"
+    / "tempo-strike-window.yaml"
+)
+
+# (lull_until, kill_target, deadline, loss_cap)
+EXPECTED = {
+    "easy":   (2000, 4, 4200, 3),
+    "medium": (1800, 5, 3600, 2),
+    "hard":   (1500, 6, 3000, 1),
+}
+
+
+def _win_clauses(c):
+    return dict(c.win_condition.__pydantic_extra__ or {})["all_of"]
+
+
+def _fail_clauses(c):
+    return dict(c.fail_condition.__pydantic_extra__ or {})["any_of"]
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_level_encodes_lull_kill_deadline_attrition(level):
+    pack = load_pack(PACK)
+    assert pack.meta.capability == "reasoning"
+    c = compile_level(pack, level)
+
+    win = _win_clauses(c)
+    after = [cl["after_ticks"] for cl in win if "after_ticks" in cl]
+    killed = [cl["units_killed_gte"] for cl in win if "units_killed_gte" in cl]
+    within = [cl["within_ticks"] for cl in win if "within_ticks" in cl]
+    lost = [cl["units_lost_lte"] for cl in win if "units_lost_lte" in cl]
+
+    assert len(after) == 1 and len(killed) == 1 and len(within) == 1 and len(lost) == 1, (
+        f"{level}: must have exactly one of each (after_ticks/units_killed_gte/"
+        f"within_ticks/units_lost_lte)"
+    )
+    lull_until, kill_target, deadline, loss_cap = EXPECTED[level]
+    assert after[0] == lull_until, f"{level}: lull_until expected {lull_until}, got {after[0]}"
+    assert killed[0] == kill_target, f"{level}: kill_target expected {kill_target}, got {killed[0]}"
+    assert within[0] == deadline, f"{level}: deadline expected {deadline}, got {within[0]}"
+    assert lost[0] == loss_cap, f"{level}: loss_cap expected {loss_cap}, got {lost[0]}"
+    assert after[0] < within[0], f"{level}: lull must end before deadline"
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_fail_condition_includes_premature_engagement(level):
+    """The 'premature engagement' fail = units_killed_gte:N AND
+    within_ticks:lull-1 — i.e. having too many kills before the lull
+    elapses immediately loses."""
+    pack = load_pack(PACK)
+    c = compile_level(pack, level)
+    fail = _fail_clauses(c)
+    lull_until = EXPECTED[level][0]
+
+    has_premature = False
+    for cl in fail:
+        if "all_of" in cl:
+            inner = cl["all_of"]
+            has_killed = any("units_killed_gte" in x for x in inner)
+            within_cap = [x["within_ticks"] for x in inner if "within_ticks" in x]
+            if has_killed and within_cap and within_cap[0] < lull_until:
+                has_premature = True
+                break
+    assert has_premature, (
+        f"{level}: missing premature-engagement fail "
+        f"(units_killed_gte AND within_ticks < {lull_until})"
+    )
+
+
+def test_difficulty_tightens_lull_kill_deadline_attrition():
+    """easy -> medium -> hard: shorter lull, higher kill bar, shorter
+    deadline, tighter attrition cap."""
+    lulls = [EXPECTED[lv][0] for lv in ("easy", "medium", "hard")]
+    kills = [EXPECTED[lv][1] for lv in ("easy", "medium", "hard")]
+    deadlines = [EXPECTED[lv][2] for lv in ("easy", "medium", "hard")]
+    losses = [EXPECTED[lv][3] for lv in ("easy", "medium", "hard")]
+
+    assert lulls == sorted(lulls, reverse=True), f"lull should shrink: {lulls}"
+    assert kills == sorted(kills), f"kill target should grow: {kills}"
+    assert deadlines == sorted(deadlines, reverse=True), f"deadline should shrink: {deadlines}"
+    assert losses == sorted(losses, reverse=True), f"loss cap should shrink: {losses}"
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_pack_runs_and_donothing_loses(level):
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK), level)
+    assert c.map_supported
+    res = run_level(c, lambda rs, C: [C.observe()], seed=1)
+    assert res.outcome == "loss", (
+        f"{level}: do-nothing should LOSE on timeout, got {res.outcome}"
+    )