feat(scenario): econ-multi-patch-allocation — balanced harv allocation across patches (SC2LE / OR Weber-multi anchor)

Group F Wave-4 reasoning pack: 3 (or 4 at hard) ore patches at varied
distances from the single refinery, agent owns 3 harvesters. Optimal
allocation must deprioritise FAR/MID patches because round-trip travel
dominates throughput in this engine (verified yields: NEAR ~9000
cr/harv/4500t, MID ~2000, FAR ~1000 — ~9x ratio). The textbook 'one
harvester per source' uniform-split heuristic loses; any allocation
that concentrates harvs on the NEAREST patch wins.

Bar enforced (scripted validation, seeds 1-4):
EASY (2 patches, 2 harvs, bar 8000):
stall LOSS, both-far LOSS, both-near WIN, split WIN.
MEDIUM (3 patches, 3 harvs, bar 14000):
stall/all-far/all-mid/uniform-1-1-1/1-near-2-mid LOSS;
2-near-1-mid (intended balanced)/2-near-1-far/all-near WIN.
HARD (4 patches, 3 harvs, 2 spawn groups, bar 22000):
stall/all-far LOSS every seed; memorised-NORTH-near LOSS on
SOUTH-base seeds (and vice-versa); spawn-matched all-near WIN
every seed. ≥2 spawn_point groups (NORTH y=14 / SOUTH y=28) so
the NEAREST patch flips per seed — the capability is 'identify
your nearest patch from your start', not 'memorise a cell'.

Tick-aligned deadlines (within_ticks == after_ticks at engine
ceiling 93+90*(max_turns-1)) so a non-finisher LOSES, not draws.
Pre-placed inert e1 marker (stance:0, far from harvest envelope)
prevents premature engine auto-done on 'all enemies dead'.

Registered in tests/test_hard_tier.py::UPGRADED.

Benchmark anchors: SC2LE worker/mineral-patch allocation; OR
multi-source facility-location (Weber-multi-source); supply-chain
warehouse-to-supplier assignment; queueing-theory server allocation
across patches.

Model smoke (Qwen/Qwen3.6-Plus via together, medium seed 1): loss
composite 0.2452, objective progress 0.4996 — the discrimination
axis bites cleanly on a real frontier model.

openra_bench/scenarios/packs/econ-multi-patch-allocation.yaml

@@ -0,0 +1,218 @@
+meta:
+  id: econ-multi-patch-allocation
+  title: Economy — Multi-Patch Harvester Allocation (Weber Multi-Source)
+  capability: reasoning
+  real_world_meaning: >
+    Multi-source resource allocation under heterogeneous transport
+    cost. The agent owns 3 harvesters and faces 3 (or 4 at hard)
+    pre-placed ore patches at varied distances from the single
+    refinery: a NEAR patch, a MID patch, and a FAR patch. Income per
+    harvester scales inversely with the round-trip travel time to the
+    refinery, so allocating a harvester to the FAR patch yields ~1000
+    cr over 4500 ticks while the NEAR patch yields ~9000 cr per
+    harvester over the same window. The naive "one harvester per
+    patch" uniform split — the textbook diversification heuristic from
+    a model with no transport-cost prior — is dominated by any
+    near-prioritising allocation. Stalling earns nothing and loses;
+    committing everything to FAR or MID also loses (travel kills
+    throughput). The capability under test is the OR Weber-multi /
+    SC2-mineral-patch insight: distance-weighted throughput, not
+    "spread parallelism", drives allocation.
+  robotics_analogue: >
+    Warehouse-to-supplier assignment in a multi-source supply chain
+    (Weber multi-source / facility-location): a fleet of collectors,
+    several supply nodes at heterogeneous distances from a single
+    depot, and the optimal policy assigns collectors to MINIMISE
+    weighted travel time, not to "use every source" out of false
+    diversification. Equivalently: server allocation across queueing-
+    theory stations where each station's service rate is already
+    set and the cost is the round-trip transit, so the lowest-
+    transit-cost station soaks the most capacity.
+  author: catalog-f3
+  benchmark_anchor:
+    - SC2LE worker / mineral patch allocation
+    - OR multi-source facility-location (Weber-multi-source)
+    - supply-chain warehouse-to-supplier assignment
+    - "queueing-theory: server allocation across patches"
+
+# ENGINE NOTE (verified 2026-05-19 against installed openra_train wheel,
+# post-S0/S1 harvest income — Task #14, scripted run_level seeds 1-4):
+# 1. Per-harvester yields over 4500 ticks (50 turns) on rush-hour-arena,
+#    proc at (12,18), harvs prestaged at (14,18..22):
+#       NEAR  (16,18)  — ~9000 cr/harv  (1 harv: 8000, 2: 18000, 3: 27325)
+#       MID   (40,18)  — ~2000 cr/harv  (1 harv: 2000, 2: 4000, 3: 6000)
+#       FAR   (80,18)  — ~1000 cr/harv  (1 harv: 1000, 2: 2000, 3: 3000)
+#    Yields scale linearly with harv count up to ~3 at NEAR (no
+#    contention observed); MID/FAR scale perfectly linearly because
+#    travel-time-bound, not ore-bound. The ~9x NEAR vs FAR ratio is
+#    the discrimination signal — the model must identify that distance
+#    dominates throughput, not "use every patch" diversification.
+# 2. The smoke-tested allocation outcomes at 4500 ticks (medium budget):
+#       stall                     0 cr           LOSS at any bar > 0
+#       3-to-FAR              3,000 cr           LOSS at bar > 3000
+#       3-to-MID              6,000 cr           LOSS at bar > 6000
+#       1-NEAR + 1-MID + 1-FAR (uniform)   11,000 cr   LOSS at bar ≥ 12000
+#       1-NEAR + 2-MID                     12,000 cr   LOSS at bar ≥ 13000
+#       2-NEAR + 1-FAR                     19,000 cr   WIN at bar ≤ 19000
+#       2-NEAR + 1-MID                     20,000 cr   WIN at bar ≤ 20000
+#       3-to-NEAR                         27,325 cr   WIN at bar ≤ 27000
+#    With bar = 14000, the WIN set is "any 2 or 3 harvs on the NEAR
+#    patch" (plus the trivial 3-to-NEAR); the LOSS set is "uniform
+#    split", "MID/FAR-only", and "stall" — exactly the capability
+#    asked. The uniform "one per patch" heuristic LOSES by ~3000 cr.
+# 3. The `harvest` order with an explicit target cell directs the harv
+#    to that specific patch (it does not auto-spread to other patches
+#    even after depleting; the order persists). This is the policy
+#    knob the model uses to pick a patch per harvester.
+# 4. Tick budget: engine advances ~90 ticks per decision turn. Easy
+#    and medium both use max_turns=50 → ceiling 4503 → within_ticks
+#    = 4500. Hard uses max_turns=80 → ceiling 7203 → within_ticks =
+#    7200. fail_condition.after_ticks sits at the same boundary so a
+#    non-finisher LOSES (not draws).
+# 5. The pre-placed proc + fact + harvs trigger ConquestVictoryConditions
+#    — without a persistent enemy actor the engine would auto-`done`
+#    once "all enemies dead" trivially. An unarmed e1 at (120,36)
+#    with stance:0 sits well outside the agent's harvest envelope so
+#    it can't be killed and the win/fail predicate evaluates cleanly.
+# 6. Hard tier spawn round-robin (verified seeds 1-4): seeds 1,3 pick
+#    spawn_point 1 (SOUTH base, proc at y=28); seeds 2,4 pick
+#    spawn_point 0 (NORTH base, proc at y=14). The four neutral
+#    mines place at the SAME cells across both spawns (CLAUDE.md:
+#    "spawn_point filter applies ONLY to AGENT actors"), but the
+#    NEAREST patch flips per seed — (16,14) for spawn 0 (NORTH),
+#    (16,28) for spawn 1 (SOUTH). A memorised "always send to
+#    (16,14)" policy loses on the SOUTH-base seeds (yield ~16500
+#    vs ~38000 on the matched-near patch), so the capability is
+#    "identify your nearest patch from your start, then allocate".
+base_map: rush-hour-arena
+starting_cash: 0
+
+base:
+  agent:
+    faction: allies
+  enemy:
+    faction: soviet
+  tools:
+    - observe
+    - harvest
+    - move_units
+    - stop
+  planning: true
+  termination:
+    max_ticks: 40000
+  actors:
+    # Pre-placed agent base + 3 harvs centred on row y=18..22.
+    - {type: fact, owner: agent, position: [10, 22]}
+    - {type: proc, owner: agent, position: [12, 18]}
+    - {type: harv, owner: agent, position: [14, 18]}
+    - {type: harv, owner: agent, position: [14, 20]}
+    - {type: harv, owner: agent, position: [14, 22]}
+    # NEAR patch (~16 cells out — yields ~9000 cr/harv/4500t).
+    - {type: mine, owner: neutral, position: [16, 18]}
+    # MID patch (~28 cells from proc — yields ~2000 cr/harv/4500t).
+    - {type: mine, owner: neutral, position: [40, 18]}
+    # FAR patch (~68 cells from proc — yields ~1000 cr/harv/4500t).
+    - {type: mine, owner: neutral, position: [80, 18]}
+    # Inert enemy marker far from the harvest envelope keeps the
+    # episode from auto-terminating on "all enemies dead" before
+    # the win/fail predicate is evaluated.
+    - {type: e1, owner: enemy, position: [120, 36], stance: 0}
+
+levels:
+  easy:
+    description: >
+      Two patches (NEAR at (16,18), FAR at (80,18)) and 2 harvesters.
+      Sending BOTH to FAR yields only ~2000 cr — well below the 8000
+      bar; sending at least one to NEAR clears it (1 NEAR = 8000;
+      2 NEAR = 18000). Stalling earns nothing and loses. The capability
+      asked is "identify the near patch and prioritise it" — any
+      allocation that uses NEAR ≥ once wins; the FAR-only allocation
+      loses.
+    starting_cash: 0
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 22]}
+        - {type: proc, owner: agent, position: [12, 18]}
+        - {type: harv, owner: agent, position: [14, 18]}
+        - {type: harv, owner: agent, position: [14, 20]}
+        - {type: mine, owner: neutral, position: [16, 18]}
+        - {type: mine, owner: neutral, position: [80, 18]}
+        - {type: e1, owner: enemy, position: [120, 36], stance: 0}
+    win_condition:
+      all_of:
+        - economy_value_gte: 8000
+        - within_ticks: 4500
+    # ceiling 93 + 90*49 = 4503 ⇒ deadline bites; non-finisher LOSES.
+    fail_condition:
+      any_of:
+        - after_ticks: 4500
+        - not: {own_units_gte: 1}
+        - not: {has_building: proc}
+    max_turns: 50
+  medium:
+    description: >
+      Three patches (NEAR (16,18), MID (40,18), FAR (80,18)) and 3
+      harvesters. The naive "one harv per patch" uniform split yields
+      ~11000 cr — below the 14000 bar; allocations that prioritise
+      NEAR (2+ harvs on NEAR, or all 3) clear it cleanly. Allocating
+      ZERO harvs to NEAR (uniform 1/1/1, or any MID/FAR-only policy)
+      loses. The capability asked is the OR Weber-multi insight —
+      distance-weighted throughput, not parallelism per source.
+    starting_cash: 0
+    win_condition:
+      all_of:
+        - economy_value_gte: 14000
+        - within_ticks: 4500
+    # ceiling 93 + 90*49 = 4503 ⇒ deadline bites; non-finisher LOSES.
+    fail_condition:
+      any_of:
+        - after_ticks: 4500
+        - not: {own_units_gte: 1}
+        - not: {has_building: proc}
+    max_turns: 50
+  hard:
+    description: >
+      Four patches and 3 harvesters, with the base round-robined
+      between NORTH (y=14) and SOUTH (y=28) per seed. The neutral
+      mines stay at (16,14)/(16,28)/(40,18)/(80,18) — so the NEAREST
+      patch FLIPS per seed (NORTH spawn → (16,14); SOUTH spawn →
+      (16,28)). A memorised "always send to (16,14)" policy loses on
+      the SOUTH-base seeds (~16500 cr vs ~38000 cr on the matched-
+      near patch). Bar 22000 cr in 7200 ticks requires ≥2 harvs on
+      the spawn-matched NEAR patch; the naive uniform 1/1/1/0 split
+      across three patches yields ~16500-23000 cr (depending on
+      which patch is dropped) — too noisy to clear reliably. Stalling
+      and any FAR-only / wrong-NEAR allocation lose.
+    starting_cash: 0
+    overrides:
+      actors:
+        # spawn_point 0 — base NORTH (proc + harvs around y=14).
+        - {type: fact, owner: agent, position: [10, 14], spawn_point: 0}
+        - {type: proc, owner: agent, position: [12, 14], spawn_point: 0}
+        - {type: harv, owner: agent, position: [14, 13], spawn_point: 0}
+        - {type: harv, owner: agent, position: [14, 14], spawn_point: 0}
+        - {type: harv, owner: agent, position: [14, 15], spawn_point: 0}
+        # spawn_point 1 — base SOUTH (proc + harvs around y=28).
+        - {type: fact, owner: agent, position: [10, 28], spawn_point: 1}
+        - {type: proc, owner: agent, position: [12, 28], spawn_point: 1}
+        - {type: harv, owner: agent, position: [14, 27], spawn_point: 1}
+        - {type: harv, owner: agent, position: [14, 28], spawn_point: 1}
+        - {type: harv, owner: agent, position: [14, 29], spawn_point: 1}
+        # Four shared patches — identical to both spawns; the NEAREST
+        # flips per seed (NORTH → (16,14); SOUTH → (16,28)).
+        - {type: mine, owner: neutral, position: [16, 14]}
+        - {type: mine, owner: neutral, position: [16, 28]}
+        - {type: mine, owner: neutral, position: [40, 18]}
+        - {type: mine, owner: neutral, position: [80, 18]}
+        - {type: e1, owner: enemy, position: [120, 36], stance: 0}
+    win_condition:
+      all_of:
+        - economy_value_gte: 22000
+        - within_ticks: 7200
+    # ceiling 93 + 90*79 = 7203 ⇒ deadline bites; non-finisher LOSES.
+    fail_condition:
+      any_of:
+        - after_ticks: 7200
+        - not: {own_units_gte: 1}
+        - not: {has_building: proc}
+    max_turns: 80

tests/test_econ_multi_patch_allocation.py

@@ -0,0 +1,336 @@
+"""Full contributor-loop validation for econ-multi-patch-allocation.
+
+The pack tests Weber-multi-source / SC2-mineral-patch allocation: 3 (or
+4 at hard) ore patches at varied distances from a single refinery, the
+agent owns 3 harvesters, and yield-per-harvester scales inversely with
+round-trip travel. The capability under test is "distance dominates
+throughput; prioritise the NEAR patch" — NOT naive "one harv per
+source" diversification.
+
+Bar (per CLAUDE.md "no defect, no cheat"):
+- stall LOSES every tier.
+- All-to-FAR LOSES every tier (~1000 cr/harv/4500t).
+- All-to-MID LOSES medium/hard (~2000 cr/harv).
+- Uniform 1-per-patch LOSES medium (~11000 cr < 14000 bar).
+- Wrong-NEAR (memorised cell that matches one spawn but not the other)
+  LOSES on hard's mismatched seeds.
+- Intended capability — 2+ harvs on the spawn-matched NEAR patch — WINS
+  every tier and every seed.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+
+from openra_bench.eval_core import run_level
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+
+PACK = PACKS_DIR / "econ-multi-patch-allocation.yaml"
+
+# Base/medium patch positions
+NEAR = (16, 18)
+MID = (40, 18)
+FAR = (80, 18)
+
+# Hard tier: 4 patches; NEAREST flips per seed.
+P_NORTH = (16, 14)   # NEAREST for spawn_point 0 (NORTH base)
+P_SOUTH = (16, 28)   # NEAREST for spawn_point 1 (SOUTH base)
+H_MID = (40, 18)
+H_FAR = (80, 18)
+
+
+# ---------------------------------------------------------------- policies
+
+
+def stall_policy(rs, Command):
+    return [Command.observe()]
+
+
+def _make_alloc(targets):
+    """Send harv[i] (in id order) to targets[i] every turn. The
+    `harvest` order persists so re-issuing is idempotent."""
+    def f(rs, Command):
+        harvs = sorted(
+            (u for u in rs.get("units_summary", []) if u.get("type") == "harv"),
+            key=lambda u: u["id"],
+        )
+        cmds = [Command.harvest([str(h["id"])], *t) for h, t in zip(harvs, targets)]
+        return cmds or [Command.observe()]
+    return f
+
+
+def _make_smart_hard():
+    """Hard-tier intended policy: identify the matched NEAR patch from
+    the harvs' Y row (NORTH base → harvs at y=13..15 → near is (16,14);
+    SOUTH base → y=27..29 → near is (16,28)), then allocate all 3."""
+    def f(rs, Command):
+        harvs = sorted(
+            (u for u in rs.get("units_summary", []) if u.get("type") == "harv"),
+            key=lambda u: u["id"],
+        )
+        if not harvs:
+            return [Command.observe()]
+        y = harvs[0]["cell_y"]
+        target = P_NORTH if y < 20 else P_SOUTH
+        return [Command.harvest([str(h["id"])], *target) for h in harvs]
+    return f
+
+
+# ---------------------------------------------------------------- helpers
+
+
+def _run(level, policy_factory, seed=1):
+    c = compile_level(load_pack(PACK), level)
+    assert c.map_supported, "rush-hour-arena terrain must be present"
+    policy = policy_factory() if callable(policy_factory) else policy_factory
+    return c, run_level(c, policy, seed=seed)
+
+
+def _ev(res):
+    return res.signals.cash + res.signals.resources
+
+
+# ---------------------------------------------------------------- structural
+
+
+def test_pack_loads_and_meta_active():
+    pack = load_pack(PACK)
+    assert pack.meta.status == "active"
+    assert pack.meta.id == "econ-multi-patch-allocation"
+    assert pack.meta.capability == "reasoning"
+    anchors = pack.meta.benchmark_anchor
+    assert any("SC2LE" in a for a in anchors)
+    assert any("Weber" in a for a in anchors)
+    assert any("supply-chain" in a for a in anchors)
+    assert any("queueing" in a for a in anchors)
+
+
+def test_all_tiers_have_reachable_deadlines():
+    """tick-alignment idiom: within_ticks ≤ ceiling AND
+    after_ticks ≤ ceiling AND within_ticks == after_ticks (so a
+    non-finisher LOSES, not draws)."""
+    pack = load_pack(PACK)
+    for lvl in ("easy", "medium", "hard"):
+        L = pack.levels[lvl]
+        ceiling = 93 + 90 * (L.max_turns - 1)
+        wt = next(
+            int(c["within_ticks"])
+            for c in L.win_condition.model_dump()["all_of"]
+            if "within_ticks" in c
+        )
+        ft = next(
+            int(c["after_ticks"])
+            for c in L.fail_condition.model_dump()["any_of"]
+            if "after_ticks" in c
+        )
+        assert wt <= ceiling, f"{lvl}: within_ticks {wt} > ceiling {ceiling}"
+        assert ft <= ceiling, f"{lvl}: after_ticks {ft} > ceiling {ceiling}"
+        assert wt == ft, (
+            f"{lvl}: within_ticks {wt} != after_ticks {ft} "
+            "(non-finisher must LOSE, not draw)"
+        )
+
+
+def test_hard_has_two_seed_driven_spawn_groups():
+    """Hard tier must define ≥2 spawn_point groups so different seeds
+    place the agent at different starts (the capability test: identify
+    the NEAREST patch from YOUR base, don't memorise a fixed cell)."""
+    c = compile_level(load_pack(PACK), "hard")
+    sp = {
+        (a.spawn_point if a.spawn_point is not None else 0)
+        for a in c.scenario.actors
+        if a.owner == "agent"
+    }
+    assert len(sp) >= 2, (
+        f"hard must define ≥2 agent spawn_point groups; got {sorted(sp)}"
+    )
+
+
+# ---------------------------------------------------------------- EASY
+
+
+def test_easy_stall_loses():
+    _, res = _run("easy", lambda: stall_policy)
+    assert res.outcome == "loss", f"stall must LOSE easy; got {res.outcome} ev={_ev(res)}"
+
+
+def test_easy_all_to_far_loses():
+    _, res = _run("easy", lambda: _make_alloc([FAR, FAR]))
+    assert res.outcome == "loss", (
+        f"all-to-FAR must LOSE easy (~2000 ev < 8000 bar); "
+        f"got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_easy_both_to_near_wins():
+    _, res = _run("easy", lambda: _make_alloc([NEAR, NEAR]))
+    assert res.outcome == "win", (
+        f"both-to-NEAR must WIN easy; got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_easy_split_near_far_wins():
+    """Even the inefficient split (1 NEAR + 1 FAR) clears 8000 because
+    the NEAR harv alone supplies ~8000 cr; this is the loose-bar easy
+    tier — any allocation that USES the NEAR patch passes."""
+    _, res = _run("easy", lambda: _make_alloc([NEAR, FAR]))
+    assert res.outcome == "win", (
+        f"split-NEAR+FAR must WIN easy; got {res.outcome} ev={_ev(res)}"
+    )
+
+
+# ---------------------------------------------------------------- MEDIUM
+
+
+def test_medium_stall_loses():
+    _, res = _run("medium", lambda: stall_policy)
+    assert res.outcome == "loss", (
+        f"stall must LOSE medium; got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_medium_all_to_far_loses():
+    _, res = _run("medium", lambda: _make_alloc([FAR, FAR, FAR]))
+    assert res.outcome == "loss", (
+        f"all-to-FAR must LOSE medium (~3000 ev < 14000 bar); "
+        f"got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_medium_all_to_mid_loses():
+    _, res = _run("medium", lambda: _make_alloc([MID, MID, MID]))
+    assert res.outcome == "loss", (
+        f"all-to-MID must LOSE medium (~6000 ev < 14000 bar); "
+        f"got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_medium_uniform_split_loses():
+    """The NAIVE one-harv-per-patch heuristic LOSES medium — the
+    capability test is "transport cost dominates, not parallelism"."""
+    _, res = _run("medium", lambda: _make_alloc([NEAR, MID, FAR]))
+    assert res.outcome == "loss", (
+        f"uniform 1/1/1 split must LOSE medium (~11000 ev < 14000 bar); "
+        f"got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_medium_one_near_two_mid_loses():
+    """A "diversify slightly towards MID" allocation still under-uses
+    the NEAR patch; medium's bar bites at this margin."""
+    _, res = _run("medium", lambda: _make_alloc([NEAR, MID, MID]))
+    assert res.outcome == "loss", (
+        f"1-NEAR+2-MID must LOSE medium (~12000 ev < 14000 bar); "
+        f"got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_medium_balanced_2near_1mid_wins():
+    """The intended balanced allocation (2 harvs on NEAR + 1 on MID)
+    wins cleanly — the textbook Weber-multi answer with this geometry."""
+    _, res = _run("medium", lambda: _make_alloc([NEAR, NEAR, MID]))
+    assert res.outcome == "win", (
+        f"2-NEAR+1-MID (intended) must WIN medium; got {res.outcome} "
+        f"ev={_ev(res)}"
+    )
+
+
+def test_medium_2near_1far_wins():
+    """Variant balanced allocation also clears the bar (the NEAR
+    saturation is soft enough that an extra FAR harv adds ~1000 ev)."""
+    _, res = _run("medium", lambda: _make_alloc([NEAR, NEAR, FAR]))
+    assert res.outcome == "win", (
+        f"2-NEAR+1-FAR must WIN medium; got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_medium_all_to_near_wins():
+    """Concentrating ALL harvs on the NEAR patch is also a valid
+    optimum at this fleet size (3 harvs don't saturate the patch hard);
+    the bar discriminates "ignored NEAR" from "used NEAR", not from
+    "balanced vs concentrated"."""
+    _, res = _run("medium", lambda: _make_alloc([NEAR, NEAR, NEAR]))
+    assert res.outcome == "win", (
+        f"all-to-NEAR must WIN medium; got {res.outcome} ev={_ev(res)}"
+    )
+
+
+# ---------------------------------------------------------------- HARD
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_hard_stall_loses_every_seed(seed):
+    _, res = _run("hard", lambda: stall_policy, seed=seed)
+    assert res.outcome == "loss", (
+        f"stall must LOSE hard/seed{seed}; got {res.outcome} ev={_ev(res)}"
+    )
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_hard_all_to_far_loses_every_seed(seed):
+    _, res = _run("hard", lambda: _make_alloc([H_FAR, H_FAR, H_FAR]), seed=seed)
+    assert res.outcome == "loss", (
+        f"all-to-FAR must LOSE hard/seed{seed} (~4500 ev < 22000 bar); "
+        f"got {res.outcome} ev={_ev(res)}"
+    )
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_hard_uniform_1pn_1mid_1far_loses_every_seed(seed):
+    """The uniform "one per source" heuristic that drops one of the
+    two near patches loses every seed — too much load on transport-
+    expensive patches."""
+    _, res = _run("hard", lambda: _make_alloc([P_NORTH, H_MID, H_FAR]), seed=seed)
+    assert res.outcome == "loss", (
+        f"uniform 1-PN+1-MID+1-FAR must LOSE hard/seed{seed}; "
+        f"got {res.outcome} ev={_ev(res)}"
+    )
+
+
+def test_hard_memorised_pn_loses_on_south_spawn_seeds():
+    """A model that memorises "always send to (16,14)" loses on
+    SOUTH-base seeds (1 and 3 per round-robin) — the matched NEAR
+    patch is (16,28), and (16,14) is now ~14 cells of vertical
+    travel from the proc, dropping yield to ~16500 ev < 22000."""
+    for seed in (1, 3):
+        _, res = _run("hard", lambda: _make_alloc([P_NORTH, P_NORTH, P_NORTH]), seed=seed)
+        assert res.outcome == "loss", (
+            f"memorised-PN must LOSE hard/seed{seed} (SOUTH spawn); "
+            f"got {res.outcome} ev={_ev(res)}"
+        )
+
+
+def test_hard_memorised_ps_loses_on_north_spawn_seeds():
+    """Symmetric: memorising (16,28) loses on NORTH-base seeds 2 and 4."""
+    for seed in (2, 4):
+        _, res = _run("hard", lambda: _make_alloc([P_SOUTH, P_SOUTH, P_SOUTH]), seed=seed)
+        assert res.outcome == "loss", (
+            f"memorised-PS must LOSE hard/seed{seed} (NORTH spawn); "
+            f"got {res.outcome} ev={_ev(res)}"
+        )
+
+
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_hard_smart_spawn_matched_wins_every_seed(seed):
+    """The intended capability — identify the spawn-matched NEAR patch
+    from the agent's own base position, then concentrate harvs there —
+    WINS every seed cleanly."""
+    _, res = _run("hard", _make_smart_hard, seed=seed)
+    assert res.outcome == "win", (
+        f"SMART spawn-matched policy must WIN hard/seed{seed}; "
+        f"got {res.outcome} ev={_ev(res)}"
+    )
+
+
+# ---------------------------------------------------------------- determinism
+
+
+def test_outcomes_are_deterministic_per_seed():
+    """Same seed, same policy → identical outcome and ev."""
+    c = compile_level(load_pack(PACK), "medium")
+    a = run_level(c, _make_alloc([NEAR, NEAR, MID]), seed=2)
+    b = run_level(c, _make_alloc([NEAR, NEAR, MID]), seed=2)
+    assert (a.outcome, a.turns, _ev(a)) == (b.outcome, b.turns, _ev(b))

tests/test_hard_tier.py

@@ -109,6 +109,13 @@ UPGRADED = [
     # (two 3tnk defenders + four harvs around proc 80,20) varies
     # per seed.
     "combat-harass-aggro-commit",
+    # Group F econ reasoning (Wave-4): Weber multi-source / SC2
+    # mineral-patch allocation. Hard defines two agent spawn_point
+    # groups (NORTH base y=14 / SOUTH base y=28) round-robined by
+    # seed; the four neutral mines stay fixed but the NEAREST patch
+    # flips per seed ((16,14) for NORTH, (16,28) for SOUTH), so a
+    # memorised "always send to (16,14)" cannot generalise.
+    "econ-multi-patch-allocation",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation