feat(scenario): build-sell-and-rebuild-elsewhere — sell exposed building + rebuild safe (capital reallocation anchor)

openra_bench/scenarios/packs/build-sell-and-rebuild-elsewhere.yaml

@@ -0,0 +1,353 @@
+# build-sell-and-rebuild-elsewhere.yaml
+#
+# REASONING capability — Wave-8 Group "capital reallocation" pack
+# (SC2 sell mechanic for refund / financial reallocation / business
+# CAPEX redeployment anchor). The agent owns a Construction Yard
+# (`fact`) and a Power Plant (`powr`) at the safe north-west corner
+# and an exposed Refinery (`proc`) at the centre lane. A scripted
+# `hunt` band is incoming on the centre lane and will raze the proc
+# within ~25-30 turns (the proc has no defenders and no inherent
+# weapons). Starting cash alone is NOT enough to build a NEW proc
+# (1400 build cost > starting cash on every tier); the only path
+# to a fresh proc inside the tick budget is:
+#
+#     1. `sell` the EXPOSED proc           ⇒ refunds 50% of cost (700)
+#     2. `build('proc')` + `place_building` ⇒ at the safe target region
+#
+# Without selling, the agent has insufficient cash to build a new
+# proc (build cost 1400 > starting cash on every tier and there is
+# no income source); even if the agent attempts to wait, the proc
+# is razed by the hunt band ⇒ refund forfeit ⇒ still no cash for a
+# new proc. Building-without-selling stalls on insufficient funds
+# (`build('proc')` is rejected until cash ≥ 1400 — production
+# gates on cash > cost). The intended SELL-THEN-REBUILD play wins.
+#
+# Real-world anchors:
+#   - SC2 sell mechanic for refund (the classic mechanic this pack
+#     is named for — partial salvage of a structure for partial
+#     refund to redeploy production elsewhere)
+#   - Financial / CAPEX reallocation (liquidate a deteriorating
+#     asset and redeploy the capital to a safer / forward site)
+#   - PlanBench resource reallocation (the planner must reason that
+#     the partial refund + new build is cheaper than any alternative
+#     under the budget — building from cash alone is impossible)
+#
+# DISCRIMINATIONS (no defect, no cheat):
+#   - stall (observe only): LOSS — proc razed; no new proc placed
+#     anywhere (let alone in the safe region) ⇒ building_in_region
+#     clause unmet AND clock runs out.
+#   - build-without-selling: LOSS — `build('proc')` is rejected
+#     until cash ≥ 1400; the agent has no income source within the
+#     tick budget, so the build never starts ⇒ no proc in safe
+#     region.
+#   - sell-but-place-in-wrong-region: LOSS — refunded cash + cash
+#     covers a new proc, but placed in the central lane (or
+#     anywhere outside the safe region) ⇒ building_in_region
+#     clause unmet (the new proc is in the wrong cell band).
+#   - sell-then-rebuild-at-safe-region (intended): WIN — refund
+#     funds the new proc, placed at the safe far-west target
+#     region ⇒ all win clauses satisfied within tick budget.
+#
+# ENGINE FACTS (CLAUDE.md):
+#   - proc cost 1400 → sell refund = 700 (50% of build cost;
+#     world.rs::order_sell / estimate_building_sell_value).
+#   - PROC has `Prerequisites: anypower` → POWR pre-placed at the
+#     safe corner so the new proc can be built.
+#   - `fact` cost 0 ⇒ NOT buildable via StartProduction (engine
+#     gates on cost > 0). Pre-place the agent fact on the SAFE
+#     corner so `has_building:fact` is satisfied turn 1; the
+#     rebuild target is a `proc`, not a fact.
+#   - `place_building` does NOT enforce build-adjacency — orders
+#     work at arbitrary in-bounds coords (CLAUDE.md), so the safe
+#     target region can be far from the surviving fact.
+#   - `building_in_region` is the present-tense region-and-type
+#     predicate (vs `has_building` which is a one-shot "ever
+#     seen" set; the proc must STAND at the safe region at the
+#     win check).
+#   - `hunt` bot: each enemy unit attacks NEAREST foe (CLAUDE.md
+#     scripted_bot — not centroid like rusher). With proc on the
+#     centre lane (front piece) and fact far in the NW corner,
+#     each hunt unit picks the proc first, then walks west for the
+#     fact only after the proc falls. This gives the agent a
+#     ~25-30 turn proc-razing window during which the sell+build
+#     must complete, and the fact survives long enough to satisfy
+#     the win clause.
+#   - within_ticks paired with after_ticks ⇒ a non-finisher is a
+#     real reachable timeout LOSS (CLAUDE.md rule 2 — deadline
+#     must be reachable below max_turns).
+#   - Inert enemy `fact` far east (anti-DRAW: keeps the episode
+#     alive past hunt-band death so the win/fail check fires;
+#     engine auto-`done`s on enemy-elimination otherwise).
+#
+# Validate (no model / no network):
+#   cd /Users/berta/Projects/OpenRA-Bench && \
+#   python3 -m pytest tests/test_build_sell_and_rebuild_elsewhere.py -q
+
+meta:
+  id: build-sell-and-rebuild-elsewhere
+  title: 'Sell and Rebuild Elsewhere — Recoup Capital, Relocate Production'
+  capability: reasoning
+  real_world_meaning: >
+    A forward refinery (proc) sits in the path of an incoming enemy
+    hunt band that will raze it within ~25-30 turns; starting cash
+    alone does not cover building a new proc at the safe target
+    region. The only path to a fresh proc inside the tick budget
+    is to SELL the exposed proc (recouping 50% of its build cost)
+    and use the refund plus starting cash to BUILD a new proc and
+    PLACE it at the safe target region far from the rush. Stalling,
+    building without selling (cash gated), and placing the new
+    proc in the wrong region all lose; only sell-then-rebuild-at-
+    safe-region wins.
+  robotics_analogue: >
+    Liquidate a deteriorating asset to fund a relocation: a forward
+    production node is about to be lost to environmental damage,
+    and the capital reserve alone is insufficient to commission a
+    replacement node elsewhere. The right move is a deliberate
+    salvage of the at-risk node (recovering ~half the build capital
+    in liquid form) which, combined with the on-hand reserve, funds
+    a new node at a safer site BEFORE the original is lost for zero
+    recovery. Letting the asset be destroyed loses 100% of its
+    capital; salvage-and-redeploy preserves 50% + funds the new
+    site.
+  benchmark_anchor:
+    - 'capital reallocation'
+    - 'SC2 sell mechanic'
+    - 'financial reallocation'
+  author: openra-bench
+
+base_map: rush-hour-arena
+
+base:
+  agent:
+    faction: allies
+  # `hunt` bot: each enemy unit picks its OWN nearest agent target
+  # (per-unit nearest, not rusher's all-attack-centroid-nearest).
+  # With the proc on the centre lane (front piece) and the fact +
+  # garrison far in the NW corner, every hunt unit picks the proc
+  # first; only after the proc is razed do they walk west toward
+  # the fact. The agent's sell+build cycle must complete in the
+  # proc-razing window (~25-30 turns at this composition); the
+  # fact then survives long enough for the win clause to fire.
+  enemy:
+    faction: soviet
+    bot_type: hunt
+  # Minimal toolset: observe, sell (load-bearing), build +
+  # place_building (rebuild primitive). No deploy / harvest /
+  # repair — those would side-step the decision by enabling other
+  # paths (deploying a spare MCV, training income from a harv
+  # loop, repairing the exposed proc indefinitely).
+  tools:
+    - observe
+    - sell
+    - build
+    - place_building
+  planning: true
+  # Re-decide the instant the hunt band is spotted, so the agent
+  # gets debriefed within seconds of the threat materialising and
+  # has a clean re-plan window.
+  interrupts:
+    enemy_unit_spotted: true
+    own_unit_destroyed: true
+  termination:
+    max_ticks: 12000
+
+starting_cash: 800
+
+levels:
+  # ── EASY ──────────────────────────────────────────────────────────
+  # 800 cash + 700 refund from selling the exposed proc = 1500, just
+  # over the 1400 build cost of a new proc. Light hunt band (2× e1)
+  # so the proc has ~25-30 turns before it falls — generous window
+  # to sell + queue + place. max_turns 60 → reachable tick ≈ 4698 in
+  # interrupt mode (event-shortened steps). within_ticks 4500
+  # paired with after_ticks 4501 in fail ⇒ a non-finisher is a real
+  # reachable timeout LOSS (not a draw).
+  easy:
+    description: >
+      You own a Construction Yard (fact) and a Power Plant (powr)
+      at the safe far north-west corner and a forward Refinery
+      (proc) at the centre lane. A small hunt band (2 rifle
+      infantry) is incoming from the east on the centre lane and
+      will raze the refinery within ~25-30 turns. Your starting
+      cash is 800 — not enough to build a new refinery (cost
+      1400). SELL the exposed refinery (refunds 700) and use the
+      recouped cash + starting cash to BUILD a new refinery at
+      the safe target region around (16, 8) — north of the rush
+      lane. Win by having a refinery at the safe region AND the
+      Construction Yard still alive AND before tick 4500. Stall,
+      build-without-selling (cash gated), or placing the new
+      refinery anywhere outside the safe region all lose.
+    starting_cash: 800
+    overrides:
+      actors:
+        # Agent fact + powr at the SAFE far north-west corner (off
+        # the y=20 lane; powr provides the `anypower` prerequisite
+        # that PROC needs).
+        - {type: fact, owner: agent, position: [4, 4]}
+        - {type: powr, owner: agent, position: [4, 9]}
+        # Exposed proc at the centre lane — WILL be razed by the
+        # hunt band ~tick 2400-2800 unless sold.
+        - {type: proc, owner: agent, position: [60, 20]}
+        # Light hunt band — 2× e1 — at x=110 on the centre lane.
+        # Each hunt unit attacks its own nearest foe; the proc on
+        # the centre lane is the front piece, so both rifles
+        # converge on it first. The fact in the NW corner is OFF
+        # the engagement axis (~108 cells away vs the proc's
+        # ~50 cells), so the proc absorbs the initial salvo and
+        # the fact survives well past the win check.
+        - {type: e1, owner: enemy, position: [110, 20], stance: 3, count: 2}
+        # Anti-DRAW marker: unarmed enemy fact far east keeps the
+        # episode alive past hunt-band death so the win/fail
+        # evaluation actually fires (CLAUDE.md: engine auto-
+        # `done`s on enemy-elim once the last MustBeDestroyed
+        # enemy building falls).
+        - {type: fact, owner: enemy, position: [125, 20]}
+    win_condition:
+      all_of:
+        # New proc at the safe target region (north shoulder
+        # around (16, 8), radius 6 — generous enough to admit
+        # nearby legal cells but tight enough that placing on
+        # the y=20 lane fails the clause).
+        - building_in_region: {type: proc, x: 16, y: 8, radius: 6, count: 1}
+        # Construction Yard still alive (present-tense fact
+        # predicate; `has_building` is one-shot and would stay
+        # true after the fact's destruction — CLAUDE.md footgun).
+        - building_count_gte: {type: fact, n: 1}
+        - within_ticks: 4500
+    # Fail bites at tick 4501 — reachable inside 60 turns in
+    # interrupt mode (empirically the stall path reaches ~tick 4698
+    # at turn 60 due to mid-episode event-shortened steps).
+    fail_condition:
+      any_of:
+        - after_ticks: 4501
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 60
+
+  # ── MEDIUM ────────────────────────────────────────────────────────
+  # +1 controlled variable: TIGHTER cash + LARGER hunt band. Starting
+  # cash 700 = exactly the sell refund — the agent MUST sell to fund
+  # the new proc (cash 700 is half the proc cost). The heavier band
+  # (3× e1) raises the urgency: the proc falls in ~20 turns instead
+  # of ~25-30. Same tick budget so the win window is tighter against
+  # the same after_ticks 5401 fail.
+  medium:
+    description: >
+      You own a Construction Yard and a Power Plant at the safe
+      far north-west corner and a forward Refinery at the centre
+      lane. A heavier hunt band (3 rifle infantry) is incoming
+      and will raze the refinery faster (~20 turns). Your
+      starting cash is 700 — exactly the sell refund of a
+      refinery, half the build cost. You MUST sell the exposed
+      refinery to free the second half of the cash, then build a
+      new refinery at the safe target region around (16, 8). Win
+      by having a refinery at the safe region AND the Construction
+      Yard still alive AND before tick 4500. Stalling, building
+      without selling (cash blocks the build), or placing the new
+      refinery in the central lane all lose.
+    starting_cash: 700
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [4, 4]}
+        - {type: powr, owner: agent, position: [4, 9]}
+        - {type: proc, owner: agent, position: [60, 20]}
+        # Heavier band: 3× e1 (still no e3 — pure-rifle keeps the
+        # band's eastern walk-time consistent with easy; the
+        # extra rifle just shortens the proc-razing window).
+        - {type: e1, owner: enemy, position: [110, 20], stance: 3, count: 3}
+        - {type: fact, owner: enemy, position: [125, 20]}
+    win_condition:
+      all_of:
+        - building_in_region: {type: proc, x: 16, y: 8, radius: 6, count: 1}
+        - building_count_gte: {type: fact, n: 1}
+        - within_ticks: 4500
+    fail_condition:
+      any_of:
+        - after_ticks: 4501
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 60
+
+  # ── HARD ──────────────────────────────────────────────────────────
+  # +1 controlled variable: TWO spawn_point groups (NORTH y=4 vs
+  # SOUTH y=36 base corner) round-robined by seed AND a SECOND hunt
+  # band so each spawn faces an equivalent threat. The safe target
+  # region for each spawn group shifts to the SAME y-band as that
+  # spawn's fact (so the relocate is always "stay on YOUR latitude").
+  # Tight cash 700 still requires the sell. A memorised "build at
+  # (16, 8)" cell loses on the SOUTH spawn (the safe region there
+  # is (16, 36) not (16, 8)).
+  hard:
+    description: >
+      Your base stages from a seed-chosen latitude (NORTH y=4 or
+      SOUTH y=36) — a single memorised target cell cannot
+      generalise. You own a Construction Yard and a Power Plant
+      at the safe corner of your latitude and a forward Refinery
+      at the centre lane. Hunt bands are incoming on the centre
+      lane and will raze the refinery within ~20 turns. Your
+      starting cash is 700 — exactly half the refinery build
+      cost. You MUST sell the exposed refinery and use the
+      recouped cash to build a new refinery at the safe target
+      region of your OWN latitude (around (16, 8) for the NORTH
+      spawn, (16, 36) for the SOUTH spawn). Win by having a
+      refinery at the safe region of your latitude AND the
+      Construction Yard still alive AND before tick 4500.
+    starting_cash: 700
+    overrides:
+      actors:
+        # NORTH spawn (spawn_point 0): fact + powr at the safe
+        # NW corner, proc forward on the central lane.
+        - {type: fact, owner: agent, position: [4, 4], spawn_point: 0}
+        - {type: powr, owner: agent, position: [4, 9], spawn_point: 0}
+        - {type: proc, owner: agent, position: [60, 20], spawn_point: 0}
+        # Inert HoldFire rifle at the matching safe shoulder so the
+        # spawn variation surfaces in `units_summary` (the hard-tier
+        # contract test asserts that different seeds produce
+        # different agent starts; otherwise this pack is buildings-
+        # only and the spawn round-robin is invisible to the
+        # observation channel).
+        - {type: e1, owner: agent, position: [16, 8], stance: 0, spawn_point: 0}
+        # SOUTH spawn (spawn_point 1): fact + powr at the safe
+        # SW corner, proc forward on the SAME central lane (the
+        # threat axis is symmetric across y=20).
+        - {type: fact, owner: agent, position: [4, 36], spawn_point: 1}
+        - {type: powr, owner: agent, position: [4, 31], spawn_point: 1}
+        - {type: proc, owner: agent, position: [60, 20], spawn_point: 1}
+        - {type: e1, owner: agent, position: [16, 36], stance: 0, spawn_point: 1}
+        # Hunt band on the centre lane — enemy actors don't honour
+        # spawn_point (CLAUDE.md oramap.rs footgun) so they always
+        # place regardless of seed. Each hunt unit picks its own
+        # nearest foe; the proc on (60,20) is the front piece for
+        # BOTH spawns (the fact in either NW or SW corner is far
+        # off-axis), so the proc absorbs the salvo first and the
+        # active-spawn fact survives well past the win check.
+        - {type: e1, owner: enemy, position: [110, 20], stance: 3, count: 3}
+        # Anti-DRAW marker at the centre lane far east.
+        - {type: fact, owner: enemy, position: [125, 20]}
+    # Spawn-matched win: the proc must land in the SAFE region of the
+    # active spawn's latitude. The `any_of` pairs each NORTH/SOUTH
+    # safe region with a `building_in_region` check on the active
+    # fact's corner — so the NORTH-disc clause only fires when the
+    # NORTH fact is alive (NORTH spawn) and the SOUTH-disc clause
+    # only fires when the SOUTH fact is alive (SOUTH spawn). A
+    # memorised "always place at (16, 8)" cell satisfies the NORTH
+    # clause on NORTH seeds but FAILS on SOUTH seeds (no NORTH fact
+    # ⇒ NORTH-pair fails; no SOUTH proc ⇒ SOUTH-pair fails).
+    win_condition:
+      all_of:
+        - any_of:
+            # NORTH spawn (fact at (4, 4)) ⇒ matching safe region
+            # for the new proc is the NW shoulder around (16, 8).
+            - all_of:
+                - building_in_region: {type: fact, x: 4, y: 4, radius: 4, count: 1}
+                - building_in_region: {type: proc, x: 16, y: 8, radius: 6, count: 1}
+            # SOUTH spawn (fact at (4, 36)) ⇒ matching safe region
+            # for the new proc is the SW shoulder around (16, 36).
+            - all_of:
+                - building_in_region: {type: fact, x: 4, y: 36, radius: 4, count: 1}
+                - building_in_region: {type: proc, x: 16, y: 36, radius: 6, count: 1}
+        - building_count_gte: {type: fact, n: 1}
+        - within_ticks: 4500
+    fail_condition:
+      any_of:
+        - after_ticks: 4501
+        - not: {building_count_gte: {type: fact, n: 1}}
+    max_turns: 60

tests/test_build_sell_and_rebuild_elsewhere.py

@@ -0,0 +1,548 @@
+"""build-sell-and-rebuild-elsewhere pack — no-cheat validation on Rust.
+
+Wave-8 capital reallocation pack. The pack tests SELL-AND-REBUILD as
+a reasoning primitive: the agent's exposed refinery (proc) on the
+centre lane will be razed by a `hunt` band, and starting cash alone
+is NOT enough to build a new proc. The only path to a fresh proc at
+the safe target region inside the tick budget is:
+
+    1. `sell(proc_id)`                ⇒ refunds 50% of proc cost (700)
+    2. `build('proc')` + `place_building(proc, x, y)`  in the safe region
+
+The win predicate makes the SELL load-bearing:
+
+* `building_in_region:{type:proc, x:safe_x, y:safe_y, radius:6, count:1}`
+  ⇒ a fresh proc must STAND at the safe target region (not the centre
+  lane; not anywhere outside the radius);
+* `building_count_gte:{type:fact, n:1}` ⇒ the Construction Yard must
+  still be alive (the PRESENT-TENSE predicate, not `has_building:fact`
+  which is a one-shot ever-seen set — CLAUDE.md footgun);
+* `within_ticks: 4500` paired with `after_ticks: 4501` in fail ⇒ the
+  episode end is a real reachable timeout LOSS, never a draw.
+
+The scripted-policy validations prove deterministically that:
+
+* the intended SELL-THEN-REBUILD policy WINS every (level, seed);
+* stall (observe only), build-without-selling (cash gated), and
+  sell-then-misplace (new proc on the y=20 lane) all LOSE every
+  (level, seed) — real LOSS, not draw;
+* the hard tier defines ≥2 spawn_point groups (NORTH y=4 / SOUTH
+  y=36) so a memorised "place at (16, 8)" cell cell that worked on
+  easy/medium FAILS on the SOUTH spawn (the matching safe region
+  there is (16, 36)).
+
+NOTE on building ids: `sell` requires the real engine actor id
+(e.g. `1003`), which the bench's `render_state["own_buildings"]`
+strips. The scripted policies below reach into `_raw["own_buildings"]`
+(via a small custom episode loop) to look up the proc id by cell.
+The model-evaluation path is a separate concern: the model issues
+sell-like reasoning and the win predicate is what actually grades
+the outcome (real proc presence at the safe region).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+pytest.importorskip("openra_rl_training", reason="Rust env wheel not installed")
+
+from openra_bench.eval_core import (
+    RustEnvPool,
+    _scenario_to_tmp_yaml,
+    run_level,
+)
+from openra_bench.rust_adapter import RustObsAdapter
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+from openra_bench.scenarios.win_conditions import WinContext, evaluate
+
+PACK = PACKS_DIR / "build-sell-and-rebuild-elsewhere.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+
+# ── custom episode loop with raw building-id access ──────────────────
+
+
+def _run_with_id_aware_policy(compiled, policy, seed):
+    """Run an episode where the policy is given (rs, raw, Command) and
+    can read `raw["own_buildings"][i]["id"]` (the real engine actor
+    id). Mirrors `run_level`'s win/fail/draw scoring without changing
+    the standard policy contract.
+    """
+    tmp = _scenario_to_tmp_yaml(compiled)
+    pool = RustEnvPool(size=1, scenario_path=tmp)
+    env = pool.acquire()
+    try:
+        adapter = RustObsAdapter()
+        adapter.observe(env.reset(seed=seed))
+        outcome = "draw"
+        turns = 0
+        for turns in range(1, compiled.max_turns + 1):
+            rs = adapter.render_state()
+            raw = adapter._raw  # for building ids
+            cmds = policy(rs, raw, env.Command) or [env.Command.observe()]
+            obs, _r, done, _info = env.step(cmds)
+            adapter.observe(obs, done=done)
+            ctx = WinContext(
+                signals=adapter.signals,
+                render_state=adapter.render_state(),
+            )
+            if evaluate(compiled.win_condition, ctx):
+                outcome = "win"
+                break
+            if evaluate(compiled.fail_condition, ctx):
+                outcome = "loss"
+                break
+            if done:
+                break
+        return outcome, turns, adapter.signals
+    finally:
+        pool.release(env)
+        pool.shutdown()
+        Path(tmp).unlink(missing_ok=True)
+
+
+def _proc_id_at(raw, y):
+    """Lookup the engine actor id of an own proc at the given y. None
+    if no matching proc is alive."""
+    for b in (raw.get("own_buildings") or []):
+        if b.get("type") == "proc" and int(b.get("cell_y", -1)) == y:
+            return str(b["id"])
+    return None
+
+
+def _own_proc_at(raw, y_band):
+    """Any own proc inside ``y_band`` (a (lo, hi) inclusive interval)."""
+    for b in (raw.get("own_buildings") or []):
+        if (
+            b.get("type") == "proc"
+            and y_band[0] <= int(b.get("cell_y", -1)) <= y_band[1]
+        ):
+            return b
+    return None
+
+
+def _fact_y(raw):
+    """Latitude of the agent's fact (4 on NORTH spawn / 4 on hard NORTH /
+    36 on hard SOUTH). Used by the hard-tier intended policy to pick
+    the matching safe target region."""
+    for b in (raw.get("own_buildings") or []):
+        if b.get("type") == "fact":
+            return int(b.get("cell_y", 4))
+    return 4
+
+
+# ── scripted policies ───────────────────────────────────────────────
+
+
+def stall(rs, C):
+    """Observe-only — proc razed, no new proc placed. LOSS."""
+    return [C.observe()]
+
+
+def make_build_without_selling(safe_x=16, safe_y=8):
+    """Try to BUILD + PLACE a new proc WITHOUT selling the exposed one.
+    Cash starts at 700/800 — well under the 1400 build cost — so the
+    `build('proc')` queue starts but never completes (no income
+    source). No new proc ⇒ region clause unmet ⇒ LOSS.
+
+    NOTE: queue insufficient cash is silently ignored by the engine
+    (production gates on cash > cost); the build never progresses.
+    """
+
+    def policy(rs, raw, C):
+        cmds = []
+        # Find any safe-region proc to terminate early once present.
+        if any(
+            b.get("type") == "proc" and int(b.get("cell_y", -1)) != 20
+            for b in (raw.get("own_buildings") or [])
+        ):
+            return [C.observe()]
+        prod_items = [
+            (p.get("item") if isinstance(p, dict) else p)
+            for p in (rs.get("production") or [])
+        ]
+        if "proc" not in prod_items:
+            cmds.append(C.build("proc"))
+        cmds.append(C.place_building("proc", safe_x, safe_y))
+        return cmds or [C.observe()]
+
+    return policy
+
+
+def make_sell_then_misplace(safe_x_wrong=60, safe_y_wrong=20):
+    """SELL the exposed proc (refund + cash buys a new proc) but
+    PLACE the new proc back IN THE CENTRE LANE — outside the safe
+    target region disc. The new proc satisfies `building_count_gte`
+    but NOT `building_in_region` — LOSS.
+    """
+    state = {"sold": False}
+
+    def policy(rs, raw, C):
+        cmds = []
+        if not state["sold"]:
+            pid = _proc_id_at(raw, 20)
+            if pid:
+                cmds.append(C.sell([pid]))
+                state["sold"] = True
+        # No existing safe-region proc — but we deliberately place
+        # back on the y=20 lane to demonstrate the misplace cost.
+        prod_items = [
+            (p.get("item") if isinstance(p, dict) else p)
+            for p in (rs.get("production") or [])
+        ]
+        if "proc" not in prod_items:
+            cmds.append(C.build("proc"))
+        cmds.append(C.place_building("proc", safe_x_wrong, safe_y_wrong))
+        return cmds or [C.observe()]
+
+    return policy
+
+
+def make_intended_easy_medium(safe_x=16, safe_y=8):
+    """Intended SELL-THEN-REBUILD play for easy/medium (fact at
+    (4, 4) so safe region is (16, 8)).
+
+    Turn 1: sell the exposed proc (refunds 700, total cash → 1500).
+    Continuously: queue `build('proc')` + `place_building` at the
+    safe target region. The build completes ~1400 ticks after queue;
+    place_building lands at (16, 8). Win clause fires.
+    """
+    state = {"sold": False}
+
+    def policy(rs, raw, C):
+        cmds = []
+        if not state["sold"]:
+            pid = _proc_id_at(raw, 20)
+            if pid:
+                cmds.append(C.sell([pid]))
+                state["sold"] = True
+        # Skip if the safe-region proc already exists.
+        if any(
+            b.get("type") == "proc" and int(b.get("cell_y", -1)) != 20
+            for b in (raw.get("own_buildings") or [])
+        ):
+            return cmds or [C.observe()]
+        prod_items = [
+            (p.get("item") if isinstance(p, dict) else p)
+            for p in (rs.get("production") or [])
+        ]
+        if "proc" not in prod_items:
+            cmds.append(C.build("proc"))
+        cmds.append(C.place_building("proc", safe_x, safe_y))
+        return cmds or [C.observe()]
+
+    return policy
+
+
+def make_intended_hard_adaptive():
+    """Intended SELL-THEN-REBUILD play for hard (fact at either y=4 or
+    y=36 by seed). Reads the fact's actual y from the observation on
+    turn 1, then places the new proc at the matching safe region —
+    (16, 8) for NORTH spawn, (16, 36) for SOUTH spawn.
+    """
+    state = {"sold": False, "safe_xy": None}
+
+    def policy(rs, raw, C):
+        if state["safe_xy"] is None:
+            fy = _fact_y(raw)
+            state["safe_xy"] = (16, 8 if fy < 20 else 36)
+        sx, sy = state["safe_xy"]
+        cmds = []
+        if not state["sold"]:
+            pid = _proc_id_at(raw, 20)
+            if pid:
+                cmds.append(C.sell([pid]))
+                state["sold"] = True
+        # Skip if the safe-region proc already exists.
+        if any(
+            b.get("type") == "proc" and int(b.get("cell_y", -1)) != 20
+            for b in (raw.get("own_buildings") or [])
+        ):
+            return cmds or [C.observe()]
+        prod_items = [
+            (p.get("item") if isinstance(p, dict) else p)
+            for p in (rs.get("production") or [])
+        ]
+        if "proc" not in prod_items:
+            cmds.append(C.build("proc"))
+        cmds.append(C.place_building("proc", sx, sy))
+        return cmds or [C.observe()]
+
+    return policy
+
+
+def make_memorised_north_only():
+    """Naive: always place at (16, 8) (the easy/medium safe region).
+    On hard SOUTH spawn (fact at y=36), the safe region is (16, 36),
+    so a place at (16, 8) lands outside the matching radius-6 disc
+    AND outside the SOUTH disc — LOSS on SOUTH seeds.
+    """
+    state = {"sold": False}
+
+    def policy(rs, raw, C):
+        cmds = []
+        if not state["sold"]:
+            pid = _proc_id_at(raw, 20)
+            if pid:
+                cmds.append(C.sell([pid]))
+                state["sold"] = True
+        if any(
+            b.get("type") == "proc" and int(b.get("cell_y", -1)) != 20
+            for b in (raw.get("own_buildings") or [])
+        ):
+            return cmds or [C.observe()]
+        prod_items = [
+            (p.get("item") if isinstance(p, dict) else p)
+            for p in (rs.get("production") or [])
+        ]
+        if "proc" not in prod_items:
+            cmds.append(C.build("proc"))
+        cmds.append(C.place_building("proc", 16, 8))
+        return cmds or [C.observe()]
+
+    return policy
+
+
+# ── scenario-shape invariants ───────────────────────────────────────
+
+
+def test_pack_compiles_with_three_levels_and_hunt_bot():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "build-sell-and-rebuild-elsewhere"
+    assert pack.meta.capability == "reasoning"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+    # Required-by-spec benchmark anchors (capital reallocation idiom).
+    anchors = [a.lower() for a in pack.meta.benchmark_anchor]
+    assert any("capital reallocation" in a for a in anchors), pack.meta.benchmark_anchor
+    assert any("sc2 sell mechanic" in a for a in anchors), pack.meta.benchmark_anchor
+    assert any(
+        "financial reallocation" in a for a in anchors
+    ), pack.meta.benchmark_anchor
+    # Hunt bot is wired through to the engine for every level (per-unit
+    # nearest-foe targeting, so the proc on the centre lane is the
+    # front piece, not the off-axis fact — see pack header).
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.map_supported
+        bot = getattr(c.scenario.enemy, "bot_type", None) or getattr(
+            c.scenario.enemy, "bot", None
+        )
+        assert str(bot).lower() == "hunt", (lvl, bot)
+
+
+def test_sell_is_exposed_in_the_tool_palette():
+    """`sell` is the load-bearing primitive — the pack would be
+    unsolvable without it (build('proc') is cash-gated, the agent has
+    no income source, the exposed proc would just be razed)."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        tools = set(getattr(c.scenario, "tools", None) or [])
+        assert "sell" in tools, (lvl, tools)
+        assert "build" in tools, (lvl, tools)
+        assert "place_building" in tools, (lvl, tools)
+
+
+def test_starting_cash_is_below_proc_build_cost_on_every_tier():
+    """Cash + sell-refund must just barely cover the proc rebuild
+    (cash 700-800; refund 700; proc cost 1400). Without the refund
+    the cash alone falls short — that gap is the load-bearing
+    discrimination."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        # cash < 1400 (proc cost) ⇒ build-without-selling is impossible.
+        assert c.starting_cash < 1400, (lvl, c.starting_cash)
+        # cash + 700 refund ≥ 1400 ⇒ sell-then-rebuild is feasible.
+        assert c.starting_cash + 700 >= 1400, (lvl, c.starting_cash)
+
+
+@pytest.mark.parametrize("level", LEVELS)
+def test_every_level_has_a_reachable_timeout_fail(level):
+    """Non-win must be a real LOSS: the `after_ticks` fail clause must
+    be strictly below the tick reachable at max_turns (interrupt mode
+    advances ≤90 ticks per step; some steps are shorter due to
+    enemy_unit_spotted events, so the empirical reachable tick is
+    ~4698 at 60 turns)."""
+    c = compile_level(load_pack(PACK), level)
+    assert c.fail_condition is not None
+    fc = c.fail_condition.model_dump(exclude_none=True)
+    deadline = None
+    for clause in fc.get("any_of", []) or []:
+        if "after_ticks" in clause:
+            deadline = int(clause["after_ticks"])
+    assert deadline is not None, f"{level}: no after_ticks fail clause"
+    # 60 turns × ~78 ticks/turn (event-shortened) ≈ 4680; 4501
+    # deadline reliably bites.
+    assert deadline < 4700, (
+        f"{level}: deadline {deadline} unreachable within {c.max_turns} "
+        f"turns (interrupt mode ≈ 4680 max tick) → draw degeneracy"
+    )
+
+
+def test_fact_alive_clause_uses_present_tense_predicate():
+    """The fact-survival clause must use the PRESENT-TENSE predicate
+    (`building_count_gte:{type:fact,n:1}`) rather than `has_building`,
+    which is a one-shot "ever seen" set that stays true after the
+    fact is destroyed (a documented CLAUDE.md footgun)."""
+    for lvl in LEVELS:
+        c = compile_level(load_pack(PACK), lvl)
+        fc = c.fail_condition.model_dump(exclude_none=True)
+        fact_clauses = [
+            clause for clause in fc.get("any_of", []) or []
+            if isinstance(clause, dict)
+            and isinstance(clause.get("not"), dict)
+            and "building_count_gte" in (clause["not"] or {})
+            and (clause["not"]["building_count_gte"] or {}).get("type") == "fact"
+        ]
+        assert fact_clauses, f"{lvl}: missing present-tense fact-alive fail clause"
+
+
+def test_hard_has_two_spawn_point_groups_and_fact_flips():
+    """Hard-tier contract: ≥2 distinct agent spawn_point groups so the
+    fact (and therefore the safe target region for proc placement)
+    flips by seed. The two groups must define the NORTH (y=4) and
+    SOUTH (y=36) fact pair."""
+    c = compile_level(load_pack(PACK), "hard")
+    groups = {
+        a.spawn_point for a in c.scenario.actors
+        if a.owner == "agent" and a.spawn_point is not None
+    }
+    assert groups == {0, 1}, groups
+    fact_ys = sorted({
+        a.position[1] for a in c.scenario.actors
+        if a.owner == "agent" and a.type == "fact"
+    })
+    assert fact_ys == [4, 36], fact_ys
+    # In-bounds check (rush-hour-arena playable x ≈ 2..126, y ≈ 2..38).
+    for a in c.scenario.actors:
+        x, y = a.position
+        assert 2 <= x <= 126 and 2 <= y <= 38, (a.type, a.position)
+
+
+# ── solvency: intended SELL-THEN-REBUILD wins every (level, seed) ────
+
+
+@pytest.mark.parametrize("level", ("easy", "medium"))
+def test_intended_sell_then_rebuild_wins_easy_medium(level):
+    c = compile_level(load_pack(PACK), level)
+    for seed in SEEDS:
+        outcome, turns, sig = _run_with_id_aware_policy(
+            c, make_intended_easy_medium(), seed
+        )
+        assert outcome == "win", (
+            f"{level} seed{seed}: intended SELL-THEN-REBUILD must WIN; "
+            f"got {outcome} (tick={sig.game_tick}, "
+            f"buildings={sig.own_buildings})"
+        )
+
+
+def test_intended_hard_adaptive_wins_every_seed():
+    """Hard tier: the intended policy must read the fact's latitude
+    (NORTH y=4 vs SOUTH y=36) and pick the matching safe target
+    region. WINS on every seed."""
+    c = compile_level(load_pack(PACK), "hard")
+    for seed in SEEDS:
+        outcome, turns, sig = _run_with_id_aware_policy(
+            c, make_intended_hard_adaptive(), seed
+        )
+        assert outcome == "win", (
+            f"hard seed{seed}: intended adaptive sell-then-rebuild must "
+            f"WIN; got {outcome} (tick={sig.game_tick}, "
+            f"buildings={sig.own_buildings})"
+        )
+
+
+# ── no-cheat: every lazy / wrong policy LOSES (not draws) ────────────
+
+
+@pytest.mark.parametrize("level", LEVELS)
+def test_stall_loses_every_level_and_seed(level):
+    """STALL: observe only. The hunt band razes the exposed proc and
+    the agent never places a new one ⇒ region clause unmet AND clock
+    runs out ⇒ real LOSS, not draw."""
+    c = compile_level(load_pack(PACK), level)
+    for seed in SEEDS:
+        r = run_level(c, stall, seed=seed)
+        assert r.outcome == "loss", (
+            f"{level} seed{seed} stall: must LOSE (real fail, not draw); "
+            f"got {r.outcome} (tick={r.signals.game_tick}, "
+            f"buildings={r.signals.own_buildings})"
+        )
+
+
+@pytest.mark.parametrize("level", ("easy", "medium"))
+def test_build_without_selling_loses_easy_medium(level):
+    """BUILD WITHOUT SELLING: `build('proc')` is rejected until cash
+    ≥ 1400; the agent has no income source, the build never starts,
+    no proc lands at the safe region ⇒ LOSS."""
+    c = compile_level(load_pack(PACK), level)
+    for seed in SEEDS:
+        outcome, turns, sig = _run_with_id_aware_policy(
+            c, make_build_without_selling(), seed
+        )
+        assert outcome == "loss", (
+            f"{level} seed{seed} build-without-selling: must LOSE; "
+            f"got {outcome} (tick={sig.game_tick}, "
+            f"buildings={sig.own_buildings})"
+        )
+
+
+@pytest.mark.parametrize("level", ("easy", "medium"))
+def test_sell_then_misplace_loses_easy_medium(level):
+    """SELL-THEN-MISPLACE: sells the exposed proc and uses the
+    refund to build a NEW proc, but places it back in the central
+    lane (y=20) — outside the safe target region disc. Region clause
+    unmet ⇒ LOSS."""
+    c = compile_level(load_pack(PACK), level)
+    for seed in SEEDS:
+        outcome, turns, sig = _run_with_id_aware_policy(
+            c, make_sell_then_misplace(), seed
+        )
+        assert outcome == "loss", (
+            f"{level} seed{seed} sell-then-misplace: must LOSE; "
+            f"got {outcome} (tick={sig.game_tick}, "
+            f"buildings={sig.own_buildings})"
+        )
+
+
+def test_memorised_north_only_loses_on_hard_south_seeds():
+    """The non-adaptive "always place at (16, 8)" policy WINS hard
+    seeds whose spawn is NORTH (fact at y=4 ⇒ matching safe region is
+    (16, 8)) but FAILS hard seeds whose spawn is SOUTH (fact at y=36
+    ⇒ matching safe region is (16, 36), and (16, 8) is outside the
+    SOUTH disc). The spawn-driven discrimination: at least one of
+    the 4 hard seeds must LOSE."""
+    c = compile_level(load_pack(PACK), "hard")
+    losses = 0
+    for seed in SEEDS:
+        outcome, turns, sig = _run_with_id_aware_policy(
+            c, make_memorised_north_only(), seed
+        )
+        if outcome == "loss":
+            losses += 1
+    assert losses >= 1, (
+        f"hard: memorised-north-only must LOSE on ≥1 of {len(SEEDS)} "
+        f"seeds (spawn-driven discrimination); got {losses} losses"
+    )
+
+
+# ── determinism ──────────────────────────────────────────────────────
+
+
+def test_intended_run_is_deterministic_on_easy():
+    c = compile_level(load_pack(PACK), "easy")
+    a_outcome, a_turns, a_sig = _run_with_id_aware_policy(
+        c, make_intended_easy_medium(), seed=3
+    )
+    b_outcome, b_turns, b_sig = _run_with_id_aware_policy(
+        c, make_intended_easy_medium(), seed=3
+    )
+    assert (a_outcome, a_turns, a_sig.units_killed) == (
+        b_outcome, b_turns, b_sig.units_killed,
+    ), "same seed must be deterministic"

tests/test_hard_tier.py

@@ -926,6 +926,23 @@ UPGRADED = [
     # targets so the agent's infantry strike force racks up kills
     # without being attrited in transit.
     "lh-econ-army-victory",
+    # Wave-8 REASONING capital reallocation pack — SC2 sell mechanic
+    # for refund / financial CAPEX reallocation / business continuity
+    # asset redeployment anchor. Starting cash alone is below the
+    # proc rebuild cost, so the agent MUST sell the exposed central-
+    # lane proc to recoup 50% capital (refund 700) and use the refund
+    # + on-hand cash to build a fresh proc at the safe target region.
+    # Hard tier defines two agent spawn_point groups (NORTH base at
+    # y=4 / SOUTH base at y=36) round-robined by seed; the win
+    # predicate pairs each safe-region clause with the matching
+    # spawn-fact's corner clause, so a memorised "always place at
+    # (16, 8)" opening wins NORTH seeds by coincidence but loses
+    # SOUTH seeds (NORTH-fact-corner clause unmet AND SOUTH-proc-
+    # region clause unmet). The central hunt band is symmetric across
+    # y=20 (enemy actors don't honour spawn_point — CLAUDE.md), so
+    # both spawns face the same sell-then-rebuild discipline from a
+    # flipped base latitude.
+    "build-sell-and-rebuild-elsewhere",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation