feat(scenario): proc-tool-use-multi-distractor — multi-tool clutter resistance (τ²-bench / BFCL V4 anchor)

Wave-6 multi-distractor tool-relevance discipline pack. The agent is
handed a CLUTTERED 9-tool API surface (move_units, attack_unit,
attack_move, build, place_building, harvest, set_stance,
set_rally_point, observe) where only TWO tools are on the critical
path (move_units + observe). The other seven are MAXIMALLY SALIENT
distractors: a visible off-path weak-enemy garrison invites
attack_unit / attack_move, cash + pre-placed base invites build /
place_building, no-producer / no-harvester tools (set_rally_point,
harvest, set_stance) look generally useful but do nothing for THIS
goal.

Discriminator is OUTCOME-graded (reach + zero loss + within_ticks),
NOT tool-name graded — no forbidden_tools. The off-path enemies
are stance:0 (HoldFire) so they never pursue a clean column; the
cost of invoking a distractor tool is the TURNS BURNED ordering it
(each command also replaces the units' active move order so the
column never makes monotonic progress) while the within_ticks clock
keeps ticking. This is the τ²-bench multi-distractor / BFCL V4
cluttered-API setting: select the relevant subset of a large API
on your own, with no instruction telling you which to skip.

Distinct from sibling strict-toolban-fidelity-under-pressure (B3),
which uses a single forbidden_tools binary signal. This pack uses
NO forbidden_tools — pure outcome-graded relevance discipline.

Tiering:
easy : fewer distractors (1 off-path rifle), generous budget
(within_ticks 2000 / max_turns 25). Intended direct
policy wins in ~9 turns ≈ tick 813.
medium : full distractor palette (3-stack off-path garrison),
tighter budget (within_ticks 1500 / max_turns 22).
hard : + time-pressure central sentry stack at (60,18..22)
denying the direct y=20 lane, + TWO seed-driven
spawn_point groups (NORTH lane y=4..6 / SOUTH lane
y=34..36) round-robined by seed. Listed UPGRADED.

Validation (scripted, no network): intended movement-only policy
WINS every level/seed (1..4); stall (only observe) and use-
multiple-distractors (set_stance + attack_move + build + harvest
+ set_rally_point every turn) both LOSE every level/seed via the
within_ticks deadline.

meta.benchmark_anchor:
- τ²-bench multi-distractor handling
- BFCL V4 cluttered-API relevance
- IFBench distraction resistance
- junior-operator discipline test

Smoke (together / Qwen3.6-Plus, medium seed 1): loss, composite
0.2659 (model failed to ignore distractors — valid discrimination).

openra_bench/scenarios/packs/proc-tool-use-multi-distractor.yaml

@@ -0,0 +1,375 @@
+# proc-tool-use-multi-distractor — Wave-6 multi-distractor tool-relevance
+# discipline (τ²-bench multi-distractor / BFCL V4 cluttered-API anchor).
+#
+# CAPABILITY (action): the agent is handed a CLUTTERED tool surface — 9
+# tools, including several that are MAXIMALLY SALIENT (a visible weak
+# enemy that invites attack_unit; cash on hand and a pre-placed base
+# that invite build/place_building; harvesters absent but `harvest` is
+# present; no producers but `set_rally_point` is present; `set_stance`
+# / `attack_move` likewise tempt). Only TWO tools are actually needed
+# to win: `move_units` (drive the column east) and `observe` (read
+# state). The discipline test is whether the model can IGNORE the
+# multiple irrelevant tools and use only the relevant ones.
+#
+# Distinct from sibling `strict-toolban-fidelity-under-pressure` (B3):
+#   B3:   ONE forbidden tool (attack), procedural BINARY signal —
+#         tool_violations_gte:1 instantly fails.
+#   This: NO forbidden tools at all. Every tool is "allowed" in the
+#         allowlist sense — but invoking the irrelevant ones either
+#         (a) interrupts the units' move order so they stop progressing,
+#         (b) lures units off-course into a fight that costs casualties,
+#         or (c) burns the model's turn budget on no-ops while the
+#         within_ticks clock keeps ticking. The bench grades OUTCOME
+#         (reach + no losses + on time), not tool-name compliance —
+#         which IS the τ²-bench multi-distractor / BFCL V4 cluttered-
+#         API setting (the model must select the RELEVANT subset of a
+#         large API on its own; no instruction tells it which to skip).
+#
+# Why this cell exists in the Wave-6 taxonomy:
+#   - Real-world: τ²-bench's multi-distractor handling (a function-
+#     calling agent given a large toolset where most options are
+#     irrelevant to the current task); BFCL V4's cluttered-API
+#     relevance test (cherry-pick the right tool from a long list).
+#   - Robotics: a teleop operator panel exposing dozens of buttons;
+#     only two are on the critical path for THIS mission. A junior
+#     operator who reaches for every salient button wastes the
+#     window or causes collateral.
+#
+# Win  : reach_region(110,20,r=6) AND units_lost_lte:0 AND within_ticks
+# Fail : after_ticks (deadline) OR units_lost (any casualty)
+#
+# Failure modes (all real, reachable LOSSES; no draw degeneracy):
+#   • Stall (only observe): never moves; deadline LOSS via after_ticks.
+#   • Use-multiple-distractors (issue build / set_stance / attack_unit /
+#     attack_move / set_rally_point / harvest commands TO the agent's
+#     units every turn): each non-move command REPLACES the units'
+#     active move order so the column oscillates / stops, AND the
+#     attack_unit / attack_move calls lure the column into the off-
+#     path weak-enemy garrison where the garrison's return fire
+#     ticks a unit down → units_lost LOSS (or deadline LOSS).
+#   • Intended-direct (movement-only east to (110,20), ignore every
+#     other tool): the column arrives before the deadline with all
+#     units intact → WIN.
+#
+# Engine-footgun notes (re-asserted on every level):
+#   • ~90 ticks per decision turn ⇒ tick ≤ 93 + 90·(max_turns-1).
+#     Every `within_ticks` / `after_ticks` below is strictly under
+#     that threshold so the deadline genuinely BITES.
+#   • A persistent unarmed enemy `fact` at (118,20) keeps the
+#     episode alive past any enemy-elimination engine auto-`done`
+#     (CLAUDE.md engine fact #5) — so the win/fail evaluator reads
+#     reach_region + within_ticks instead of degenerating to DRAW.
+#   • Agent jeeps are stance:0 (HoldFire) so `move_units` en-route
+#     auto-fire is suppressed (CLAUDE.md engine fact). The off-path
+#     "weak enemy" garrison only fires when the agent CHOOSES to
+#     send units into its range (attack_unit / attack_move).
+#   • This pack does NOT use `forbidden_tools` — the test is
+#     outcome-graded, not tool-name graded. Every tool the model
+#     might pick is in `tools:`. The bench's tool_violations counter
+#     stays at 0 for every policy; the failure signal is reach /
+#     casualty / clock.
+#
+# Hard-tier curation: this pack IS in
+# tests/test_hard_tier.py::UPGRADED — hard adds two agent spawn_point
+# groups (NORTH lane y=10..12 / SOUTH lane y=28..30) so the route
+# geometry differs per seed and a memorised "drive east on y=20"
+# opening cannot generalise. Hard additionally adds time-pressure
+# (a `patrol` enemy bot oscillating across the central corridor) —
+# the patrol is itself a DISTRACTOR (the model is tempted to
+# attack_unit it) AND a real threat to a y=20 column, reinforcing
+# the spawn-vary controlled axis.
+
+meta:
+  id: proc-tool-use-multi-distractor
+  title: 'Cluttered Tool Surface — Ignore the Distractor Tools and Just Move'
+  capability: action
+  real_world_meaning: >
+    The agent receives a CLUTTERED toolset (9 tools) where only TWO
+    are on the critical path for the current task (move + observe).
+    The other seven are MAXIMALLY SALIENT distractors: a visible
+    weak enemy invites `attack_unit`; cash on hand and a pre-placed
+    base invite `build` / `place_building`; `harvest` / `set_rally_
+    point` / `set_stance` / `attack_move` look generally useful but
+    do nothing for THIS goal. The discipline is to recognise which
+    subset of a large API is actually relevant and ignore the rest —
+    every off-path tool call either interrupts the unit's move
+    order, lures units into a costly engagement, or burns the
+    model's turn budget while the within_ticks clock keeps ticking.
+  robotics_analogue: >
+    A teleoperation panel with dozens of buttons (manipulator,
+    nav, gripper, vision, comms, logging…) but only two are on
+    the critical path for THIS mission. A disciplined operator
+    runs the two-button procedure; a junior operator who reaches
+    for every salient button wastes the window or causes
+    collateral damage. The skill is API/relevance discrimination
+    under no explicit "don't touch X" instruction.
+  benchmark_anchor:
+    - "τ²-bench multi-distractor handling"
+    - "BFCL V4 cluttered-API relevance"
+    - "IFBench distraction resistance"
+    - "junior-operator discipline test"
+  author: "openra-bench"
+
+base_map: rush-hour-arena
+
+# Shared engine fields. The tools allowlist is the FULL 9-tool
+# cluttered API — no forbidden_tools. The agent must self-select
+# the relevant subset (move_units + observe). Generous starting
+# cash and a pre-placed agent base make `build` / `place_building`
+# fully usable distractors (not gated out by tech-tree errors).
+base:
+  agent: {faction: allies, cash: 0}
+  enemy: {faction: soviet, cash: 0}
+  # Full 9-tool API surface. Every tool the spec lists is present in
+  # `tools:`; none is in `forbidden_tools`. The discipline test is
+  # outcome-graded — irrelevant tool use shows up as missed deadline
+  # or unit loss, NOT as a tool_violations counter increment.
+  tools:
+    - move_units
+    - attack_unit
+    - attack_move
+    - build
+    - place_building
+    - harvest
+    - set_stance
+    - set_rally_point
+    - observe
+  planning: true
+  termination: {max_ticks: 6000}
+  actors:
+    # 4 jeep scouts at the west edge, tight column on y=20 (overridden
+    # per level / spawn group below). Jeeps are stance:0 (HoldFire)
+    # so the move_units en-route auto-fire engine quirk doesn't
+    # accidentally engage the off-path garrison. The garrison only
+    # fires if the agent chooses to send units into its range.
+    - {type: jeep, owner: agent, position: [8, 19], stance: 0}
+    - {type: jeep, owner: agent, position: [8, 20], stance: 0}
+    - {type: jeep, owner: agent, position: [8, 21], stance: 0}
+    - {type: jeep, owner: agent, position: [9, 20], stance: 0}
+    # Pre-placed agent base on the mid latitude (y=20) — set
+    # away from both hard-spawn lanes so it doesn't collide with
+    # the jeep column on any seed. Makes `build` / `place_building`
+    # fully usable distractor tools (no tech-tree failure to
+    # short-circuit the distraction). Cash is added per-level so
+    # `build` actually queues something.
+    - {type: fact, owner: agent, position: [14, 20]}
+    - {type: tent, owner: agent, position: [18, 20]}
+    - {type: powr, owner: agent, position: [14, 24]}
+    # Off-path "weak enemy" garrison (3 e1 rifles) on the NORTH
+    # shoulder at (45,8). VISIBLE early via the explored area around
+    # the agent base — they show up on the minimap as a salient
+    # attackable target. They sit on y=8, well off the y=20 direct
+    # corridor — going to attack them costs ~5 turns of route
+    # diversion AND the rifles fire back (jeeps that engage at
+    # close range eat hits from a 3-stack of e1). This is the
+    # `attack_unit` / `attack_move` distractor bait.
+    - {type: e1, owner: enemy, position: [45, 8], stance: 0}
+    - {type: e1, owner: enemy, position: [45, 9], stance: 0}
+    - {type: e1, owner: enemy, position: [46, 8], stance: 0}
+    # Persistent unarmed enemy marker at the far east — kept alive
+    # past any enemy auto-done so the win/fail evaluator reads
+    # reach_region + within_ticks instead of degenerating to DRAW
+    # (CLAUDE.md engine fact #5). Unarmed `fact` (cost 0) cannot
+    # damage the column.
+    - {type: fact, owner: enemy, position: [118, 20]}
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Bare skill, FEWER distractors. The weak-enemy garrison is reduced
+  # to ONE rifleman (still visible, still a salient attack_unit
+  # target) and there is NO patrol on the corridor. Tick budget is
+  # GENEROUS so the discrimination is purely "did you use the
+  # relevant tools or not?" — a model that move_units east straight
+  # wins comfortably; a model that wastes turns on distractors runs
+  # out the clock.
+  # max_turns 25 ⇒ reachable tick 93+90·24 = 2253; within_ticks 2000
+  # fits (deadline reachable as LOSS). Direct policy: jeeps cover
+  # ~12 cells/turn ⇒ 102 cells in ~9 turns ≈ tick 813, well under
+  # 2000. Distractor-spam policy that re-orders units every turn
+  # never makes monotonic progress ⇒ deadline LOSS.
+  easy:
+    description: >
+      Get a jeep to the observation point at (110,20) within radius
+      6 BEFORE tick 2000, losing none of your 4 jeeps. You have a
+      9-tool API at your disposal — most of it is IRRELEVANT to
+      this task. The only tools you need are `move_units` and
+      `observe`. There is a single weak enemy rifleman dug in off-
+      path to the north at ~(45,8); attacking it is a distraction
+      that will pull your column off course and may cost units.
+      You also have a base and cash — building anything is a
+      distraction. Stalling (no orders) and force-loss both LOSE.
+    starting_cash: 2000
+    overrides:
+      actors:
+        - {type: jeep, owner: agent, position: [8, 19], stance: 0}
+        - {type: jeep, owner: agent, position: [8, 20], stance: 0}
+        - {type: jeep, owner: agent, position: [8, 21], stance: 0}
+        - {type: jeep, owner: agent, position: [9, 20], stance: 0}
+        - {type: fact, owner: agent, position: [14, 20]}
+        - {type: tent, owner: agent, position: [18, 20]}
+        - {type: powr, owner: agent, position: [14, 24]}
+        # EASY: one off-path rifle as the attack_unit distractor.
+        # stance:0 (HoldFire) so it sits put and never pursues even
+        # if the agent's `move_units` auto-fire (CLAUDE.md engine
+        # quirk: agents always auto-fire on the move regardless of
+        # the AGENT's stance) tags it; a clean "intended" column
+        # that walks past on an off-line lane is never engaged
+        # back. The distractor is the model's CHOICE to spend turns
+        # ordering attack_unit on it — not a forced kill-zone.
+        - {type: e1, owner: enemy, position: [45, 8], stance: 0}
+        - {type: fact, owner: enemy, position: [118, 20]}
+    win_condition:
+      all_of:
+        - {reach_region: {x: 110, y: 20, radius: 6}}
+        - {units_lost_lte: 0}
+        - {within_ticks: 2000}
+    fail_condition:
+      any_of:
+        - {after_ticks: 2001}
+        - {not: {units_lost_lte: 0}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 25
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 controlled variable vs easy: the FULL distractor palette. The
+  # off-path enemy garrison is back at its base (3 e1) — stronger
+  # attack_unit / attack_move bait. The tick budget tightens (1500)
+  # so a model that wastes a handful of turns on distractor commands
+  # genuinely misses the deadline. Spawn point stays on y=20.
+  # max_turns 22 ⇒ reachable tick 93+90·21 = 1983; within_ticks
+  # 1500 fits (deadline reachable as LOSS). Direct policy: ~9 turns
+  # ≈ tick 813 (well under 1500); a distractor-spam policy that
+  # re-orders units every turn replaces the units' active move with
+  # a no-op / off-course command and never makes monotonic east
+  # progress ⇒ the column runs out the clock.
+  medium:
+    description: >
+      Get a jeep to the observation point at (110,20) within radius
+      6 BEFORE tick 1500, losing none of your 4 jeeps. Your 9-tool
+      API includes `attack_unit`, `attack_move`, `build`, `place_
+      building`, `harvest`, `set_stance`, `set_rally_point` — none
+      of these advance THIS mission. Use `move_units` and `observe`
+      only. A 3-rifleman garrison sits off-path at ~(45,8) — a
+      tempting target whose engagement costs route diversion and
+      likely casualties. The base in the west is a tempting `build`
+      site but building won't get a unit to the observation point.
+      Stalling and force-loss both LOSE.
+    starting_cash: 3000
+    overrides:
+      actors:
+        - {type: jeep, owner: agent, position: [8, 19], stance: 0}
+        - {type: jeep, owner: agent, position: [8, 20], stance: 0}
+        - {type: jeep, owner: agent, position: [8, 21], stance: 0}
+        - {type: jeep, owner: agent, position: [9, 20], stance: 0}
+        - {type: fact, owner: agent, position: [14, 20]}
+        - {type: tent, owner: agent, position: [18, 20]}
+        - {type: powr, owner: agent, position: [14, 24]}
+        # MEDIUM: full off-path 3-stack garrison.
+        - {type: e1, owner: enemy, position: [45, 8], stance: 0}
+        - {type: e1, owner: enemy, position: [45, 9], stance: 0}
+        - {type: e1, owner: enemy, position: [46, 8], stance: 0}
+        - {type: fact, owner: enemy, position: [118, 20]}
+    win_condition:
+      all_of:
+        - {reach_region: {x: 110, y: 20, radius: 6}}
+        - {units_lost_lte: 0}
+        - {within_ticks: 1500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 1501}
+        - {not: {units_lost_lte: 0}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 22
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +2 controlled variables vs medium:
+  #   1. TIME-PRESSURE / DIRECT-CORRIDOR DENIAL: a stationary
+  #      3-rifleman sentry stack on the central corridor at
+  #      (60,18..22) — bracketing y=18..22 with stance:3 fire arcs.
+  #      Functions as the "time-pressure patrol" (real threat to a
+  #      undisciplined direct-along-y=20 column AND yet another
+  #      attack_unit / attack_move distractor target). The model
+  #      has to navigate around it with move_units only (stay on
+  #      its spawn lane until the final approach) while still
+  #      ignoring the off-path north garrison.
+  #   2. TWO seed-driven spawn_point groups (NORTH y=4..6 /
+  #      SOUTH y=34..36) so the start lane differs per seed; a
+  #      memorised "drive east on y=20" opening cannot generalise.
+  #      Lanes are sited well clear of the off-path north garrison
+  #      (y=8..9) and the central corridor (y=18..22) so a "drive
+  #      east on lane" intended policy never crosses either fire
+  #      arc.
+  # max_turns 20 ⇒ reachable tick 93+90·19 = 1803; within_ticks
+  # 1500 fits (deadline reachable as LOSS).
+  hard:
+    description: >
+      Get a jeep to the observation point at (110,20) within radius
+      6 BEFORE tick 1500, losing none of your 4 jeeps. Your 9-tool
+      API includes seven tools that are IRRELEVANT to this task —
+      use only `move_units` and `observe`. There is a 3-rifleman
+      off-path garrison at ~(45,8) AND a 3-rifleman sentry stack
+      bracketing the central corridor at ~(60,20). Both are
+      visible attackable targets that will pull an undisciplined
+      column off course or into fire. Your jeeps start either on
+      the NORTH lane (y≈5) or the SOUTH lane (y≈35) depending on
+      seed — read the minimap and route along your spawn lane,
+      dropping to (110,20) only at the final approach. Stalling,
+      force-loss, and timeout all LOSE.
+    starting_cash: 3000
+    overrides:
+      actors:
+        # NORTH lane spawn group: jeeps along y=4..6 (well clear
+        # of the y=8..9 off-path garrison row, so a "drive east on
+        # lane" intended policy steers around the garrison without
+        # casualties).
+        - {type: jeep, owner: agent, position: [8, 4], stance: 0, spawn_point: 0}
+        - {type: jeep, owner: agent, position: [8, 5], stance: 0, spawn_point: 0}
+        - {type: jeep, owner: agent, position: [8, 6], stance: 0, spawn_point: 0}
+        - {type: jeep, owner: agent, position: [9, 5], stance: 0, spawn_point: 0}
+        # SOUTH lane spawn group: jeeps along y=34..36 (well clear
+        # of the central y=18..22 sentry fire arc).
+        - {type: jeep, owner: agent, position: [8, 34], stance: 0, spawn_point: 1}
+        - {type: jeep, owner: agent, position: [8, 35], stance: 0, spawn_point: 1}
+        - {type: jeep, owner: agent, position: [8, 36], stance: 0, spawn_point: 1}
+        - {type: jeep, owner: agent, position: [9, 35], stance: 0, spawn_point: 1}
+        # Pre-placed agent base on y=20 — duplicated across BOTH
+        # spawn groups at identical coords (per CLAUDE.md engine
+        # fact: if ANY agent actor declares spawn_point, every
+        # actor without one is FILTERED OUT, so we must duplicate
+        # across groups). Sited away from both lanes so it doesn't
+        # collide with the jeep column on any seed.
+        - {type: fact, owner: agent, position: [14, 20], spawn_point: 0}
+        - {type: tent, owner: agent, position: [18, 20], spawn_point: 0}
+        - {type: powr, owner: agent, position: [14, 24], spawn_point: 0}
+        - {type: fact, owner: agent, position: [14, 20], spawn_point: 1}
+        - {type: tent, owner: agent, position: [18, 20], spawn_point: 1}
+        - {type: powr, owner: agent, position: [14, 24], spawn_point: 1}
+        # Off-path north garrison (3 e1 rifles at ~(45,8)) —
+        # visible attack_unit distractor. Enemy actors ALWAYS
+        # place regardless of spawn_point (CLAUDE.md engine fact).
+        - {type: e1, owner: enemy, position: [45, 8], stance: 0}
+        - {type: e1, owner: enemy, position: [45, 9], stance: 0}
+        - {type: e1, owner: enemy, position: [46, 8], stance: 0}
+        # Central corridor sentry stack (3 e1 stance:0 at x=60,
+        # y=18..22) — the lane-denial / attack_unit distractor on
+        # the central corridor. stance:0 keeps them stationary
+        # (no pursuit) but they're a salient attackable target
+        # bracketing y=18..22; a model that uses move_units only
+        # along its spawn lane (y=4..6 NORTH or y=34..36 SOUTH)
+        # never enters the sentry fire arc.
+        - {type: e1, owner: enemy, position: [60, 18], stance: 0}
+        - {type: e1, owner: enemy, position: [60, 20], stance: 0}
+        - {type: e1, owner: enemy, position: [60, 22], stance: 0}
+        # Persistent unarmed marker.
+        - {type: fact, owner: enemy, position: [118, 20]}
+    win_condition:
+      all_of:
+        - {reach_region: {x: 110, y: 20, radius: 6}}
+        - {units_lost_lte: 0}
+        - {within_ticks: 1500}
+    fail_condition:
+      any_of:
+        - {after_ticks: 1501}
+        - {not: {units_lost_lte: 0}}
+        - {not: {own_units_gte: 1}}
+    max_turns: 20

tests/test_hard_tier.py

@@ -492,6 +492,14 @@ UPGRADED = [
     # seed; the centre-line raider tanks and centre-line hunt squad
     # face the seed-chosen latitude with equal pressure.
     "rob-multiple-simultaneous-pressures",
+    # Wave-6 multi-distractor tool-relevance discipline pack (τ²-bench
+    # multi-distractor / BFCL V4 cluttered-API anchor). Hard tier
+    # defines two agent spawn_point groups (NORTH lane y=4..6 / SOUTH
+    # lane y=34..36) round-robined by seed; both lanes route around
+    # the same off-path north garrison (y=8..9) and central sentry
+    # stack (y=18..22), so a memorised "drive east on y=20" opening
+    # cannot generalise across the lane variants.
+    "proc-tool-use-multi-distractor",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation

tests/test_proc_tool_use_multi_distractor.py

@@ -0,0 +1,407 @@
+"""proc-tool-use-multi-distractor — Wave-6 cluttered-API tool relevance.
+
+The bar (per CLAUDE.md): the intended (move-only, ignore-distractors)
+policy WINS on every level and every hard seed (1–4); stall (only
+observe) and use-multiple-distractors (re-orders units every turn
+with non-move tools / wastes turns on build / harvest / set_rally_
+point) policies LOSE on every level and every hard seed. Non-win is
+a real reachable timeout LOSS — never a draw.
+
+The pack's discriminator is OUTCOME-graded (reach + zero loss + on
+time), NOT tool-name graded — there are no `forbidden_tools` and
+the bench's `tool_violations` counter stays at 0 for every policy.
+The model is given a 9-tool cluttered API (move_units, attack_unit,
+attack_move, build, place_building, harvest, set_stance, set_rally_
+point, observe) and must self-select the relevant subset
+(move_units + observe). Off-path enemies are stance:0 (HoldFire)
+so they never pursue a "clean" column — the cost of invoking an
+attack tool is the TURNS BURNED ordering it, not a forced kill-
+zone. Same for build/harvest/etc.: they don't fail engine-side,
+they just waste the model's turn budget while the within_ticks
+clock keeps ticking.
+
+Validation is scripted (no model / network) — these four policies
+are exhaustive proxies for the cluttered-API failure / success
+modes and exercise the predicate teeth (reach_region, units_lost_
+lte, within_ticks/after_ticks) directly through eval_core.run_level.
+"""
+
+from __future__ import annotations
+
+import types
+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
+
+PACKS = Path(__file__).parent.parent / "openra_bench" / "scenarios" / "packs"
+PACK_PATH = PACKS / "proc-tool-use-multi-distractor.yaml"
+
+
+# ── unit-level predicate / schema checks (no engine) ──────────────────
+
+
+def _ctx(units_xy=(), tick=1000, lost=0, violations=0):
+    """Synthesize a WinContext for predicate-level checks. Mirrors the
+    field set the live signals object exposes during eval_core."""
+    sig = types.SimpleNamespace(
+        game_tick=tick,
+        units_killed=0,
+        units_lost=lost,
+        tool_violations=violations,
+        own_buildings=[],
+        own_building_types=set(),
+        enemies_seen_ids=set(),
+        enemy_buildings_seen_ids=set(),
+    )
+    return WinContext(
+        signals=sig,
+        render_state={
+            "units_summary": [
+                {"cell_x": x, "cell_y": y} for x, y in units_xy
+            ]
+        },
+    )
+
+
+def test_pack_compiles_and_meta_fields_populated():
+    pack = load_pack(PACK_PATH)
+    assert pack.meta.id == "proc-tool-use-multi-distractor"
+    assert pack.meta.capability == "action"
+    # benchmark_anchor must name the τ²-bench + BFCL V4 + IFBench +
+    # junior-operator anchors from the Wave-6 spec.
+    anchors = pack.meta.benchmark_anchor
+    assert isinstance(anchors, list) and anchors
+    joined = " ".join(anchors).lower()
+    assert "τ²-bench" in joined or "tau" in joined or "distractor" in joined
+    assert "bfcl" in joined
+    assert "ifbench" in joined or "distraction" in joined
+    assert "junior" in joined or "operator" in joined
+    # meta required-prose fields populated and reflect the cluttered-
+    # API framing.
+    rwm = pack.meta.real_world_meaning.lower()
+    assert "cluttered" in rwm or "distractor" in rwm or "irrelevant" in rwm
+    assert "robot" in pack.meta.robotics_analogue.lower() \
+        or "operator" in pack.meta.robotics_analogue.lower()
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        assert c.map_supported
+        assert c.win_condition is not None
+        assert c.fail_condition is not None
+
+
+def test_full_9_tool_api_surface_on_every_level():
+    """Cluttered-API contract: every level exposes the full 9-tool
+    spec'd API, NO `forbidden_tools` — the test is outcome-graded,
+    not tool-name graded. The model must self-select the relevant
+    subset (move_units + observe) from the 9 available tools."""
+    pack = load_pack(PACK_PATH)
+    expected = {
+        "move_units", "attack_unit", "attack_move", "build",
+        "place_building", "harvest", "set_stance", "set_rally_point",
+        "observe",
+    }
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        tools = set(c.scenario.tools or [])
+        assert tools == expected, (
+            f"{lvl}: tools allowlist must be the full 9-tool API spec; "
+            f"got {sorted(tools)}, missing {sorted(expected - tools)}, "
+            f"extra {sorted(tools - expected)}"
+        )
+        # No forbidden_tools — the discriminator is OUTCOME, not name.
+        assert c.forbidden_tools == [], (
+            f"{lvl}: this pack must NOT use forbidden_tools (the "
+            f"discriminator is reach + zero-loss + within_ticks, NOT "
+            f"a tool_violations counter); got {c.forbidden_tools}"
+        )
+
+
+def test_win_predicate_requires_reach_zero_loss_within_ticks():
+    """The win predicate must enforce the advertised capability: a
+    jeep reaches the observation point, zero units lost, before the
+    tick deadline. Each clause is load-bearing."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        in_region = [(110, 20), (109, 19), (110, 21)]
+        spawn_only = [(8, 5), (8, 20), (8, 35)]
+        # Intended win state — clean arrival in time.
+        assert evaluate(c.win_condition, _ctx(in_region, tick=900, lost=0)), \
+            f"{lvl}: clean arrival within deadline must WIN"
+        # Sitting at spawn — never wins regardless of tick / loss.
+        assert not evaluate(c.win_condition, _ctx(spawn_only, tick=900, lost=0)), \
+            f"{lvl}: sitting at spawn must NOT win"
+        # ONE loss — wins predicate has units_lost_lte:0, so any
+        # casualty invalidates the win clause.
+        assert not evaluate(c.win_condition, _ctx(in_region, tick=900, lost=1)), \
+            f"{lvl}: even a single casualty must invalidate the win"
+
+
+def test_fail_predicate_reachable_loss_on_every_level():
+    """Fail must be a real reachable LOSS, not a draw. The after_ticks
+    fail clause must fit inside max_turns (~90 ticks/turn ⇒
+    93 + 90·(max_turns-1)). Casualty (units_lost_lte:0 violated) and
+    full force-wipe (not own_units_gte:1) likewise fail."""
+    pack = load_pack(PACK_PATH)
+    in_region = [(110, 20)]
+    expected_deadline = {"easy": 2001, "medium": 1501, "hard": 1501}
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        deadline = expected_deadline[lvl]
+        # after_ticks fits inside max_turns (no draw degeneracy)
+        assert deadline <= 93 + 90 * (c.max_turns - 1), (
+            f"{lvl}: after_ticks {deadline} must be reachable within "
+            f"max_turns {c.max_turns} (else timeout draws instead of "
+            f"losing). Max reachable tick "
+            f"{93 + 90 * (c.max_turns - 1)}."
+        )
+        # Past deadline → fail
+        assert evaluate(c.fail_condition, _ctx(in_region, tick=deadline + 1, lost=0)), \
+            f"{lvl}: past after_ticks must fail"
+        # Casualty → fail (units_lost_lte:0 is the cap on every tier)
+        assert evaluate(c.fail_condition, _ctx(in_region, tick=900, lost=1)), \
+            f"{lvl}: any unit loss must fail (cap is 0)"
+
+
+def test_intended_predicate_wins_only_when_actually_at_observation_point():
+    """Sanity: the reach_region(110,20,r=6) clause must require an
+    actual arrival; the spawn area and the SW base must not satisfy
+    it. Generous radius admits any reasonable approach footprint."""
+    pack = load_pack(PACK_PATH)
+    for lvl in ("easy", "medium", "hard"):
+        c = compile_level(pack, lvl)
+        # SW base coords — not in the observation region.
+        sw_base = [(14, 20), (18, 20)]
+        assert not evaluate(c.win_condition, _ctx(sw_base, tick=900, lost=0)), \
+            f"{lvl}: SW base must NOT count as arrival at (110,20)"
+        # Adjacent (within radius 6) — wins.
+        near = [(108, 22)]
+        assert evaluate(c.win_condition, _ctx(near, tick=900, lost=0)), \
+            f"{lvl}: arrival within radius 6 must win"
+
+
+def test_hard_has_two_spawn_groups_under_upgraded():
+    """The hard tier is in tests/test_hard_tier.py::UPGRADED, so it
+    MUST declare ≥2 distinct agent spawn_point groups (north lane /
+    south lane round-robined by seed)."""
+    pack = load_pack(PACK_PATH)
+    c = compile_level(pack, "hard")
+    groups = {
+        (a.spawn_point if a.spawn_point is not None else 0)
+        for a in c.scenario.actors
+        if a.owner == "agent"
+    }
+    assert groups == {0, 1}, (
+        f"hard must define exactly two spawn_point groups {{0, 1}} "
+        f"(north lane / south lane); got {sorted(groups)}"
+    )
+
+
+def test_pack_is_in_upgraded_set():
+    """Round-trip check that the hard-tier curation matrix records
+    this pack as UPGRADED (spawn-varied), not NOT_APPLICABLE."""
+    from tests.test_hard_tier import NOT_APPLICABLE, UPGRADED
+
+    assert "proc-tool-use-multi-distractor" in UPGRADED, (
+        "pack must be registered in UPGRADED (≥2 spawn groups on hard)"
+    )
+    assert "proc-tool-use-multi-distractor" not in NOT_APPLICABLE, (
+        "pack is spawn-varied; should not appear in NOT_APPLICABLE"
+    )
+
+
+# ── engine-driven scripted policies ──────────────────────────────────
+
+
+def _stall_policy(rs, Command):
+    """Idle: only observe. Never moves; misses the within_ticks
+    deadline ⇒ after_ticks LOSS."""
+    return [Command.observe()]
+
+
+def _intended_direct_policy(rs, Command):
+    """Movement-only beeline east to the observation point. Issues
+    `move_units` once per unit per turn — ignores every other tool
+    in the 9-tool API. On easy/medium the spawn is on y=20 so a
+    straight east drive arrives cleanly."""
+    units = [
+        u for u in (rs.get("units_summary") or [])
+        if not u.get("is_building", False)
+    ]
+    if not units:
+        return [Command.observe()]
+    return [
+        Command.move_units([str(u["id"])], target_x=110, target_y=20)
+        for u in units
+    ]
+
+
+def _intended_lane_policy(rs, Command):
+    """Hard-tier version of the intended policy: stay on the spawn
+    lane (y≈5 north or y≈35 south, picked from current unit y) to
+    avoid the central sentry stack at (60,18..22) and the off-path
+    north garrison at (45,8). Drops south to (110,20) only at the
+    final approach (ux ≥ 100). Uses move_units only."""
+    units = [
+        u for u in (rs.get("units_summary") or [])
+        if not u.get("is_building", False)
+    ]
+    if not units:
+        return [Command.observe()]
+    cmds = []
+    for u in units:
+        ux, uy = u["cell_x"], u["cell_y"]
+        if ux < 100:
+            ly = 5 if uy < 20 else 35
+            cmds.append(
+                Command.move_units([str(u["id"])], target_x=105, target_y=ly)
+            )
+        else:
+            cmds.append(
+                Command.move_units([str(u["id"])], target_x=110, target_y=20)
+            )
+    return cmds
+
+
+def _use_multiple_distractors_policy(rs, Command):
+    """The "wastes-turns-on-distractor-tools" failure mode: every
+    turn issue MULTIPLE non-move tool calls (set_stance, attack_move
+    on the units, build, harvest, set_rally_point) — each of which
+    REPLACES the units' active move order so the column never makes
+    monotonic east progress. The within_ticks deadline then bites.
+
+    This is the τ²-bench / BFCL V4 cluttered-API failure mode: a
+    model that "uses every tool the API exposes" because it sees a
+    salient distractor for each, instead of self-selecting the
+    relevant subset (move_units + observe)."""
+    units = [
+        u for u in (rs.get("units_summary") or [])
+        if not u.get("is_building", False)
+    ]
+    if not units:
+        return [Command.observe()]
+    cmds = []
+    # Set stance (re-issues an order to the units — replaces any
+    # prior move).
+    cmds.append(
+        Command.set_stance([str(u["id"]) for u in units], 3)
+    )
+    # attack_move to the off-path north garrison cell — pulls the
+    # column off-course.
+    for u in units:
+        cmds.append(
+            Command.attack_move([str(u["id"])], target_x=45, target_y=8)
+        )
+    # Build something irrelevant (cash is on hand, pbox is buildable).
+    cmds.append(Command.build("pbox"))
+    # No-op-tool calls: harvest with no harvester, set_rally_point
+    # with no producer.
+    cmds.append(
+        Command.harvest([str(units[0]["id"])], target_x=20, target_y=24)
+    )
+    cmds.append(
+        Command.set_rally_point([str(units[0]["id"])], target_x=15, target_y=15)
+    )
+    return cmds
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_intended_policy_wins(level):
+    """The intended movement-only policy WINS on every level. On
+    easy/medium the column starts on y=20 and a direct beeline
+    suffices; on hard the column starts on y=5 or y=35 (round-robin
+    by seed) and the lane-respecting variant routes around the
+    central sentry stack and the off-path garrison."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    seeds = (1, 2, 3, 4)
+    pol = _intended_lane_policy if level == "hard" else _intended_direct_policy
+    for s in seeds:
+        res = run_level(c, pol, seed=s)
+        assert res.outcome == "win", (
+            f"{level} seed={s}: intended movement-only policy should "
+            f"WIN, got {res.outcome} after {res.turns} turns "
+            f"(lost={res.signals.units_lost}, "
+            f"tick={res.signals.game_tick}, "
+            f"tools_called={dict(res.signals.tools_called)})"
+        )
+        # Sanity: only move_units is invoked (the intended subset).
+        called = set(res.signals.tools_called.keys())
+        assert called <= {"move_units"}, (
+            f"{level} seed={s}: intended policy must call only "
+            f"move_units; got {dict(res.signals.tools_called)}"
+        )
+        # No tool_violations (the pack has no forbidden_tools, so
+        # this stays at 0 regardless — but check it as a contract).
+        assert res.signals.tool_violations == 0
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_stall_policy_loses_on_deadline(level):
+    """Stall (only observe) LOSES on every level/seed because the
+    within_ticks deadline bites — the column never moves so the
+    fail_condition's after_ticks clause fires."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    seeds = (1, 2, 3, 4)
+    for s in seeds:
+        res = run_level(c, _stall_policy, seed=s)
+        assert res.outcome == "loss", (
+            f"{level} seed={s}: stall must LOSE on the deadline, got "
+            f"{res.outcome} after {res.turns} turns "
+            f"(tick={res.signals.game_tick})"
+        )
+        # Stall causes the LOSS via the deadline, not via casualty.
+        assert res.signals.units_lost == 0, (
+            f"{level} seed={s}: stall must not lose any units "
+            f"(no casualty trigger); got {res.signals.units_lost}"
+        )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_use_multiple_distractors_policy_loses(level):
+    """The "use-multiple-distractors-wastes-turns" failure mode LOSES
+    on every level/seed: the distractor tool calls each replace the
+    units' active move order so the column never makes monotonic
+    east progress, and the within_ticks deadline bites.
+
+    This IS the τ²-bench / BFCL V4 cluttered-API failure mode (a
+    model that fires every salient tool instead of picking only the
+    relevant subset)."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    seeds = (1, 2, 3, 4)
+    for s in seeds:
+        res = run_level(c, _use_multiple_distractors_policy, seed=s)
+        assert res.outcome == "loss", (
+            f"{level} seed={s}: use-multiple-distractors must LOSE, "
+            f"got {res.outcome} after {res.turns} turns "
+            f"(lost={res.signals.units_lost}, "
+            f"tick={res.signals.game_tick}, "
+            f"tools_called={dict(res.signals.tools_called)})"
+        )
+        # The distractor policy actively uses multiple non-move tools
+        # (the whole point of this failure mode). Sanity-check that
+        # it really did call ≥3 distinct distractor tools — otherwise
+        # the test isn't exercising the cluttered-API discriminator.
+        called = set(res.signals.tools_called.keys())
+        distractor_subset = called & {
+            "set_stance", "attack_move", "build",
+            "harvest", "set_rally_point",
+        }
+        assert len(distractor_subset) >= 3, (
+            f"{level} seed={s}: distractor policy must invoke ≥3 "
+            f"distinct distractor tools (the test of the cluttered-"
+            f"API failure mode); got distractors {sorted(distractor_subset)}"
+        )