feat(scenario): proc-instruction-following-edge-case — conditional SOP (IFBench / BFCL V4 anchor)

Wave-6 IFBench / BFCL V4 negative-instruction adherence pack:
selective-action discipline. The brief carries an explicit
conditional rule — 'Move the JEEP units to (90,20). Do NOT move the
TANK units.' — and the bench measures whether the agent honours both
halves.

Win predicate uses the type-filtered region predicate
`units_of_type_in_region_gte` (Wave-2 / Group-N) to check BOTH:
1. ≥3 jeeps in goal region around (90,20).
2. ≥3 tanks STILL in start region around (8,20).

Fail mirrors clause 2 as a `not` clause so a single tank dragged
out of the start cluster trips IMMEDIATE fail — the IFBench
instruction-precision teeth.

Tiers (one new variable per step):
easy = bare positive instruction only (no negative teeth — calibration).
medium = +negative teeth (must-not-move tanks anchored at (8,20)).
hard = +2 agent spawn_point groups (jeeps NW vs SW), tanks
duplicated at (8..10, 20) across BOTH groups so the
must-not-move region is identical across seeds.

Scripted validation (4 levels × 4 seeds each):
stall → LOSS (clock; after_ticks 4501 within max_turns 55).
move-all → WIN on easy (no teeth); LOSS turn 1 on medium/hard
(negative-instruction teeth fire when tank leaves cluster).
jeeps-only → WIN (intended capability play).

Registered in tests/test_hard_tier.py::UPGRADED (≥2 jeep spawn
groups, tanks anchored at common region across seeds).

Real-world anchor: IFBench conditional/edge-case instructions; BFCL
V4 negative-instruction compliance; conditional SOP; selective-action
discipline (mixed fleet, act on subset, leave the rest).

openra_bench/scenarios/packs/proc-instruction-following-edge-case.yaml

@@ -0,0 +1,245 @@
+# proc-instruction-following-edge-case — IFBench conditional / negative-
+# instruction adherence (selective-action discipline).
+#
+# The mission brief carries an EXPLICIT CONDITIONAL RULE — "do X, but
+# NOT Y" — and the bench measures whether the agent honours the
+# carve-out. The intended capability is *selective action*: identify
+# the units the instruction targets, act on those, and LEAVE THE OTHER
+# UNITS WHERE THEY STARTED. Touching the prohibited group at all
+# (even moving them a single cell) is a procedural violation and
+# fails the mission outright, regardless of what the jeeps achieve.
+#
+# Concretely: the agent owns a mixed column — JEEPS and MEDIUM TANKS
+# (2tnk) — at the west edge (x=8, y∈[18..22]). The brief says:
+#   "Move the JEEP units to (90, 20). Do NOT move the TANK units."
+# The win predicate uses the type-filtered region predicate
+# `units_of_type_in_region_gte` to check BOTH halves of the
+# instruction simultaneously:
+#
+#   1. ≥3 JEEPS in region around (90, 20) — the positive instruction.
+#   2. ≥3 TANKS still in region around (8, 20) — the negative
+#      instruction (the tanks must remain at their start).
+#
+# Both clauses must hold at the same observation tick — a "move tanks
+# then later return them" play is structurally hard within the budget
+# and is the wrong skill anyway (the brief forbade the move). The
+# failure side mirrors clause 2 as a `not units_of_type_in_region_gte`
+# clause so a single tank dragged out of the start cluster trips fail
+# IMMEDIATELY (no need to wait for the deadline). This is the
+# IFBench-style "instruction-precision" teeth: violation is detected
+# the moment the agent acts on the prohibited group.
+#
+# Failure modes (all real, reachable LOSSES; no draw degeneracy):
+#   • STALL (only `observe`): jeeps never reach (90,20); the
+#     within_ticks deadline fires → after_ticks fail.
+#   • MOVE-ALL (the model treats the order as "move everything east"
+#     and ignores the carve-out): the tanks leave the start cluster
+#     within a few turns → `not units_of_type_in_region_gte 2tnk` fail
+#     fires as soon as <3 tanks remain near (8,20). Even if the jeeps
+#     reach (90,20), the run is forfeit — the brief said "do NOT move
+#     the tanks" and the agent moved them.
+#   • TANKS-ONLY (the model fixates on the wrong half — only
+#     tanks moved): the tanks leave the start AND the jeeps never
+#     reach the goal → both fail clauses fire.
+#   • INTENDED (move JEEPS east to (90,20), issue NO order to the
+#     tanks): jeeps arrive on time, tanks remain at start → WIN.
+#
+# Real-world anchor: IFBench / instruction-precision benchmarks
+# ("output only X, do not include Y"); BFCL V4 negative-instruction
+# compliance ("call this tool but DO NOT call that one"); conditional
+# SOP ("perform action A on units of class C, leave class D
+# untouched"); robotic mixed-asset selective-task execution.
+#
+# Distinct from:
+#   • proc-no-attack-passive-only (B0): forbids a tool entirely
+#     (attack_unit / attack_move) — the carve-out is on TOOLS, not on
+#     a subset of UNITS. Here the agent IS allowed `move_units`; the
+#     constraint is the SET OF UNITS that may receive that command.
+#   • proc-strict-toolban-under-pressure: also a tool-level ban.
+#   • coord-squad-handoff: positive sequenced relay (both squads must
+#     move). Here exactly one squad must move and the other must NOT.
+#
+# Tick budget note: ~90 ticks/turn (tick ≈ 93 + 90·(turn-1)). With
+# max_turns=55 the reachable max tick is 4953, so the fail
+# `after_ticks: 4501` bites well within the budget (no draw). The
+# intended jeep convoy travels ~82 cells; jeep speed is ~12 cells/turn
+# so it arrives in ~7-10 turns (~tick 700-1000), well under the
+# deadline.
+#
+# Hard-tier curation: hard defines 2 agent spawn_point groups for the
+# JEEPS (NW vs SW staging — y=8 vs y=32), round-robined by seed; the
+# TANKS are duplicated at the SAME start cell (8,20) across BOTH
+# spawn groups (the must-not-move group is anchored to ONE region so
+# the negative-instruction predicate is well-defined). This pack is
+# in `tests/test_hard_tier.py::UPGRADED`.
+
+meta:
+  id: proc-instruction-following-edge-case
+  title: 'Selective Action — Move the Jeeps, Do NOT Move the Tanks'
+  capability: action
+  real_world_meaning: >
+    Conditional standard-operating-procedure: the order has both a
+    positive and a negative clause ("do X to units of class C; do NOT
+    do anything to units of class D"). The operator's skill is to
+    identify the targeted subset, act on it, and leave the rest
+    untouched. Spraying the same action over the whole fleet is the
+    classic failure mode — and is what the IFBench / BFCL V4
+    negative-instruction families measure.
+  robotics_analogue: >
+    Mixed-asset fleet with a per-class action allowlist for this
+    mission: forklifts may move pallets; the autonomous floor
+    scrubber must stay docked. The fleet controller must NOT issue
+    a move command to the scrubber even if the scene is messy and
+    the scrubber would naively be the "obvious next agent" to act.
+  benchmark_anchor:
+    - "IFBench conditional / edge-case instruction"
+    - "BFCL V4 negative instruction compliance"
+    - "conditional SOP compliance"
+    - "selective-action discipline"
+  author: "openra-bench"
+
+base_map: rush-hour-arena
+
+# Shared engine fields. The agent's tools are the bare action set —
+# move/attack/observe/stop — and the instruction's teeth are in the
+# WIN PREDICATE (must keep the tanks at start), not a forbidden-tools
+# list. This is deliberate: the IFBench / BFCL V4 anchor is
+# "everything is technically *allowed*, but the brief forbids it" —
+# the bench measures whether the agent self-restrains.
+base:
+  agent: {faction: allies, cash: 0}
+  enemy: {faction: soviet, cash: 0}
+  tools: [move_units, attack_unit, observe, stop]
+  planning: true
+  termination: {max_ticks: 6000}
+  actors: []   # every level supplies its own actor list via overrides.
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # The bare selective-action skill: ONLY the positive clause is
+  # tested. 3 jeeps + 3 tanks at the west edge; jeeps must reach
+  # (90,20); no negative-clause teeth. A naive "move everything"
+  # policy CAN win on easy — easy is the calibration tier (the
+  # capability is the difficulty step on medium).
+  easy:
+    description: >
+      Move ALL THREE JEEP units to the region around (90, 20) within
+      radius 6, before tick 4500. The TANK units may be ignored
+      (easy tier: no negative-instruction teeth). Stalling and
+      timeout LOSE.
+    overrides:
+      actors:
+        # 3 jeeps + 3 medium tanks at the west edge.
+        - {type: jeep, owner: agent, position: [8, 18]}
+        - {type: jeep, owner: agent, position: [8, 19]}
+        - {type: jeep, owner: agent, position: [8, 21]}
+        - {type: 2tnk, owner: agent, position: [8, 20]}
+        - {type: 2tnk, owner: agent, position: [9, 20]}
+        - {type: 2tnk, owner: agent, position: [10, 20]}
+    win_condition:
+      all_of:
+        - {units_of_type_in_region_gte:
+            {type: jeep, x: 90, y: 20, radius: 6, n: 3}}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {own_units_gte: 1}}
+    max_turns: 55
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 controlled variable: the NEGATIVE INSTRUCTION teeth come in.
+  # The brief now explicitly forbids moving the tanks. The win
+  # condition adds a second clause ("≥3 tanks still at start") and
+  # the fail condition adds the symmetric `not` clause so a single
+  # tank dragged out of the start cluster trips an IMMEDIATE fail
+  # (no need to wait for the deadline). This is the IFBench /
+  # BFCL V4 anchor cell — measuring whether the model honours the
+  # carve-out under no other pressure than the brief itself.
+  medium:
+    description: >
+      Move ALL THREE JEEP units to the region around (90, 20) within
+      radius 6, before tick 4500. Do NOT move the TANK units — all
+      three TANK (2tnk) units must remain in the start region around
+      (8, 20) within radius 6. Issuing ANY move order to a tank
+      breaks the tank-at-start clause as soon as a tank leaves the
+      cluster and FAILS the mission immediately. Stalling, moving a
+      tank, force-loss, and timeout all LOSE.
+    overrides:
+      actors:
+        - {type: jeep, owner: agent, position: [8, 18]}
+        - {type: jeep, owner: agent, position: [8, 19]}
+        - {type: jeep, owner: agent, position: [8, 21]}
+        - {type: 2tnk, owner: agent, position: [8, 20]}
+        - {type: 2tnk, owner: agent, position: [9, 20]}
+        - {type: 2tnk, owner: agent, position: [10, 20]}
+    win_condition:
+      all_of:
+        - {units_of_type_in_region_gte:
+            {type: jeep, x: 90, y: 20, radius: 6, n: 3}}
+        - {units_of_type_in_region_gte:
+            {type: 2tnk, x: 8, y: 20, radius: 6, n: 3}}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {own_units_gte: 1}}
+        - {not: {units_of_type_in_region_gte:
+            {type: 2tnk, x: 8, y: 20, radius: 6, n: 3}}}
+    max_turns: 55
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 controlled variable vs medium: the JEEP starting corner is
+  # seed-randomised (NW staging y=8 vs SW staging y=32 — 2 agent
+  # spawn_point groups, round-robined by seed). The TANKS always
+  # start clustered at (8..10, 20) — the must-not-move group is
+  # ANCHORED to one region so the negative-instruction predicate is
+  # well-defined and identical across seeds. The selective-action
+  # skill is unchanged; the spawn variation prevents memorised
+  # opening generalisation (test_hard_tier.py::UPGRADED contract).
+  hard:
+    description: >
+      Move ALL THREE JEEP units to the region around (90, 20) within
+      radius 6, before tick 4500 — your jeeps may start at the
+      NORTHWEST (y≈8) OR SOUTHWEST (y≈32) corner depending on the
+      seed; route accordingly. Do NOT move the TANK units — all
+      three TANK (2tnk) units must remain in the start region around
+      (8, 20) within radius 6. Issuing any move order to a tank
+      breaks the tank-at-start clause as soon as a tank leaves the
+      cluster and FAILS the mission immediately. Stalling, moving a
+      tank, force-loss, and timeout all LOSE.
+    overrides:
+      actors:
+        # spawn_point 0 — NW jeep staging (y≈8).
+        - {type: jeep, owner: agent, position: [8, 7],  spawn_point: 0}
+        - {type: jeep, owner: agent, position: [8, 8],  spawn_point: 0}
+        - {type: jeep, owner: agent, position: [8, 9],  spawn_point: 0}
+        # spawn_point 1 — SW jeep staging (y≈32).
+        - {type: jeep, owner: agent, position: [8, 31], spawn_point: 1}
+        - {type: jeep, owner: agent, position: [8, 32], spawn_point: 1}
+        - {type: jeep, owner: agent, position: [8, 33], spawn_point: 1}
+        # TANKS are anchored at (8..10, 20) in BOTH spawn groups
+        # (the must-not-move region is identical across seeds).
+        # CLAUDE.md: if ANY agent actor declares spawn_point, every
+        # agent actor WITHOUT spawn_point is filtered OUT — so the
+        # tanks are duplicated across both groups at identical coords.
+        - {type: 2tnk, owner: agent, position: [8, 20],  spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [9, 20],  spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [10, 20], spawn_point: 0}
+        - {type: 2tnk, owner: agent, position: [8, 20],  spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [9, 20],  spawn_point: 1}
+        - {type: 2tnk, owner: agent, position: [10, 20], spawn_point: 1}
+    win_condition:
+      all_of:
+        - {units_of_type_in_region_gte:
+            {type: jeep, x: 90, y: 20, radius: 6, n: 3}}
+        - {units_of_type_in_region_gte:
+            {type: 2tnk, x: 8, y: 20, radius: 6, n: 3}}
+        - {within_ticks: 4500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 4501}
+        - {not: {own_units_gte: 1}}
+        - {not: {units_of_type_in_region_gte:
+            {type: 2tnk, x: 8, y: 20, radius: 6, n: 3}}}
+    max_turns: 55

tests/test_hard_tier.py

@@ -359,6 +359,18 @@ UPGRADED = [
     # sit on the spawn-matched row so throughput is symmetric per
     # spawn, but a memorised opening cannot generalise across seeds.
     "econ-cash-reserve-management",
+    # Wave-6 IFBench / BFCL V4 negative-instruction seed — conditional
+    # SOP / selective-action discipline anchor. The brief carries an
+    # explicit carve-out ("move the JEEPS to (90,20); do NOT move the
+    # TANKS"); win checks BOTH halves via type-filtered region
+    # (`units_of_type_in_region_gte`). Hard tier defines 2 agent
+    # spawn_point groups (NW jeep staging y≈8 / SW jeep staging y≈32)
+    # round-robined by seed; the TANKS are duplicated at (8..10, 20)
+    # across BOTH groups so the must-not-move region is identical and
+    # well-defined across seeds. The spawn variation prevents memorised
+    # opening generalisation without diluting the selective-action
+    # signal.
+    "proc-instruction-following-edge-case",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation

tests/test_proc_instruction_following_edge_case.py

@@ -0,0 +1,290 @@
+"""proc-instruction-following-edge-case: IFBench / BFCL V4 negative
+instruction adherence (selective-action discipline).
+
+The brief carries an EXPLICIT CONDITIONAL RULE — "move the JEEP units
+to (90,20); do NOT move the TANK units." The bench measures whether
+the agent honours BOTH halves of the instruction. The win predicate
+checks:
+
+  1. ≥3 jeeps in the goal region around (90,20).
+  2. ≥3 tanks STILL in the start region around (8,20).
+
+The fail predicate mirrors clause 2 as a `not` clause so a single tank
+dragged out of the start cluster trips an IMMEDIATE loss (no need to
+wait for the deadline) — that is the IFBench instruction-precision
+teeth.
+
+The bar (per CLAUDE.md) must hold on every level × every hard seed:
+
+  - STALL          -> LOSS (clock)
+  - MOVE-ALL       -> WIN on easy (no negative teeth), LOSS on
+                       medium/hard (touching the tanks fails fast)
+  - JEEPS-ONLY     -> WIN  (the intended capability play)
+"""
+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
+from openra_bench.scenarios.win_conditions import WinContext, evaluate
+
+PACK = (
+    Path(__file__).parent.parent
+    / "openra_bench"
+    / "scenarios"
+    / "packs"
+    / "proc-instruction-following-edge-case.yaml"
+)
+
+
+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"]
+
+
+# ── A. STRUCTURAL: predicate / clauses / deadlines wired correctly ───
+
+def test_easy_has_positive_clause_only():
+    """Easy is the calibration tier — only the positive instruction
+    (jeeps reach (90,20)) is in the win predicate. Moving the tanks
+    is harmless on easy (the negative teeth come in on medium)."""
+    c = compile_level(load_pack(PACK), "easy")
+    win = _win_clauses(c)
+    type_clauses = [cl for cl in win if "units_of_type_in_region_gte" in cl]
+    types = [cl["units_of_type_in_region_gte"]["type"] for cl in type_clauses]
+    assert types == ["jeep"], f"easy: expected only the jeep clause, got {types}"
+
+
+@pytest.mark.parametrize("level", ["medium", "hard"])
+def test_medium_and_hard_enforce_both_halves_of_the_instruction(level):
+    """Medium and hard MUST encode BOTH:
+      - positive: ≥3 jeeps at goal (90,20) and
+      - negative: ≥3 tanks still at start (8,20).
+    Anything less and the bench fails to enforce the carve-out."""
+    c = compile_level(load_pack(PACK), level)
+    win = _win_clauses(c)
+    type_clauses = [cl for cl in win if "units_of_type_in_region_gte" in cl]
+    by_type = {cl["units_of_type_in_region_gte"]["type"]: cl["units_of_type_in_region_gte"]
+               for cl in type_clauses}
+    assert "jeep" in by_type, f"{level}: missing positive jeep clause"
+    assert by_type["jeep"]["x"] == 90 and by_type["jeep"]["y"] == 20, (
+        f"{level}: jeep goal must be (90,20), got "
+        f"({by_type['jeep']['x']},{by_type['jeep']['y']})"
+    )
+    assert by_type["jeep"]["n"] >= 3, f"{level}: jeep clause needs n>=3"
+    assert "2tnk" in by_type, f"{level}: missing negative tanks-at-start clause"
+    assert by_type["2tnk"]["x"] == 8 and by_type["2tnk"]["y"] == 20, (
+        f"{level}: tanks-at-start must be (8,20), got "
+        f"({by_type['2tnk']['x']},{by_type['2tnk']['y']})"
+    )
+    assert by_type["2tnk"]["n"] >= 3, f"{level}: tanks clause needs n>=3"
+
+
+@pytest.mark.parametrize("level", ["medium", "hard"])
+def test_medium_and_hard_have_immediate_violation_fail_clause(level):
+    """The fail predicate must include a `not units_of_type_in_region
+    _gte 2tnk` clause so moving a tank trips fail IMMEDIATELY (no
+    wait for deadline)."""
+    c = compile_level(load_pack(PACK), level)
+    fails = _fail_clauses(c)
+    not_clauses = [cl["not"] for cl in fails if "not" in cl]
+    has_immediate = any(
+        "units_of_type_in_region_gte" in nc
+        and nc["units_of_type_in_region_gte"]["type"] == "2tnk"
+        for nc in not_clauses
+    )
+    assert has_immediate, (
+        f"{level}: fail_condition must include `not units_of_type_in"
+        f"_region_gte 2tnk` so moving a tank trips IMMEDIATE fail"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_level_has_binding_deadline_and_reachable_loss(level):
+    c = compile_level(load_pack(PACK), level)
+    win = _win_clauses(c)
+    wt = [cl["within_ticks"] for cl in win if "within_ticks" in cl]
+    assert wt, f"{level}: missing within_ticks deadline"
+    # The deadline must bite within max_turns (engine ~90 ticks/turn).
+    assert wt[0] < 93 + 90 * (c.max_turns - 1), (
+        f"{level}: within_ticks {wt[0]} unreachable inside max_turns "
+        f"{c.max_turns} (would draw on timeout)"
+    )
+    fail = _fail_clauses(c)
+    at = [cl["after_ticks"] for cl in fail if "after_ticks" in cl]
+    assert at, f"{level}: missing after_ticks in fail_condition"
+    assert at[0] <= 93 + 90 * (c.max_turns - 1), (
+        f"{level}: after_ticks {at[0]} unreachable inside max_turns "
+        f"{c.max_turns} (would draw on timeout)"
+    )
+
+
+def test_hard_has_two_spawn_groups_for_jeeps():
+    """Hard tier must have ≥2 jeep spawn_point groups (the
+    test_hard_tier.py::UPGRADED contract). Tanks are anchored at
+    (8..10, 20) across BOTH groups so the negative-instruction
+    predicate is identical and well-defined across seeds."""
+    c = compile_level(load_pack(PACK), "hard")
+    agent_actors = [a for a in c.scenario.actors if a.owner == "agent"]
+    sp = {(a.spawn_point if a.spawn_point is not None else 0) for a in agent_actors}
+    assert len(sp) >= 2, (
+        f"hard: must define ≥2 agent spawn_point groups; got {sorted(sp)}"
+    )
+    # Tanks must be duplicated in EVERY spawn group at the same coords
+    # so the negative-instruction predicate is identical across seeds.
+    tank_cells_per_group = {}
+    for a in agent_actors:
+        if a.type == "2tnk":
+            g = a.spawn_point if a.spawn_point is not None else 0
+            tank_cells_per_group.setdefault(g, set()).add(tuple(a.position))
+    assert len(tank_cells_per_group) >= 2, (
+        "hard: tanks must be present in BOTH spawn groups"
+    )
+    cell_sets = list(tank_cells_per_group.values())
+    assert all(s == cell_sets[0] for s in cell_sets), (
+        f"hard: tanks must occupy the SAME cells across spawn groups; "
+        f"got {tank_cells_per_group}"
+    )
+
+
+# ── B. PREDICATE UNIT TEST: tank-at-start negative clause semantics ──
+
+class _Sig:
+    def __init__(self):
+        self.game_tick = 100
+        self.then_progress: dict = {}
+
+
+def _ctx(units):
+    return WinContext(signals=_Sig(), render_state={"units_summary": units})
+
+
+def test_tanks_still_at_start_is_satisfied_by_unmoved_tanks():
+    spec = {"units_of_type_in_region_gte":
+        {"type": "2tnk", "x": 8, "y": 20, "radius": 6, "n": 3}}
+    tanks = [
+        {"type": "2tnk", "cell_x": 8, "cell_y": 20, "id": "1"},
+        {"type": "2tnk", "cell_x": 9, "cell_y": 20, "id": "2"},
+        {"type": "2tnk", "cell_x": 10, "cell_y": 20, "id": "3"},
+    ]
+    assert evaluate(spec, _ctx(tanks)) is True
+
+
+def test_tanks_still_at_start_breaks_the_moment_a_tank_leaves_cluster():
+    """The negative-instruction teeth: as soon as <3 tanks remain in
+    the start region, the clause becomes False — so the fail-side
+    `not` clause fires immediately."""
+    spec = {"units_of_type_in_region_gte":
+        {"type": "2tnk", "x": 8, "y": 20, "radius": 6, "n": 3}}
+    # Two tanks still at start, one dragged east — predicate is False.
+    moved = [
+        {"type": "2tnk", "cell_x": 8, "cell_y": 20, "id": "1"},
+        {"type": "2tnk", "cell_x": 9, "cell_y": 20, "id": "2"},
+        {"type": "2tnk", "cell_x": 40, "cell_y": 20, "id": "3"},
+    ]
+    assert evaluate(spec, _ctx(moved)) is False
+    # And the corresponding `not` (which IS the fail clause) is True.
+    not_spec = {"not": spec}
+    assert evaluate(not_spec, _ctx(moved)) is True
+
+
+def test_jeeps_do_not_satisfy_the_tanks_at_start_clause():
+    """Type-filter teeth: a jeep parked at the tanks' start does NOT
+    count toward the 2tnk-at-start clause (the carve-out is on UNIT
+    TYPE, not on cell occupancy)."""
+    spec = {"units_of_type_in_region_gte":
+        {"type": "2tnk", "x": 8, "y": 20, "radius": 6, "n": 3}}
+    jeeps = [
+        {"type": "jeep", "cell_x": 8, "cell_y": 20, "id": "j1"},
+        {"type": "jeep", "cell_x": 9, "cell_y": 20, "id": "j2"},
+        {"type": "jeep", "cell_x": 10, "cell_y": 20, "id": "j3"},
+    ]
+    assert evaluate(spec, _ctx(jeeps)) is False
+
+
+# ── C. SOLVENCY / NO-CHEAT: scripted policies on the live engine ─────
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+from openra_bench.eval_core import run_level  # noqa: E402
+
+
+def _split(rs):
+    us = rs.get("units_summary", []) or []
+    jeeps = [str(u["id"]) for u in us if u.get("type") == "jeep"]
+    tanks = [str(u["id"]) for u in us if u.get("type") == "2tnk"]
+    return jeeps, tanks
+
+
+def _stall(rs, C):
+    return [C.observe()]
+
+
+def _move_all(rs, C):
+    """The classic IFBench failure mode: model treats the brief as
+    'move everything east' and ignores the carve-out. On medium and
+    hard the negative-instruction teeth fire the moment a tank
+    leaves the start cluster."""
+    jeeps, tanks = _split(rs)
+    cmds = []
+    if jeeps:
+        cmds.append(C.move_units(jeeps, 90, 20))
+    if tanks:
+        cmds.append(C.move_units(tanks, 90, 20))
+    return cmds or [C.observe()]
+
+
+def _jeeps_only(rs, C):
+    """The intended capability play: move ONLY the jeeps to the goal,
+    issue NO order to the tanks. The tanks stay at their start and
+    both halves of the instruction are honoured."""
+    jeeps, _ = _split(rs)
+    if not jeeps:
+        return [C.observe()]
+    return [C.move_units(jeeps, 90, 20)]
+
+
+# Seeds 1..4 = held-out seed contract from CLAUDE.md.
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_stall_loses(level, seed):
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _stall, seed=seed)
+    assert res.outcome == "loss", (
+        f"{level} seed{seed}: stall must LOSE on timeout, got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("level", ["medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_move_all_loses_when_negative_teeth_present(level, seed):
+    """On medium/hard the brief forbids moving the tanks; spraying
+    move-east across both squads must LOSE the moment a tank leaves
+    the start cluster."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _move_all, seed=seed)
+    assert res.outcome == "loss", (
+        f"{level} seed{seed}: move-all (touched the tanks) must LOSE, "
+        f"got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_jeeps_only_wins(level, seed):
+    """The intended selective-action policy must WIN on every level
+    × every seed."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _jeeps_only, seed=seed)
+    assert res.outcome == "win", (
+        f"{level} seed{seed}: jeeps-only (intended play) must WIN, "
+        f"got {res.outcome}"
+    )