fix-forward: repair merged PR#5/#6 (unblocked by own-unit actor_type fix)

The collaborator merged PR#5 (tech-production-planning) and PR#6
(economy-investment/rush-hour fail_conditions + longhorizon pack) raw
— main was RED (3 failures). With the engine own-unit actor_type fix:

- tech-production-planning: now WINNABLE (scripted chain wins easy
~tick 2883). Un-quarantined; realigned the inert within_ticks to the
tick reachable at max_turns (5403/7203/8103) + added timeout fails;
classified NOT_APPLICABLE (non-spatial build-order); added 'mine'
glossary entry; fixed the PR's test (res.signals.units_summary
AttributeError -> a win already proves the 3tnk; hard-fail test
updated to the any_of shape).
- economy-investment / rush-hour / longhorizon-opening-to-assault:
realigned the inert after_ticks fails to R=93+90·(max_turns-1) so a
non-finisher LOSES instead of drawing (turn budget unchanged ->
solvency-safe); classified longhorizon NOT_APPLICABLE.

Suite 380 passed, 1 skipped; catalog regenerated.

openra_bench/game_knowledge.py

@@ -52,6 +52,7 @@ ACTOR_GLOSSARY: dict[str, str] = {
     "fix": "service depot (repairs vehicles)",
     "dome": "radar dome (reveals map / tech prerequisite)",
     "silo": "ore silo (stores surplus ore)",
+    "mine": "ore mine (resource node harvesters gather from)",
     "gun": "gun turret (anti-vehicle base defence)",
     "pbox": "pillbox (anti-infantry base defence)",
     "tsla": "Tesla coil (powerful anti-everything defence)",

openra_bench/scenarios/packs/economy-investment.yaml

@@ -73,9 +73,11 @@ levels:
       all_of:
         - building_count_gte: {type: proc, n: 2}
         - building_count_gte: {type: powr, n: 2}
-        - within_ticks: 22000
+        - within_ticks: 6303
+    # aligned to tick reachable at max_turns (~90/turn): non-finisher
+    # LOSES not draws; turn budget unchanged (solvency-safe).
     fail_condition:
-      after_ticks: 22001
+      after_ticks: 6303
     max_turns: 70
   medium:
     description: >
@@ -89,9 +91,9 @@ levels:
         - building_count_gte: {type: proc, n: 2}
         - building_count_gte: {type: powr, n: 2}
         - own_units_gte: 3
-        - within_ticks: 16000
+        - within_ticks: 7203
     fail_condition:
-      after_ticks: 16001
+      after_ticks: 7203
     max_turns: 80
   hard:
     description: >
@@ -105,9 +107,9 @@ levels:
         - own_units_gte: 6
         - building_count_gte: {type: proc, n: 1}
         - units_lost_lte: 0
-        - within_ticks: 14000
+        - within_ticks: 8103
     fail_condition:
       any_of:
-        - after_ticks: 14001
+        - after_ticks: 8103
         - not: {units_lost_lte: 0}
     max_turns: 90

openra_bench/scenarios/packs/longhorizon-opening-to-assault.yaml

@@ -103,9 +103,9 @@ levels:
         - has_building: proc
         - own_units_gte: 4
         - reach_region: {x: 115, y: 32, radius: 8}
-        - within_ticks: 40000
+        - within_ticks: 10803
     fail_condition:
-      after_ticks: 40001
+      after_ticks: 10803
     max_turns: 120
 
   medium:
@@ -119,9 +119,9 @@ levels:
         - has_building: proc
         - own_units_gte: 5
         - reach_region: {x: 115, y: 32, radius: 7}
-        - within_ticks: 32000
+        - within_ticks: 12603
     fail_condition:
-      after_ticks: 32001
+      after_ticks: 12603
     max_turns: 140
 
   hard:
@@ -140,10 +140,10 @@ levels:
         - has_building: proc
         - own_units_gte: 6
         - reach_region: {x: 115, y: 32, radius: 6}
-        - within_ticks: 24000
+        - within_ticks: 14403
         - units_lost_lte: 4
     fail_condition:
       any_of:
-        - after_ticks: 24001
+        - after_ticks: 14403
         - not: {own_units_gte: 1}
     max_turns: 160

openra_bench/scenarios/packs/rush-hour.yaml

@@ -523,12 +523,12 @@ levels:
     win_condition:
       all_of:
       - units_killed_gte: 5
-      - within_ticks: 16000
+      - within_ticks: 3603
       - units_lost_lte: 6
     fail_condition:
       any_of:
       - not: {own_units_gte: 1}
-      - after_ticks: 16001
+      - after_ticks: 3603
   medium:
     description: >
       Rush Hour Sweep \u2014 medium. Tighter clock and attrition cap:
@@ -537,12 +537,12 @@ levels:
     win_condition:
       all_of:
       - units_killed_gte: 7
-      - within_ticks: 13000
+      - within_ticks: 3603
       - units_lost_lte: 4
     fail_condition:
       any_of:
       - not: {own_units_gte: 1}
-      - after_ticks: 13001
+      - after_ticks: 3603
   hard:
     description: >
       Rush Hour Sweep \u2014 hard. The agent force already round-robins
@@ -552,9 +552,9 @@ levels:
     win_condition:
       all_of:
       - units_killed_gte: 9
-      - within_ticks: 10000
+      - within_ticks: 3603
       - units_lost_lte: 3
     fail_condition:
       any_of:
       - not: {own_units_gte: 1}
-      - after_ticks: 10001
+      - after_ticks: 3603

openra_bench/scenarios/packs/tech-production-planning.yaml

@@ -67,7 +67,11 @@ levels:
       all_of:
         - unit_type_count_gte: {type: 3tnk, n: 1}
         - building_count_gte: {type: fix, n: 1}
-        - within_ticks: 18000
+        - within_ticks: 5403
+    # aligned to tick reachable at max_turns (~90/turn); scripted
+    # chain wins easy by ~tick 2883 so this stays solvable.
+    fail_condition:
+      after_ticks: 5403
     max_turns: 60
 
   medium:
@@ -93,7 +97,9 @@ levels:
         - unit_type_count_gte: {type: e3, n: 1}
         - unit_type_count_gte: {type: e1, n: 3}
         - power_surplus_gte: 0
-        - within_ticks: 22000
+        - within_ticks: 7203
+    fail_condition:
+      after_ticks: 7203
     max_turns: 80
 
   hard:
@@ -121,7 +127,9 @@ levels:
       all_of:
         - enemies_discovered_gte: 2
         - unit_type_count_gte: {type: e3, n: 5}
-        - within_ticks: 14000
+        - within_ticks: 8103
     fail_condition:
-      unit_type_count_gte: {type: e1, n: 10}
+      any_of:
+        - after_ticks: 8103
+        - unit_type_count_gte: {type: e1, n: 10}
     max_turns: 90

tests/test_hard_tier.py

@@ -48,6 +48,11 @@ NOT_APPLICABLE = {
     "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",
+    "tech-production-planning": "non-spatial: build-order dependency "
+    "planning (precedence + power + budget); start position irrelevant",
+    "longhorizon-opening-to-assault": "fixed pre-seeded base; the test "
+    "is the scout→tech→army→strike phase chain within one budget, not "
+    "start-position generalization (single base by design)",
     "reasoning-risk-route": "rigor 5/5 from one tuned safe seam — varying "
     "the start would break the single-solution tuning / seed parity",
     "strategy-dilemma": "win redesigned to destroy fact+proc (faithful "

tests/test_tech_production_planning.py

@@ -75,11 +75,12 @@ def test_easy_tech_chain_wins_and_scores():
     assert "weap" in btypes and "fix" in btypes, (
         f"chain incomplete; own_building_types={btypes}"
     )
-    # The agent actually trained a Heavy Tank.
-    unit_types = [u["type"] for u in res.signals.units_summary]
-    assert "3tnk" in unit_types, f"no 3tnk produced; units={unit_types}"
     # Production debited the budget.
     assert res.signals.cash < 5000, "construction must debit the budget"
+    # A win implies a Heavy Tank was trained: the win condition
+    # includes `unit_type_count_gte {type: 3tnk, n: 1}`, so outcome ==
+    # "win" is itself proof the 3tnk was produced (and observed — this
+    # also exercises the own-unit actor_type fix).
     assert res.outcome == "win", f"easy should be winnable, got {res.outcome}"
 
     sc = score_episode(c, res)
@@ -126,6 +127,10 @@ def test_hard_fail_predicate_set():
     it). Schema-level check, no episode run required."""
     c = compile_level(load_pack(PACK), "hard")
     assert c.fail_condition is not None
-    # The fail leaf is unit_type_count_gte on e1 at n=10.
+    # Hard loses on EITHER the timeout (deadline aligned to the tick
+    # reachable at max_turns — no draw degeneracy) OR overproducing
+    # infantry past 10.
     fc = c.fail_condition.model_dump(exclude_none=True)
-    assert fc == {"unit_type_count_gte": {"type": "e1", "n": 10}}, fc
+    clauses = fc.get("any_of", [fc])
+    assert {"unit_type_count_gte": {"type": "e1", "n": 10}} in clauses, fc
+    assert any("after_ticks" in cl for cl in clauses), fc