feat(bench): then composite predicate happened-before (PlanBench replanning / PERT anchor)

A new composite operator alongside all_of / any_of / not. Each clause
must become true IN ORDER over the course of the episode -- not
merely all-of-now. Pattern mirrors waypoint_sequence: per-episode
latch on signals.then_progress[id] (greedy advance through every
consecutive currently-satisfied clause; the latch persists across
turns so a clause that stopped being true still counts).

YAML form:
then:
id: scout-then-counter # stable per-episode key
clauses:
- {buildings_discovered_gte: 1} # FIRST (e.g. scout)
- {unit_type_count_gte: {type: e3, n: 4}} # THEN (counter)

8 tests in tests/test_then_composite.py cover: composite key
registration; in-order success; B-only-without-A never advances;
late-A-then-B credits both via greedy advance; three-stage strict
order; empty clauses do not false-pass; phrase translation renders
'in this exact order: A -> THEN -> B'; multiple `then` predicates
with distinct ids latch independently.

Unblocks B2 mid-tech-switch-on-scout (the 'scout BEFORE counter'
enforcement that all_of cannot express) plus Group I procedural
seeds (proc-ordered-action-strict, etc.) plus Group G long-horizon
seeds (lh-progression-stage-locked) per SCENARIO_BACKLOG.md.

openra_bench/game_knowledge.py

@@ -259,6 +259,19 @@ def _describe(node: Any, join: str = " AND ", coords: str = "exact") -> str:
                 else f"fewer than {n} of your units remain"
             )
         return "NOT (" + _describe(inner, coords=coords) + ")"
+    if "then" in node:
+        # The happened-before composite. Read each clause as a stage
+        # in an enforced ordered chain.
+        v = node["then"] or {}
+        clauses = v.get("clauses") or []
+        if not clauses:
+            return "(empty then:)"
+        return (
+            "in this exact order: "
+            + " → THEN → ".join(
+                _describe(c, coords=coords) for c in clauses
+            )
+        )
     return join.join(_leaf_phrase(k, v, coords) for k, v in node.items())
 
 

openra_bench/rust_adapter.py

@@ -131,6 +131,12 @@ class EpisodeSignals:
     # waypoint_sequence's ordered-visit progress, keyed by sequence id).
     # Reset for free: EpisodeSignals is reconstructed each episode.
     seq_progress: dict = field(default_factory=dict)
+    # Per-episode latch for the `then:[A,B]` happened-before composite
+    # (clauses-satisfied-so-far index, keyed by the `then.id`). Lets a
+    # scenario require "scout → THEN commit counter" instead of
+    # ``all_of`` which is satisfied by any state where both happen to
+    # be true. See win_conditions._then.
+    then_progress: dict = field(default_factory=dict)
     # Per-episode tool-use accounting for the strict-toolban / procedural-
     # compliance family. tools_called counts each tool name the agent
     # invoked this episode; tool_violations counts how many of those calls

openra_bench/scenarios/win_conditions.py

@@ -202,7 +202,52 @@ _PREDICATES: dict[str, Callable[[WinContext, Any], bool]] = {
 }
 
 LEAF_KEYS = frozenset(_PREDICATES)
-COMPOSITE_KEYS = frozenset({"all_of", "any_of", "not"})
+COMPOSITE_KEYS = frozenset({"all_of", "any_of", "not", "then"})
+
+
+def _then(ctx: WinContext, v: Any) -> bool:
+    """Happened-before composite: each clause must become true IN ORDER
+    over the course of the episode. Stateful: the latch persists on
+    ``signals.then_progress[id]`` so an early clause that stopped being
+    true still counts (analogous to ``waypoint_sequence``).
+
+    YAML form::
+
+        then:
+          id: scout-then-counter            # stable key (per-episode)
+          clauses:
+            - {buildings_discovered_gte: 1}    # FIRST
+            - {unit_type_count_gte: {type: e3, n: 4}}  # THEN
+
+    Satisfied once every clause has been observed-true AT LEAST ONCE,
+    in order. Reaching a later clause without the earlier one being
+    latched does NOT advance — this is what makes "counter chosen
+    AFTER scout" enforceable (vs the stateless ``all_of`` which is
+    satisfied by any state where every clause happens to be true now).
+    """
+    if not isinstance(v, dict):
+        raise ValueError("then: expects a dict with id + clauses")
+    clauses = v.get("clauses") or []
+    if not clauses:
+        return False
+    store = getattr(ctx.signals, "then_progress", None)
+    if store is None or not isinstance(store, dict):
+        store = {}
+        try:
+            ctx.signals.then_progress = store  # type: ignore[attr-defined]
+        except Exception:  # frozen/stub signals in unit tests
+            pass
+    key = str(v.get("id", id(v)))
+    idx = int(store.get(key, 0))
+    # Advance through every consecutive clause currently satisfied
+    # (typically ≤1 per evaluation, like waypoint_sequence).
+    while idx < len(clauses):
+        if WinCondition(**clauses[idx]).evaluate(ctx):
+            idx += 1
+        else:
+            break
+    store[key] = idx
+    return idx >= len(clauses)
 
 
 class WinCondition(BaseModel):
@@ -241,6 +286,8 @@ class WinCondition(BaseModel):
             return any(WinCondition(**c).evaluate(ctx) for c in node["any_of"])
         if "not" in node:
             return not WinCondition(**node["not"]).evaluate(ctx)
+        if "then" in node:
+            return _then(ctx, node["then"])
         return all(_PREDICATES[k](ctx, v) for k, v in node.items())
 
 

tests/test_then_composite.py

@@ -0,0 +1,210 @@
+"""then:[A,B,…] happened-before composite predicate.
+
+Unblocks the reactive-replan / scout-then-counter / strict-ordered-
+sequence family: a scenario can require clauses to become true IN
+ORDER over the course of an episode, not merely all-of-now.
+
+Real-world anchor: PlanBench replanning, ALFWorld goal-conditional
+adaptation, PERT stage dependencies. The bench's existing predicates
+let you say "all of these must be true now" (`all_of`) and "any of
+these must be true now" (`any_of`); `then:` is the missing temporal
+operator: the clauses must have been observed-true in sequence.
+
+State: per-episode `signals.then_progress[id]` (an integer index of
+how many clauses have been observed-true so far), so a clause that
+stopped being true still counts. Identical pattern to
+`waypoint_sequence`'s `seq_progress` latch.
+"""
+
+from __future__ import annotations
+
+import types
+
+from openra_bench.scenarios.win_conditions import (
+    COMPOSITE_KEYS,
+    WinContext,
+    evaluate,
+)
+
+
+def _ctx(units_killed: int = 0, buildings_disc: int = 0,
+         own_units: int = 0):
+    sig = types.SimpleNamespace(
+        units_killed=units_killed,
+        enemy_buildings_seen_ids=set(range(buildings_disc)),
+        game_tick=0,
+        units_lost=0,
+        cash=0, resources=0, power_provided=0, power_drained=0,
+        own_building_types=set(), own_buildings=[],
+        enemies_seen_ids=set(),
+        explored_percent=0.0,
+        then_progress={},
+        seq_progress={},
+    )
+    return WinContext(
+        signals=sig,
+        render_state={"units_summary": [
+            {"id": i, "type": "e1", "cell_x": 0, "cell_y": 0}
+            for i in range(own_units)
+        ]},
+    )
+
+
+def test_then_is_a_composite_key():
+    """The new operator must register as a composite (not a leaf), so
+    the WinCondition validator accepts {then: …} alongside all_of /
+    any_of / not."""
+    assert "then" in COMPOSITE_KEYS
+
+
+def test_then_satisfied_when_clauses_observed_in_order():
+    """A → B in order ⇒ true. The clauses don't both need to be true
+    NOW; they just need to have been observed-true at some past
+    evaluation, in order."""
+    cond = {"then": {
+        "id": "scout-then-counter",
+        "clauses": [
+            {"buildings_discovered_gte": 1},  # A
+            {"units_killed_gte": 3},           # B
+        ],
+    }}
+    ctx = _ctx(units_killed=0, buildings_disc=0)
+    # Initially: neither clause true.
+    assert evaluate(cond, ctx) is False
+
+    # A becomes true: scouted 1 building.
+    ctx.signals.enemy_buildings_seen_ids = {1}
+    assert evaluate(cond, ctx) is False  # A latched, B not yet
+    assert ctx.signals.then_progress["scout-then-counter"] == 1
+
+    # A is no longer true (lost vision) — but the latch holds.
+    ctx.signals.enemy_buildings_seen_ids = set()
+    ctx.signals.units_killed = 3   # B now true
+    assert evaluate(cond, ctx) is True
+    assert ctx.signals.then_progress["scout-then-counter"] == 2
+
+
+def test_then_no_credit_for_b_alone_without_a():
+    """B true while A is still false ⇒ the chain does NOT advance.
+    The latch only counts clauses observed-true-in-order. Once A
+    finally becomes true on a later evaluation, the chain advances
+    through every consecutive currently-satisfied clause in one pass
+    (greedy advance, mirroring `waypoint_sequence`'s semantics). The
+    bench-relevant guarantee is that a policy which ONLY ever made B
+    true (never A) can never satisfy the chain — keeping the
+    happened-before signal honest."""
+    cond = {"then": {
+        "id": "ordered-x",
+        "clauses": [
+            {"buildings_discovered_gte": 1},  # A
+            {"units_killed_gte": 3},           # B
+        ],
+    }}
+    ctx = _ctx()
+    # B true, A false → no progress.
+    ctx.signals.units_killed = 5
+    assert evaluate(cond, ctx) is False
+    assert ctx.signals.then_progress["ordered-x"] == 0
+    # Many more evals with B-only must STILL not advance (no false
+    # credit for the late-A case).
+    for _ in range(20):
+        assert evaluate(cond, ctx) is False
+        assert ctx.signals.then_progress["ordered-x"] == 0
+
+
+def test_then_late_a_then_b_credits_both_clauses():
+    """Once A finally latches, the greedy advance picks up any
+    currently-satisfied later clauses in the same call. This matches
+    waypoint_sequence's semantics and is the right semantic: 'I
+    already had the counter ready; now that I've also scouted, the
+    chain is satisfied'."""
+    cond = {"then": {
+        "id": "late-a",
+        "clauses": [
+            {"buildings_discovered_gte": 1},
+            {"units_killed_gte": 3},
+        ],
+    }}
+    ctx = _ctx()
+    ctx.signals.units_killed = 5  # B pre-satisfied
+    assert evaluate(cond, ctx) is False  # but A blocks
+    ctx.signals.enemy_buildings_seen_ids = {1}  # A becomes true
+    assert evaluate(cond, ctx) is True  # chain completes
+    assert ctx.signals.then_progress["late-a"] == 2
+
+
+def test_then_three_clauses_strict_order():
+    """Three-stage chain: A → B → C. Each stage must latch before the
+    next can advance. Skipping is impossible by construction."""
+    cond = {"then": {
+        "id": "abc",
+        "clauses": [
+            {"buildings_discovered_gte": 1},
+            {"units_killed_gte": 2},
+            {"own_units_gte": 4},
+        ],
+    }}
+    ctx = _ctx()
+    # Skip straight to C: own_units=5 but no scout, no kills.
+    ctx.render_state["units_summary"] = [
+        {"id": i, "type": "e1", "cell_x": 0, "cell_y": 0} for i in range(5)
+    ]
+    assert evaluate(cond, ctx) is False
+    assert ctx.signals.then_progress["abc"] == 0
+
+    # Now satisfy A: scout 1 building.
+    ctx.signals.enemy_buildings_seen_ids = {1}
+    assert evaluate(cond, ctx) is False
+    # Stage advanced to 1, but B (kills) is still 0.
+    assert ctx.signals.then_progress["abc"] == 1
+
+    # Now B: kill 2.
+    ctx.signals.units_killed = 2
+    # On this evaluation, B advances (idx 1→2), and C is already true
+    # (5 own units >= 4) so C also advances (idx 2→3). Returns true.
+    assert evaluate(cond, ctx) is True
+    assert ctx.signals.then_progress["abc"] == 3
+
+
+def test_then_empty_clauses_returns_false():
+    """Authoring-hygiene: an empty or missing clauses list must not
+    accidentally satisfy the predicate (silent always-true would be a
+    no-cheat bar violation)."""
+    assert evaluate({"then": {"id": "empty", "clauses": []}}, _ctx()) is False
+
+
+def test_then_phrase_translation():
+    """The objective_brief must render `then` as a plain-language
+    ordered chain so the model knows the order matters."""
+    from openra_bench.game_knowledge import objective_brief
+
+    brief = objective_brief(
+        "description",
+        {"then": {
+            "id": "scout-then-counter",
+            "clauses": [
+                {"buildings_discovered_gte": 1},
+                {"units_killed_gte": 3},
+            ],
+        }},
+        None,
+        max_turns=30,
+    )
+    assert "in this exact order" in brief
+    assert "THEN" in brief
+    assert "spot ≥1 enemy buildings" in brief
+    assert "destroy ≥3 enemy units" in brief
+
+
+def test_then_id_isolation():
+    """Two `then` predicates with different ids must latch
+    independently — necessary for a pack that uses multiple ordered
+    chains (e.g. a win clause + a fail clause both with their own
+    sequencing)."""
+    a = {"then": {"id": "A", "clauses": [{"units_killed_gte": 1}]}}
+    b = {"then": {"id": "B", "clauses": [{"units_killed_gte": 5}]}}
+    ctx = _ctx(units_killed=1)
+    assert evaluate(a, ctx) is True
+    assert evaluate(b, ctx) is False
+    assert ctx.signals.then_progress["A"] == 1
+    assert ctx.signals.then_progress["B"] == 0