Hard-tier curation: action/perception/reasoning/strict/rush-hour + exhaustive classification

Seed-driven spawn variation (+ fail_condition where an adversary
exists) applied to every remaining applicable pack:
- action-multiunit-coordination, action-sequenced-execution: 2 spawn
groups (same fixed regions/waypoints), + force-loss fail
- perception-frontier-reading, perception-target-vs-fog: scouts staged
from a seed-chosen corner so the fog-reading order flips by seed, + fail
- reasoning-frontier-commit: single scout, seed-chosen corner → the
commitment decision must generalise, + fail
- strict-sequence, custom-map-no-enemy: 2 spawn groups (no-adversary →
no force-loss fail, documented in _NO_ENEMY)
- rush-hour: already round-robins base spawn 0/1 by seed; added the
missing force-loss fail_condition

Consciously N/A (documented w/ reasons in NOT_APPLICABLE): economy-*/
building-and-planning/strict-production-bom (non-spatial),
reasoning-risk-route (tuned single seam), strategy-* (win-predicate
redesign needed, separate rigor item).

test_hard_tier.py: 15 packs in UPGRADED, live seed→distinct-start
integ check per pack, fail_condition check, + exhaustive
classification test (every active pack is UPGRADED or N/A). Full
suite 305 passed, 1 skipped.

openra_bench/scenarios/packs/action-multiunit-coordination.yaml

@@ -88,10 +88,17 @@ levels:
       genuine parallel multi-group control can satisfy all clauses.
     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: apc,  owner: agent, position: [9, 18], count: 2}
+        # spawn_point 0 — full force, northern staging
+        - {type: 2tnk, owner: agent, position: [5, 6],  count: 3, spawn_point: 0}
+        - {type: 1tnk, owner: agent, position: [7, 10], count: 3, spawn_point: 0}
+        - {type: jeep, owner: agent, position: [5, 14], count: 2, spawn_point: 0}
+        - {type: apc,  owner: agent, position: [9, 18], count: 2, spawn_point: 0}
+        # spawn_point 1 — full force, southern staging (same 3 fixed
+        # regions to cover; seed picks the start cluster)
+        - {type: 2tnk, owner: agent, position: [5, 20], count: 3, spawn_point: 1}
+        - {type: 1tnk, owner: agent, position: [7, 24], count: 3, spawn_point: 1}
+        - {type: jeep, owner: agent, position: [5, 28], count: 2, spawn_point: 1}
+        - {type: apc,  owner: agent, position: [9, 32], count: 2, spawn_point: 1}
         - {type: fact, owner: enemy, position: [112, 5]}
         - {type: proc, owner: enemy, position: [112, 35]}
         - {type: powr, owner: enemy, position: [115, 20]}
@@ -107,4 +114,6 @@ levels:
         - {reach_region: {x: 115, y: 20, radius: 7}}
         - {within_ticks: 4200}
         - {units_lost_lte: 2}
+    fail_condition:
+      not: {own_units_gte: 1}
     max_turns: 44

openra_bench/scenarios/packs/action-sequenced-execution.yaml

@@ -87,10 +87,17 @@ levels:
       leg overruns the clock or loses too many units.
     overrides:
       actors:
-        - {type: 2tnk, owner: agent, position: [5, 8],  count: 2}
-        - {type: 1tnk, owner: agent, position: [7, 12], count: 2}
-        - {type: jeep, owner: agent, position: [5, 16]}
-        - {type: apc,  owner: agent, position: [9, 20]}
+        # spawn_point 0 — northern staging
+        - {type: 2tnk, owner: agent, position: [5, 8],  count: 2, spawn_point: 0}
+        - {type: 1tnk, owner: agent, position: [7, 12], count: 2, spawn_point: 0}
+        - {type: jeep, owner: agent, position: [5, 16], spawn_point: 0}
+        - {type: apc,  owner: agent, position: [9, 20], spawn_point: 0}
+        # spawn_point 1 — southern staging (same serpentine to the same
+        # fixed waypoints/final; seed picks the start)
+        - {type: 2tnk, owner: agent, position: [5, 22], count: 2, spawn_point: 1}
+        - {type: 1tnk, owner: agent, position: [7, 26], count: 2, spawn_point: 1}
+        - {type: jeep, owner: agent, position: [5, 30], spawn_point: 1}
+        - {type: apc,  owner: agent, position: [9, 34], spawn_point: 1}
         - {type: powr, owner: enemy, position: [45, 33]}    # W1
         - {type: proc, owner: enemy, position: [80, 6]}      # W2
         - {type: tsla, owner: enemy, position: [110, 30]}    # W3
@@ -104,4 +111,6 @@ levels:
         - {after_ticks: 3400}
         - {within_ticks: 4400}
         - {units_lost_lte: 1}
+    fail_condition:
+      not: {own_units_gte: 1}
     max_turns: 46

openra_bench/scenarios/packs/custom-map-no-enemy.yaml

@@ -63,7 +63,16 @@ levels:
   hard:
     description: >
       Whole squad must reach the far corner of the playable bounds
-      together within a short deadline.
+      together within a short deadline, starting from a seed-chosen
+      position (two spawn_point groups) so the route can't be replayed
+      from memory. (No adversary on this map → no force-loss fail; the
+      only failure mode is missing the deadline.)
+    overrides:
+      actors:
+        - {type: jeep, owner: agent, position: [8, 12], spawn_point: 0}
+        - {type: e1,   owner: agent, position: [9, 14], count: 2, spawn_point: 0}
+        - {type: jeep, owner: agent, position: [8, 28], spawn_point: 1}
+        - {type: e1,   owner: agent, position: [9, 26], count: 2, spawn_point: 1}
     win_condition:
       all_of:
         - all_units_in_region: {x: 70, y: 24, radius: 6}

openra_bench/scenarios/packs/perception-frontier-reading.yaml

@@ -83,8 +83,13 @@ levels:
       reading of all three fog pockets clears the coverage bar in time.
     overrides:
       actors:
-        - {type: jeep, owner: agent, position: [5, 33], count: 3}
-        - {type: jeep, owner: agent, position: [7, 30], count: 2}
+        # spawn_point 0 — scouts staged SW
+        - {type: jeep, owner: agent, position: [5, 33], count: 3, spawn_point: 0}
+        - {type: jeep, owner: agent, position: [7, 30], count: 2, spawn_point: 0}
+        # spawn_point 1 — scouts staged NW (the three fog pockets are
+        # fixed, so the reading order that works flips by seed)
+        - {type: jeep, owner: agent, position: [5, 6], count: 3, spawn_point: 1}
+        - {type: jeep, owner: agent, position: [7, 9], count: 2, spawn_point: 1}
         # Center decoys (already-explored zone) — combat bait.
         - {type: e1, owner: enemy, position: [55, 20], stance: 2, count: 3}
         - {type: e3, owner: enemy, position: [58, 22], stance: 2}
@@ -98,4 +103,6 @@ levels:
         - {explored_pct_gte: 62}
         - {within_ticks: 4800}
         - {units_lost_lte: 1}
+    fail_condition:
+      not: {own_units_gte: 1}
     max_turns: 40

openra_bench/scenarios/packs/perception-target-vs-fog.yaml

@@ -91,8 +91,13 @@ levels:
       — after the near ones are ruled out — discovers it in time.
     overrides:
       actors:
-        - {type: jeep, owner: agent, position: [6, 5], count: 3}
-        - {type: 1tnk, owner: agent, position: [8, 8], count: 2}
+        # spawn_point 0 — staged NW
+        - {type: jeep, owner: agent, position: [6, 5], count: 3, spawn_point: 0}
+        - {type: 1tnk, owner: agent, position: [8, 8], count: 2, spawn_point: 0}
+        # spawn_point 1 — staged SW (target/decoys fixed, so which
+        # pocket is "counter-intuitive" flips by seed)
+        - {type: jeep, owner: agent, position: [6, 33], count: 3, spawn_point: 1}
+        - {type: 1tnk, owner: agent, position: [8, 30], count: 2, spawn_point: 1}
         # Decoy A — near NE, loud enemy squad, no target building.
         - {type: e1,  owner: enemy, position: [60, 6],  stance: 2, count: 3}
         - {type: dog, owner: enemy, position: [64, 9],  stance: 2, count: 2}
@@ -108,4 +113,6 @@ levels:
         - {buildings_discovered_gte: 1}
         - {within_ticks: 4800}
         - {units_lost_lte: 1}
+    fail_condition:
+      not: {own_units_gte: 1}
     max_turns: 40

openra_bench/scenarios/packs/reasoning-frontier-commit.yaml

@@ -94,7 +94,10 @@ levels:
       time without splitting (only one unit).
     overrides:
       actors:
-        - {type: jeep, owner: agent, position: [6, 6], count: 1}
+        # Single scout, seed-chosen corner — the commitment decision
+        # must generalise across start positions, not be memorised.
+        - {type: jeep, owner: agent, position: [6, 6],  count: 1, spawn_point: 0}
+        - {type: jeep, owner: agent, position: [6, 33], count: 1, spawn_point: 1}
         # Decoy A (SE) — hostile cluster; a route through it risks the
         # lone scout (units_lost_lte: 0 constraint below).
         - {type: e3, owner: enemy, position: [110, 34], stance: 2, count: 3}
@@ -108,4 +111,6 @@ levels:
         - {buildings_discovered_gte: 1}
         - {within_ticks: 4200}
         - {units_lost_lte: 0}
+    fail_condition:
+      not: {own_units_gte: 1}
     max_turns: 38

openra_bench/scenarios/packs/rush-hour.yaml

@@ -523,9 +523,15 @@ levels:
       - units_killed_gte: 6
       - within_ticks: 13000
   hard:
-    description: "Rush Hour Sweep \u2014 hard difficulty (ported)."
+    description: >
+      Rush Hour Sweep \u2014 hard. The agent force already round-robins
+      between two base spawn_point groups by seed (start corner varies,
+      anti-memorisation); hard adds a tight clock, an attrition cap,
+      and a real loss on force destruction.
     win_condition:
       all_of:
       - units_killed_gte: 9
       - within_ticks: 10000
       - units_lost_lte: 3
+    fail_condition:
+      not: {own_units_gte: 1}

openra_bench/scenarios/packs/strict-sequence.yaml

@@ -58,6 +58,26 @@ levels:
     description: >
       Tight ordered window: reach the region within a narrow tick band
       (not before 4000, not after 9000) — precise timing compliance.
+      The unit stages from a seed-chosen position (two spawn_point
+      groups) so the exact timed move can't be replayed from memory.
+    overrides:
+      actors:
+        - type: jeep
+          owner: agent
+          position: [6, 8]
+          stance: 0
+          health: 100
+          facing: -1
+          count: 1
+          spawn_point: 0
+        - type: jeep
+          owner: agent
+          position: [6, 30]
+          stance: 0
+          health: 100
+          facing: -1
+          count: 1
+          spawn_point: 1
     win_condition:
       all_of:
         - reach_region: {x: 26, y: 30, radius: 3}

tests/test_hard_tier.py

@@ -31,8 +31,37 @@ UPGRADED = [
     "artofwar-indirect-approach",
     "artofwar-lure-the-tiger",
     "artofwar-sequenced-citadel",
+    "action-multiunit-coordination",
+    "action-sequenced-execution",
+    "strict-sequence",
+    "perception-frontier-reading",
+    "perception-target-vs-fog",
+    "reasoning-frontier-commit",
+    "rush-hour",
+    "custom-map-no-enemy",
 ]
 
+# Consciously NOT spawn-varied, with the reason (keeps the curation
+# exhaustive — every active pack is classified, see the coverage test).
+NOT_APPLICABLE = {
+    "economy-investment": "non-spatial: capital allocation, start pos irrelevant",
+    "economy-time-box": "non-spatial: budget-under-clock",
+    "economy-force-buildup": "non-spatial: production economy",
+    "building-and-planning": "non-spatial: build-order/tech, fixed base",
+    "strict-production-bom": "non-spatial: exact bill-of-materials spec",
+    "reasoning-risk-route": "rigor 5/5 from one tuned safe seam — varying "
+    "the start would break the single-solution tuning / seed parity",
+    "strategy-dilemma": "needs win-predicate redesign (gameable "
+    "buildings_discovered_gte:1), not spawn variation — separate rigor item",
+    "strategy-gauntlet": "dual-entry design + gameable win — separate item",
+    "strategy-twobody": "two simultaneously-controlled groups IS the task; "
+    "spawn-alternatives would break intent — separate item",
+}
+
+# No-adversary maps: spawn variation applies but a force-loss
+# fail_condition is impossible (nothing can destroy the force).
+_NO_ENEMY = {"strict-sequence", "custom-map-no-enemy"}
+
 
 def _agent_spawn_points(pack_id: str, level: str) -> set:
     c = compile_level(load_pack(PACKS / f"{pack_id}.yaml"), level)
@@ -89,7 +118,31 @@ def test_curated_hard_still_compiles_and_runs(pid):
 
 def test_fail_condition_present_on_curated_hard():
     # Curated hard tiers must be able to emit a loss (no loss==draw
-    # degeneracy on the packs we've touched).
+    # degeneracy) — except no-adversary maps where force-loss is
+    # impossible by construction (documented in _NO_ENEMY).
     for pid in UPGRADED:
         c = compile_level(load_pack(PACKS / f"{pid}.yaml"), "hard")
+        if pid in _NO_ENEMY:
+            continue
         assert c.fail_condition is not None, f"{pid}:hard needs a fail_condition"
+
+
+def test_every_active_pack_is_classified():
+    """Curation is exhaustive: every active pack is either spawn-varied
+    (UPGRADED) or consciously NOT_APPLICABLE with a stated reason — no
+    pack silently skipped."""
+    import glob
+    import os
+
+    classified = set(UPGRADED) | set(NOT_APPLICABLE)
+    missing = []
+    for f in glob.glob(str(PACKS / "*.yaml")):
+        b = os.path.basename(f)
+        if b.startswith(("_", "TEMPLATE")):
+            continue
+        m = load_pack(f).meta
+        if m.status != "active":
+            continue
+        if m.id not in classified:
+            missing.append(m.id)
+    assert not missing, f"unclassified active packs (curate or mark N/A): {missing}"