Strategy packs: faithful 'destroy key economic buildings' objective

Per the training design (scout-dilemma/gauntlet/twobody): win = destroy
the enemy's MustBeDestroyed economic core (fact construction yard +
proc refinery), NOT discover-a-building and NOT wipe the deliberately
strong enemy — brute force bleeds the force and loses.

- rust_adapter: enemy_buildings_destroyed{,_types} — a seen enemy
building now absent WHILE an agent unit is on its cell ⇒ killed
(proximity to a current unit is the reliable vision test; cumulative
explored_cells can't distinguish a kill from a fogged retreat)
- win_conditions: enemy_key_buildings_destroyed {types:[...]} (all of
a named set) + enemy_buildings_destroyed_gte (total); goal_tracker
current-fn for the latter
- strategy-dilemma/gauntlet/twobody: win = destroy fact+proc within
ticks; medium/hard add attrition caps; real fail_condition (force
wiped by the strong enemy) — kills the old gameable
buildings_discovered_gte:1 and the loss==draw degeneracy
- tests: test_strategy_objective.py (6) incl proximity/fog edge cases,
non-gameability, live runs of all 3. 311 passed, 1 skipped
- test_hard_tier NOT_APPLICABLE reasons refreshed (win redesigned;
spawn still N/A by design intent)

openra_bench/goal_tracker.py

@@ -29,6 +29,9 @@ _CURRENT: dict[str, Any] = {
     "enemies_discovered_gte": lambda c: len(c.signals.enemies_seen_ids),
     "buildings_discovered_gte": lambda c: len(c.signals.enemy_buildings_seen_ids),
     "units_killed_gte": lambda c: c.signals.units_killed,
+    "enemy_buildings_destroyed_gte": lambda c: getattr(
+        c.signals, "enemy_buildings_destroyed", 0
+    ),
     "units_lost_lte": lambda c: c.signals.units_lost,
     "within_ticks": lambda c: c.signals.game_tick,
     "after_ticks": lambda c: c.signals.game_tick,

openra_bench/rust_adapter.py

@@ -83,6 +83,12 @@ class EpisodeSignals:
     explored_delta: float = 0.0
     enemies_seen_ids: set[str] = field(default_factory=set)
     enemy_buildings_seen_ids: set[str] = field(default_factory=set)
+    # Enemy buildings confirmed destroyed: a building seen earlier that
+    # is now absent while we still have vision of its cell (so it's
+    # killed, not fogged). Total + per-type — the faithful signal for
+    # "eliminate the enemy's key economic structures" objectives.
+    enemy_buildings_destroyed: int = 0
+    enemy_buildings_destroyed_types: dict = field(default_factory=dict)
     new_enemies_this_step: int = 0
     new_buildings_this_step: int = 0
     game_tick: int = 0
@@ -143,6 +149,10 @@ class RustObsAdapter:
         self._prev_own_ids: set[str] = set()
         self._raw: dict[str, Any] = {}
         self._first_own_count: int | None = None
+        # id -> (type, (cell_x, cell_y)) last time the building was seen,
+        # for destruction detection (absent + cell explored ⇒ killed).
+        self._seen_buildings: dict[str, tuple[str, tuple[int, int]]] = {}
+        self._destroyed_bldg_ids: set[str] = set()
 
     # -- ingestion --------------------------------------------------------
     def observe(self, obs: dict[str, Any], done: bool = False) -> None:
@@ -173,10 +183,40 @@ class RustObsAdapter:
         s.new_enemies_this_step = len(s.enemies_seen_ids) - before_e
 
         before_b = len(s.enemy_buildings_seen_ids)
+        visible_b: set[str] = set()
         for b in self._raw.get("enemy_buildings_summary", []) or []:
             if isinstance(b, dict) and b.get("id") is not None:
-                s.enemy_buildings_seen_ids.add(str(b["id"]))
+                bid = str(b["id"])
+                s.enemy_buildings_seen_ids.add(bid)
+                visible_b.add(bid)
+                self._seen_buildings[bid] = (
+                    str(b.get("type", "")).lower(),
+                    (int(b.get("cell_x", 0)), int(b.get("cell_y", 0))),
+                )
         s.new_buildings_this_step = len(s.enemy_buildings_seen_ids) - before_b
+        # Destruction: a previously-seen enemy building now absent while
+        # an agent unit is right on top of its last cell ⇒ it was
+        # killed (not merely fogged after a retreat). Proximity to a
+        # *current* unit is the reliable "we have vision here" test —
+        # `explored_cells` is cumulative and can't distinguish the two.
+        _VIS = 6  # cells; ~unit sight radius
+        agent_cells = [
+            (int(p.get("cell_x", 0)), int(p.get("cell_y", 0)))
+            for p in (own.values() if isinstance(own, dict) else [])
+            if isinstance(p, dict)
+        ]
+        for bid, (btype, (bx, by)) in self._seen_buildings.items():
+            if bid in visible_b or bid in self._destroyed_bldg_ids:
+                continue
+            if any(
+                max(abs(ux - bx), abs(uy - by)) <= _VIS
+                for ux, uy in agent_cells
+            ):
+                self._destroyed_bldg_ids.add(bid)
+                s.enemy_buildings_destroyed_types[btype] = (
+                    s.enemy_buildings_destroyed_types.get(btype, 0) + 1
+                )
+        s.enemy_buildings_destroyed = len(self._destroyed_bldg_ids)
 
         econ = self._raw.get("economy") or {}
         if isinstance(econ, dict):

openra_bench/scenarios/packs/strategy-dilemma.yaml

@@ -253,21 +253,39 @@ base:
     enemy_units_killed: true
 levels:
   easy:
-    description: "Strategy: Risk Dilemma \u2014 easy difficulty (ported)."
+    description: >
+      Risk Dilemma \u2014 destroy the enemy's key economic buildings
+      (construction yard + refinery). The enemy is deliberately strong:
+      brute-forcing every defender bleeds the force and loses. Take the
+      safer route, reach the base, eliminate fact+proc.
     win_condition:
       all_of:
-      - buildings_discovered_gte: 1
+      - enemy_key_buildings_destroyed: {types: [fact, proc]}
       - within_ticks: 16000
+    fail_condition:
+      not: {own_units_gte: 1}
+    max_turns: 100
   medium:
-    description: "Strategy: Risk Dilemma \u2014 medium difficulty (ported)."
+    description: >
+      Same objective (fact+proc), tighter clock and an attrition cap \u2014
+      a costly brawl no longer counts as a win even if you reach base.
     win_condition:
       all_of:
-      - buildings_discovered_gte: 1
+      - enemy_key_buildings_destroyed: {types: [fact, proc]}
       - within_ticks: 12000
+      - units_lost_lte: 8
+    fail_condition:
+      not: {own_units_gte: 1}
+    max_turns: 90
   hard:
-    description: "Strategy: Risk Dilemma \u2014 hard difficulty (ported)."
+    description: >
+      fact+proc destroyed, tight clock, strict attrition: only a clean
+      raid that avoids the strong defenses wins; brute force loses.
     win_condition:
       all_of:
-      - buildings_discovered_gte: 1
+      - enemy_key_buildings_destroyed: {types: [fact, proc]}
       - within_ticks: 9000
-      - units_lost_lte: 2
+      - units_lost_lte: 4
+    fail_condition:
+      not: {own_units_gte: 1}
+    max_turns: 80

openra_bench/scenarios/packs/strategy-gauntlet.yaml

@@ -416,21 +416,39 @@ base:
     enemy_units_killed: true
 levels:
   easy:
-    description: "Strategy: The Gauntlet \u2014 easy difficulty (ported)."
+    description: >
+      The Gauntlet \u2014 run the defended corridor and destroy the enemy's
+      key economic buildings (construction yard + refinery). The
+      corridor is lethal to a brute-force push; sequence and time the
+      run so the force survives to kill fact+proc.
     win_condition:
       all_of:
-      - buildings_discovered_gte: 1
+      - enemy_key_buildings_destroyed: {types: [fact, proc]}
       - within_ticks: 16000
+    fail_condition:
+      not: {own_units_gte: 1}
+    max_turns: 100
   medium:
-    description: "Strategy: The Gauntlet \u2014 medium difficulty (ported)."
+    description: >
+      Same objective (fact+proc), tighter clock + attrition cap \u2014 a
+      costly run no longer counts as a win.
     win_condition:
       all_of:
-      - buildings_discovered_gte: 1
+      - enemy_key_buildings_destroyed: {types: [fact, proc]}
       - within_ticks: 12000
+      - units_lost_lte: 8
+    fail_condition:
+      not: {own_units_gte: 1}
+    max_turns: 90
   hard:
-    description: "Strategy: The Gauntlet \u2014 hard difficulty (ported)."
+    description: >
+      fact+proc destroyed, tight clock, strict attrition: only a
+      well-timed run that survives the gauntlet wins.
     win_condition:
       all_of:
-      - buildings_discovered_gte: 1
+      - enemy_key_buildings_destroyed: {types: [fact, proc]}
       - within_ticks: 9000
-      - units_lost_lte: 2
+      - units_lost_lte: 4
+    fail_condition:
+      not: {own_units_gte: 1}
+    max_turns: 80

openra_bench/scenarios/packs/strategy-twobody.yaml

@@ -335,21 +335,39 @@ base:
     enemy_units_killed: true
 levels:
   easy:
-    description: "Strategy: Two-Body Coordination \u2014 easy difficulty (ported)."
+    description: >
+      Two-Body Coordination \u2014 drive the two separated squads in
+      parallel, converge through the weak gap, and destroy the enemy's
+      key economic buildings (construction yard + refinery). Serial
+      play or a brute-force push through the strong center loses.
     win_condition:
       all_of:
-      - buildings_discovered_gte: 1
+      - enemy_key_buildings_destroyed: {types: [fact, proc]}
       - within_ticks: 16000
+    fail_condition:
+      not: {own_units_gte: 1}
+    max_turns: 100
   medium:
-    description: "Strategy: Two-Body Coordination \u2014 medium difficulty (ported)."
+    description: >
+      Same objective (fact+proc), tighter clock + attrition cap \u2014 only
+      coordinated parallel control reaches base cheaply enough.
     win_condition:
       all_of:
-      - buildings_discovered_gte: 1
+      - enemy_key_buildings_destroyed: {types: [fact, proc]}
       - within_ticks: 12000
+      - units_lost_lte: 8
+    fail_condition:
+      not: {own_units_gte: 1}
+    max_turns: 90
   hard:
-    description: "Strategy: Two-Body Coordination \u2014 hard difficulty (ported)."
+    description: >
+      fact+proc destroyed, tight clock, strict attrition: both squads
+      must converge and raid cleanly; brute force loses.
     win_condition:
       all_of:
-      - buildings_discovered_gte: 1
+      - enemy_key_buildings_destroyed: {types: [fact, proc]}
       - within_ticks: 9000
-      - units_lost_lte: 2
+      - units_lost_lte: 4
+    fail_condition:
+      not: {own_units_gte: 1}
+    max_turns: 80

openra_bench/scenarios/win_conditions.py

@@ -51,6 +51,20 @@ _PREDICATES: dict[str, Callable[[WinContext, Any], bool]] = {
     "buildings_discovered_gte": lambda c, v: len(c.signals.enemy_buildings_seen_ids)
     >= int(v),
     "units_killed_gte": lambda c, v: c.signals.units_killed >= int(v),
+    # Eliminate the enemy's key economic structures (the training
+    # strategy design: destroy fact+proc, NOT brute-force the whole
+    # strong enemy). Total count, or all of a named type set.
+    "enemy_buildings_destroyed_gte": lambda c, v: getattr(
+        c.signals, "enemy_buildings_destroyed", 0
+    )
+    >= int(v),
+    "enemy_key_buildings_destroyed": lambda c, v: all(
+        getattr(c.signals, "enemy_buildings_destroyed_types", {}).get(
+            str(t).lower(), 0
+        )
+        >= 1
+        for t in (v["types"] if isinstance(v, dict) else v)
+    ),
     "units_lost_lte": lambda c, v: c.signals.units_lost <= int(v),
     "within_ticks": lambda c, v: c.signals.game_tick <= int(v),
     "after_ticks": lambda c, v: c.signals.game_tick >= int(v),

tests/test_hard_tier.py

@@ -51,11 +51,13 @@ NOT_APPLICABLE = {
     "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",
+    "strategy-dilemma": "win redesigned to destroy fact+proc (faithful "
+    "to training); spawn deferred — route-choice puzzle is the decision",
+    "strategy-gauntlet": "win redesigned to fact+proc; single defended "
+    "corridor — spawn variation would not add a distinct decision",
+    "strategy-twobody": "win redesigned to fact+proc; two "
+    "simultaneously-controlled groups IS the task — spawn-alternatives "
+    "would break intent",
 }
 
 # No-adversary maps: spawn variation applies but a force-loss

tests/test_strategy_objective.py

@@ -0,0 +1,127 @@
+"""Strategy packs: faithful "destroy the enemy's key economic
+buildings" objective (training design — fact+proc are MustBeDestroyed;
+the enemy is deliberately strong so brute force loses).
+
+Covers the new adapter destruction signal, the two predicates, the
+non-gameability (discovering a building no longer wins), and that all
+three packs compile + run on the live engine.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from openra_bench.rust_adapter import RustObsAdapter
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import compile_level
+from openra_bench.scenarios.win_conditions import WinContext, evaluate
+
+PACKS = Path(__file__).parent.parent / "openra_bench" / "scenarios" / "packs"
+STRAT = ["strategy-dilemma", "strategy-gauntlet", "strategy-twobody"]
+
+
+# ── adapter: destruction detection (absent + cell explored ⇒ killed) ──
+
+
+def test_adapter_counts_destroyed_only_when_unit_is_present():
+    a = RustObsAdapter()
+    # t1: scout sees fact+proc from afar (unit at 5,5) — nothing killed.
+    a.observe({
+        "unit_positions": {"1": {"cell_x": 5, "cell_y": 5}},
+        "enemy_buildings_summary": [
+            {"id": 900, "type": "fact", "cell_x": 80, "cell_y": 35},
+            {"id": 901, "type": "proc", "cell_x": 80, "cell_y": 32},
+        ],
+    })
+    assert a.signals.enemy_buildings_destroyed == 0
+    # t2: a unit is on the proc (79,33) and proc is gone ⇒ killed;
+    # fact still standing.
+    a.observe({
+        "unit_positions": {"1": {"cell_x": 79, "cell_y": 33}},
+        "enemy_buildings_summary": [
+            {"id": 900, "type": "fact", "cell_x": 80, "cell_y": 35},
+        ],
+    })
+    assert a.signals.enemy_buildings_destroyed == 1
+    assert a.signals.enemy_buildings_destroyed_types == {"proc": 1}
+    # t3: fact also absent but the force RETREATED far away ⇒ that's
+    # fog, not a kill — must NOT be counted.
+    a.observe({
+        "unit_positions": {"1": {"cell_x": 5, "cell_y": 5}},
+        "enemy_buildings_summary": [],
+    })
+    assert a.signals.enemy_buildings_destroyed == 1  # unchanged (fog)
+    # t4: a unit is back on the fact cell and it's gone ⇒ now a kill.
+    a.observe({
+        "unit_positions": {"1": {"cell_x": 79, "cell_y": 36}},
+        "enemy_buildings_summary": [],
+    })
+    assert a.signals.enemy_buildings_destroyed == 2
+    assert a.signals.enemy_buildings_destroyed_types == {"proc": 1, "fact": 1}
+
+
+# ── predicates ──
+
+
+class _Sig:
+    def __init__(self, destroyed_types=None, seen=0):
+        self.enemy_buildings_destroyed_types = destroyed_types or {}
+        self.enemy_buildings_destroyed = sum(
+            (destroyed_types or {}).values()
+        )
+        self.enemy_buildings_seen_ids = set(range(seen))
+        self.game_tick = 100
+
+
+def _ctx(sig):
+    return WinContext(signals=sig, render_state={})
+
+
+def test_enemy_key_buildings_predicate_requires_all_types():
+    assert evaluate(
+        {"enemy_key_buildings_destroyed": {"types": ["fact", "proc"]}},
+        _ctx(_Sig({"fact": 1, "proc": 1})),
+    )
+    # only one of the two ⇒ not satisfied
+    assert not evaluate(
+        {"enemy_key_buildings_destroyed": {"types": ["fact", "proc"]}},
+        _ctx(_Sig({"fact": 1})),
+    )
+    assert evaluate(
+        {"enemy_buildings_destroyed_gte": 2},
+        _ctx(_Sig({"fact": 1, "proc": 1})),
+    )
+
+
+def test_objective_is_not_gameable_by_mere_discovery():
+    c = compile_level(load_pack(PACKS / "strategy-dilemma.yaml"), "easy")
+    # Saw the whole enemy base but destroyed nothing → NOT a win
+    # (the old buildings_discovered_gte:1 bug would have passed here).
+    seen_only = _Sig(destroyed_types={}, seen=5)
+    assert evaluate(c.win_condition, _ctx(seen_only)) is False
+    # fact+proc down, in time → win
+    won = _Sig({"fact": 1, "proc": 1})
+    won.game_tick = 1000
+    assert evaluate(c.win_condition, _ctx(won)) is True
+
+
+@pytest.mark.parametrize("pid", STRAT)
+def test_strategy_pack_compiles_runs_and_has_faithful_objective(pid):
+    pack = load_pack(PACKS / f"{pid}.yaml")
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        assert c.map_supported
+        node = dict(c.win_condition.__pydantic_extra__ or {})
+        clauses = node.get("all_of", [])
+        assert any("enemy_key_buildings_destroyed" in cl for cl in clauses), (
+            f"{pid}:{lvl} win must require destroying fact+proc"
+        )
+        assert c.fail_condition is not None  # loss reachable (brute force)
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    res = run_level(compile_level(pack, "easy"),
+                    lambda rs, C: [C.observe()], seed=1)
+    assert res.outcome in {"win", "draw", "loss"} and res.turns >= 1