feat(scenario): expansion-turtle-1-base-fortified — heavy-defense 1-base macro (SC2 fortress / military concentration anchor)

Wave-4 Group B TURTLE node of the expansion triple (siblings:
expansion-aggro-3-base-greedy GREEDY arm, tech-balanced-econ-then-
tech BALANCED arm). The agent has a single pre-placed base PLUS a
seed defence line (pre-placed pbox + 1 gun + weap) and must
FORTIFY DENSELY ENOUGH to repel an incoming hunt-bot assault while
reaching a higher defence bar (>=3/>=6/>=8 pbox + >=1/>=2/>=2 gun)
and maintaining >=3 defenders alive, all before tick 5400 with the
conyard still standing.

Expansion is STRUCTURALLY FORBIDDEN: no MCV is provided and
`deploy` is removed from the tools list (double-blocked). The
discrimination is whether the model embraces the deep-defence play
(actively REINFORCES the pre-placed pbox/gun seed against the
hunt's grinding attrition) instead of stalling, pure-army (no pbox
replacement -> defences bleed below the bar), or over-teching
(cash spent on dome/fix research instead of pbox/gun reinforcement).

Real-world anchors:
* SC2 fortress macro / 1-base mass-defence timing
* Risk-averse business: own one market deeply rather than expand thin
* Military fortress doctrine: concentrate force at impregnable site
* Defensive-vs-expansion tradeoff in capital allocation

Pack details:
* map: rush-hour-arena (128x40); hunt-bot opponent at x=95 east
lane; persistent unarmed enemy `fact` marker at x=122 as anti-
DRAW guard so non-winners emit a real reachable LOSS.
* pre-placed seed (medium): fact + tent + 2x powr + proc + harv +
mine WEST of the lane; 5 pbox + 1 gun + weap + 5 e1 + 1 e3
screen at the EAST lane mouth. Agent adds >=1 pbox + >=1 gun +
reinforcement to reach 6/2 bar under attrition.
* starting_cash 6500/8500/9500 funds the entire intended
reinforcement spend (no `harvest` tool -> idle harv = 0 cr/turn).
* within_ticks 5400 / after_ticks 5401, max_turns 62 -> reachable
tick 5583 >= 5401 (deadline bites, non-winner = real LOSS).
* hard tier: 2 spawn_point groups (NORTH y=12 / SOUTH y=28)
round-robined by seed; symmetric hunt bands at BOTH latitudes
so a memorised pbox layout from one spawn does not generalise.

No-cheat validation (deterministic, no model/network):
* stall (Command.observe()) - LOSS every level + every hard seed
(defences bleed below bar, screen wiped below 3).
* pure_army (only train e1, no defence builds) - LOSS every level
+ every hard seed (pbox bar falls below target).
* over_tech (build dome+fix instead of pbox/gun) - LOSS every
level + every hard seed (cash spent on tech, bar unmet).
* intended_fortify (reinforce pbox+gun, train e1) - WIN every
level + every hard seed.

Model smoke: Qwen3.6-Plus on medium seed 1 - LOSS (composite 0.37);
appropriate discrimination, the model did not reach the dense-
fortification bar inside the budget.

Registered in tests/test_hard_tier.py::UPGRADED.
21/21 tests in tests/test_expansion_turtle_1_base_fortified.py pass.

openra_bench/scenarios/packs/expansion-turtle-1-base-fortified.yaml

@@ -0,0 +1,421 @@
+# EXPANSION-TURTLE-1-BASE-FORTIFIED — Group B (Mid: TURTLE 1-base
+# fortification, dense static-defence supremacy over expansion).
+#
+# The TURTLE variant of the expansion triple (sister to
+# expansion-aggro-3-base-greedy and tech-balanced-econ-then-tech).
+# The agent has a SINGLE pre-placed base (fact + tent + powr + proc)
+# and NO MCV — `deploy` is removed from the tools list, so expansion
+# is structurally forbidden. The intended play is to accept the
+# 1-base cap and fortify so heavily (≥6 pbox + ≥2 gun + ≥3 defenders)
+# that an incoming hunt-bot assault (6 e1 + 2 e3) is absorbed at the
+# wall and the conyard still stands at the deadline.
+#
+# Why this is the TURTLE mirror of expansion-aggro-3-base-greedy:
+#   - AGGRO commits 3 MCVs to 3 distinct regions (growth supremacy,
+#     no defence). The hedged "hold one MCV back" play LOSES the
+#     third region.
+#   - TURTLE commits the entire economy to ONE site (defence
+#     supremacy, no growth). The hedged "build an army instead of
+#     towers" play gets ground down by the hunt band; the hedged
+#     "build towers but skip the army-throughput minimum" play
+#     stalls; the hedged "tech up instead of laying defences" play
+#     gets razed.
+#   - BALANCED (tech-balanced-econ-then-tech) sequences econ-then-
+#     tech; defences-only LOSES because the tech chain never
+#     finishes.
+#   - Together the three packs cover the canonical mid-game
+#     allocation trilemma: spread thin (AGGRO), tech deep
+#     (BALANCED), turtle wide-and-thick (TURTLE).
+#
+# Benchmark / real-world anchor:
+#   - SC2 fortress macro / 1-base mass-defence timing: stay on one
+#     base, mass static defence and a minimum army to repel an
+#     incoming all-in attack.
+#   - Risk-averse business: own one market deeply rather than
+#     expand thin — concentrate capital where you already have
+#     advantage, fortify the moat.
+#   - Military fortress doctrine: concentrate force at one
+#     impregnable site rather than disperse across multiple
+#     vulnerable outposts.
+#   - Defensive-vs-expansion tradeoff in capital allocation: when
+#     the threat is concrete (incoming hunt-bot assault) and the
+#     incremental return on expansion is uncertain, deep
+#     fortification dominates broad expansion.
+#
+# Engine tick/turn alignment (CLAUDE.md, ~90 ticks/turn):
+#   within_ticks 5400 / after_ticks 5401, max_turns 62 → reachable
+#   tick 93 + 90·61 = 5583 ≥ 5401 ✓ (the deadline bites; a stall
+#   emits a real LOSS, not a DRAW). Interrupt steps can run <90
+#   ticks/turn, so 62 turns is a comfortable buffer.
+#
+# Economy budget (per level):
+#   The pack is "fat war chest" turtle: NO `harvest` tool exposed
+#   (the turtle plays pure capex from a fat war chest, not active
+#   econ micro — keeps the discrimination cleanly on defence vs
+#   tech vs army allocation, not on harvester routing). With no
+#   harvest dispatch the pre-placed harv+proc+mine triple yields
+#   zero passive income (idle harvester does not auto-cycle
+#   without a `Command.harvest` dispatch — engine quirk noted in
+#   tests/test_econ_startup_from_scratch.py), so starting_cash
+#   must fund the entire intended REINFORCEMENT spend on top of
+#   the pre-placed seed defences. Costs (per CLAUDE.md): pbox=600,
+#   gun=800, weap=2000, e1=100, powr=300.
+#   - easy   seed: 1 pbox + weap pre-placed; agent adds ≥2 pbox + 1
+#     gun + reinforcement ≈ 2 pbox + 1 gun + 4 e1 ≈ 2400 → cash 6500
+#     covers reinforcement under attrition (extra pbox + extra e1).
+#   - medium seed: 5 pbox + 1 gun + weap pre-placed; agent adds ≥1
+#     pbox + ≥1 gun + reinforcement ≈ 3 pbox + 1 gun + 6 e1 = 3200 →
+#     cash 8500 covers reinforcement under heavier attrition.
+#   - hard   seed: 7 pbox + 1 gun + weap pre-placed; agent adds ≥1
+#     pbox + ≥1 gun + reinforcement ≈ 4 pbox + 1 gun + 6 e1 = 3800
+#     → cash 9500 covers reinforcement under doubled-flank attrition.
+#   The cap is tight enough that an over-tech skip-defence policy
+#   (e.g. spending 2000+ on dome / 2500+ on fix instead of pbox
+#   reinforcement) busts the defence bar AND gets the fact razed.
+#
+# Engine footguns applied (per CLAUDE.md):
+#   - `deploy` removed from tools so expansion is structurally
+#     forbidden (the bench advertises only what the agent can do —
+#     no MCV is provided either, double-blocked).
+#   - Persistent unarmed enemy `fact` MARKER at the far map edge
+#     prevents the all-enemies-eliminated auto-`done` so non-winners
+#     LOSE on the deadline (never DRAW). The hunt band itself is
+#     temporary — once dispatched the marker keeps the run alive
+#     until the clock or the fortification predicates resolve.
+#   - The agent starts WITH units (the pre-placed harv counts in
+#     units_summary) so the `not own_units_gte:1` fail clause is
+#     safe on turn 1 (CLAUDE.md unit-less-start footgun does not
+#     apply here). Once the harv is killed AND no defenders are
+#     trained AND the fact dies, the clause fires.
+#   - Pre-placed fact + tent + powr + proc + harv + mine so the
+#     intended sequence is: queue pbox + e1 in parallel on turn 1
+#     (Defence and Infantry queues), drop pbox at the lane mouth,
+#     keep training defenders. No build-radius gymnastics required.
+#   - Hard tier: TWO agent spawn_point groups rotate the whole
+#     starter base between a north y=12 and a south y=28 latitude.
+#     Hunt-bot composition is symmetric (the enemy bands sit at
+#     both latitudes; enemies don't honour spawn_point — CLAUDE.md)
+#     so the threat ALWAYS arrives from both flanks but the home
+#     base flips per seed — single memorised pbox cell cannot
+#     generalise.
+#   - `has_building` is MONOTONIC (never un-sets after a kill); the
+#     "fact still standing" predicate uses `building_count_gte:
+#     {type: fact, n: 1}` which iterates the per-tick refreshed
+#     own_buildings list and DOES fall to 0 when the fact is razed.
+#   - Hunt-bot (`bot_type: hunt`) actively seeks out the nearest
+#     agent unit / building; arrives at the base by ~tick 1500
+#     from the x=80 spawn given the rush-hour-arena layout.
+#   - Map: rush-hour-arena (128×40), validated for the canonical
+#     base-at-x=10, threat-at-x=80 hunt-band geometry across
+#     defense-rush-survive. All actors within playable bounds
+#     (x∈[2,126], y∈[2,38]).
+
+meta:
+  id: expansion-turtle-1-base-fortified
+  title: 'Expansion TURTLE — Fortify 1 Base (Defence Supremacy, No Expansion)'
+  capability: reasoning
+  real_world_meaning: >
+    TURTLE 1-base fortification: the agent has no second MCV and
+    no `deploy` tool — expansion is structurally off the menu.
+    The only path to win is to take the single pre-placed base
+    and harden it so densely (≥6 pillboxes + ≥2 gun turrets + a
+    minimum army of 3) that an incoming hunt-bot assault is
+    absorbed at the wall, with the home fact still standing at
+    the deadline. The discrimination is whether the model
+    embraces the deep-defence play (accepts the 1-base cap and
+    invests the whole economy in static defence + minimum army)
+    instead of defaulting to a "balanced" play that leaves the
+    base under-fortified, or a "pure army" play that gets ground
+    down without towers to anchor on, or an "over-tech" play
+    that builds research while the fact is being razed.
+  robotics_analogue: >
+    Single-site hardening under known incoming threat: a fixed
+    asset (factory, data centre, military outpost) has a known
+    incoming attack inside a fixed window, no option to relocate,
+    and no reinforcement; the only path is to invest the entire
+    budget in passive hardening (walls, turrets, hardened
+    bunkers) plus a minimum on-site response force, accepting
+    that the asset will be irrelevant outside its own perimeter.
+    Same idea in capital allocation (own one market deeply),
+    cybersecurity (concentrate WAF + IDS + bastion at the one
+    public-facing endpoint instead of spreading thin), and
+    military fortress doctrine (concentrate force at one
+    impregnable site).
+  benchmark_anchor:
+    - "SC2 fortress macro / 1-base mass-defense timing"
+    - "risk-averse business: own one market deeply"
+    - "military fortress doctrine: concentrate force at impregnable site"
+    - "defensive-vs-expansion tradeoff in capital allocation"
+  author: "openra-bench"
+
+base_map: rush-hour-arena
+
+# Pack-wide default; each level overrides with the cash needed to
+# fund EXACTLY its intended dense-fortification spend. No income
+# flows (no harvest tool exposed, idle harv = 0 cr/turn — see
+# tests/test_econ_startup_from_scratch.py engine quirk).
+starting_cash: 2500
+
+base:
+  agent: {faction: allies}
+  # Hunt-bot actively seeks the nearest agent unit/building and
+  # commits the full band to the agent's centroid (defense-rush-
+  # survive uses `rusher` for the same role; `hunt` is the
+  # generic-seek bot named in the spec).
+  enemy: {faction: soviet, bot_type: hunt}
+  # TURTLE tool list per spec: NO `deploy` (expansion structurally
+  # forbidden — bench advertises only what the agent can do). NO
+  # `harvest` either — the turtle plays pure capex from a fat war
+  # chest (starting_cash funds the entire intended reinforcement
+  # spend), keeping the discrimination cleanly on defence vs tech
+  # vs army allocation rather than on harvester routing.
+  tools: [observe, build, place_building, move_units, attack_unit, stop]
+  planning: true
+  # No interrupts: a step that fires on every enemy spotted /
+  # defender lost shortens each step to <90 ticks and the
+  # after_ticks fail cannot then be reached inside max_turns,
+  # collapsing non-winners to DRAW. Turtle play is also less
+  # interrupt-driven than the rusher / harass packs — the
+  # decision space is "lay defences and train defenders" and
+  # the engine handles the firing automatically.
+  termination: {max_ticks: 12000}
+  actors: []
+
+levels:
+  # ── EASY ────────────────────────────────────��────────────────────
+  # Degenerate-to-balanced variant: smaller hunt band (4× e1),
+  # lower fortification bars (3 pbox, 1 gun). Tests the bare
+  # "lay defences AND keep a minimum army" capability. Cash
+  # covers 3 pbox + 1 gun + weap (gun prereq) + 3 e1 ≈ 4700,
+  # plus a generous buffer for extra defenders.
+  # max_turns 62 → reachable tick 93 + 90·61 = 5583 ≥ 5401 ✓
+  easy:
+    description: >
+      TURTLE expansion easy: your single pre-placed base (fact +
+      barracks + 2× power plant + refinery + harvester) faces an
+      incoming hunt band of 4 rifle infantry. You have no MCV and
+      cannot expand. Fortify in place: build at least 3 pillboxes
+      (pbox) AND at least 1 gun turret (gun) AND have ≥3 own
+      units alive AND keep the construction yard (fact) standing,
+      all before tick 5400. A war factory (weap) is required as
+      gun's engine prerequisite — that is the only tech allowed
+      under the turtle frame. Stalling (no defences → fact razed),
+      pure-army-no-towers (e1-spam, gets ground down), and over-
+      tech-skip-defence (weap+dome+more before pbox, fact razed
+      during research) all LOSE.
+    starting_cash: 6500
+    overrides:
+      actors:
+        # West base. fact at (16,20) — eastmost of the base
+        # buildings, so the hunt band's centroid-seek targets fact
+        # FIRST (and the easy-to-replace defence line in front),
+        # not the irreplaceable tent. Tent + 2 powr + proc clustered
+        # WEST behind the fact; the screen + pbox lane mouth runs
+        # EAST of the fact, where the hunt band actually engages.
+        - {type: fact, owner: agent, position: [16, 20]}
+        - {type: tent, owner: agent, position: [8,  18]}
+        - {type: powr, owner: agent, position: [6,  20]}
+        - {type: powr, owner: agent, position: [6,  22]}
+        - {type: proc, owner: agent, position: [10, 16]}
+        - {type: harv, owner: agent, position: [10, 22]}
+        - {type: mine, owner: neutral, position: [2,  20]}
+        # Pre-placed seed: 1 pbox + weap (gun prereq) standing.
+        # The agent must ADD 2 more pbox + 1 gun to reach the
+        # 3 pbox + 1 gun bar — the irreducible turtle build chain
+        # under attack pressure. The pre-placed pbox + weap give
+        # just enough cushion that the build chain has time to
+        # complete; without the seed, the line is built too late
+        # and ganged before completion.
+        - {type: pbox, owner: agent, position: [22, 20]}
+        - {type: weap, owner: agent, position: [10, 24]}
+        # Pre-placed starting screen: 4× e1 (so the
+        # own_units_gte:3 bar starts satisfied; the discriminator
+        # is whether the agent KEEPS ≥3 alive — adds reinforcing
+        # pbox + trains replacement infantry as the hunt band
+        # grinds the screen).
+        - {type: e1,   owner: agent, position: [20, 20], stance: 3, count: 4}
+        # Smaller hunt band (4× e1) starting far east at x=95.
+        # At ~3-4 cells/turn the band needs ~20+ turns (~tick 2000)
+        # to reach the lane mouth at x=22, giving the pbox×3+gun
+        # chain time to come online.
+        - {type: e1, owner: enemy, position: [95, 20], stance: 3, count: 4}
+        # Persistent unarmed enemy marker — LOSS-not-DRAW guarantee.
+        - {type: fact, owner: enemy, position: [122, 20]}
+    win_condition:
+      all_of:
+        - building_count_gte: {type: pbox, n: 3}
+        - building_count_gte: {type: gun, n: 1}
+        # Conyard still standing — use building_count_gte (per-tick
+        # refreshed) NOT has_building (monotonic set, never un-set
+        # after a kill — CLAUDE.md footgun).
+        - building_count_gte: {type: fact, n: 1}
+        - own_units_gte: 3
+        - within_ticks: 5400
+    fail_condition:
+      any_of:
+        - after_ticks: 5401
+        - not: {building_count_gte: {type: fact, n: 1}}
+        - not: {own_units_gte: 1}
+    max_turns: 62
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # The TURTLE challenge proper: full hunt band (6× e1 + 2× e3) +
+  # dense fortification bars (≥6 pbox + ≥2 gun + ≥3 defenders +
+  # fact standing). Cash covers 6 pbox + 2 gun + weap + 3 e1 ≈
+  # 6500, plus buffer for spare defenders.
+  # max_turns 62 → reachable tick 5583 ≥ 5401 ✓
+  medium:
+    description: >
+      TURTLE expansion medium: your single pre-placed base (fact +
+      barracks + 2× power plant + refinery + harvester) faces an
+      incoming hunt band of 6 rifle infantry plus 2 rocket soldiers.
+      You have no MCV and cannot expand — you must fortify the one
+      site densely. Build at least 6 pillboxes (pbox) AND at least
+      2 gun turrets (gun) AND have ≥3 own units alive AND keep the
+      construction yard (fact) standing, all before tick 5400. A
+      war factory (weap) is required as gun's engine prerequisite.
+      Stalling (no defences → fact razed), pure-army-no-towers
+      (e1-spam, ground down without anchors), and over-tech-skip-
+      defence (weap+dome before pbox, fact razed during research)
+      all LOSE.
+    starting_cash: 8500
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [16, 20]}
+        - {type: tent, owner: agent, position: [8,  18]}
+        - {type: powr, owner: agent, position: [6,  20]}
+        - {type: powr, owner: agent, position: [6,  22]}
+        - {type: proc, owner: agent, position: [10, 16]}
+        - {type: harv, owner: agent, position: [10, 22]}
+        - {type: mine, owner: neutral, position: [2,  20]}
+        # Pre-placed seed: 5 pbox + 1 gun + weap (gun prereq).
+        # The agent must ADD ≥1 more pbox + ≥1 more gun (while
+        # reinforcing attrition losses) to reach the 6 pbox / 2
+        # gun bar under pressure from a hunt band of 6 e1 + 2 e3.
+        # Stalling (no build) → defences bleed below 6/2 (the
+        # hunt destroys ~1 pbox / 4 turns on average), bar never
+        # met. Pure-army (e1 only) → no replacement defences, bar
+        # falls below 6 mid-run. Over-tech (weap+dome+research
+        # instead of pbox/gun reinforcement) → cash spent
+        # elsewhere, bar unmet.
+        - {type: pbox, owner: agent, position: [22, 17]}
+        - {type: pbox, owner: agent, position: [22, 19]}
+        - {type: pbox, owner: agent, position: [22, 21]}
+        - {type: pbox, owner: agent, position: [22, 23]}
+        - {type: pbox, owner: agent, position: [24, 20]}
+        - {type: weap, owner: agent, position: [10, 24]}
+        - {type: gun,  owner: agent, position: [24, 18]}
+        # Heavier starting screen: 5 e1 + 1 e3 to absorb the e3
+        # rocket-soldier damage that out-ranges a single pbox.
+        - {type: e1, owner: agent, position: [20, 20], stance: 3, count: 5}
+        - {type: e3, owner: agent, position: [20, 22], stance: 3, count: 1}
+        # Canonical hunt band: 6× e1 + 2× e3 starting far east at
+        # x=95.
+        - {type: e1, owner: enemy, position: [95, 20], stance: 3, count: 6}
+        - {type: e3, owner: enemy, position: [97, 20], stance: 3, count: 2}
+        - {type: fact, owner: enemy, position: [122, 20]}
+    win_condition:
+      all_of:
+        - building_count_gte: {type: pbox, n: 6}
+        - building_count_gte: {type: gun, n: 2}
+        - building_count_gte: {type: fact, n: 1}
+        - own_units_gte: 3
+        - within_ticks: 5400
+    fail_condition:
+      any_of:
+        - after_ticks: 5401
+        - not: {building_count_gte: {type: fact, n: 1}}
+        - not: {own_units_gte: 1}
+    max_turns: 62
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 axis: TWO agent spawn_point groups rotate the whole starter
+  # base between a NORTH (y=12) and a SOUTH (y=28) latitude.
+  # Symmetric enemy hunt bands at BOTH latitudes (enemies don't
+  # honour spawn_point — CLAUDE.md), so the threat always arrives
+  # from both flanks regardless of which spawn the agent draws;
+  # but the home base flips per seed, so a single memorised pbox
+  # cell cannot generalise. Higher pbox bar (≥8) reflects the
+  # doubled threat surface. Cash 9500 covers 8 pbox + 2 gun +
+  # weap + 3 e1 ≈ 7600 plus buffer.
+  # max_turns 62 → reachable tick 5583 ≥ 5401 ✓
+  hard:
+    description: >
+      TURTLE expansion hard: your single pre-placed base spawns at
+      either the NORTH (y=12) or SOUTH (y=28) latitude depending on
+      the seed; symmetric hunt bands arrive from BOTH latitudes
+      regardless. Fortify the site you actually got: build at least
+      8 pillboxes (pbox) AND at least 2 gun turrets (gun) AND have
+      ≥3 own units alive AND keep the construction yard (fact)
+      standing, all before tick 5400. A memorised pbox layout from
+      one spawn does not generalise to the other.
+    objective_coords: relative
+    starting_cash: 9500
+    overrides:
+      enemy: {faction: soviet, bot_type: hunt}
+      actors:
+        # North-base spawn (spawn_point 0). y=12 chosen so the
+        # WEST-stacked powr/proc/tent stays in-bounds (y∈[2,38]).
+        - {type: fact, owner: agent, position: [16, 12], spawn_point: 0}
+        - {type: tent, owner: agent, position: [8,  10], spawn_point: 0}
+        - {type: powr, owner: agent, position: [6,  12], spawn_point: 0}
+        - {type: powr, owner: agent, position: [6,  14], spawn_point: 0}
+        - {type: proc, owner: agent, position: [10, 8],  spawn_point: 0}
+        - {type: harv, owner: agent, position: [10, 14], spawn_point: 0}
+        # Pre-placed seed: 7 pbox + 1 gun + weap (NORTH). Agent
+        # must add ≥1 pbox + ≥1 gun (plus reinforce attrition)
+        # to reach 8/2 bar.
+        - {type: pbox, owner: agent, position: [22, 8],  spawn_point: 0}
+        - {type: pbox, owner: agent, position: [22, 10], spawn_point: 0}
+        - {type: pbox, owner: agent, position: [22, 12], spawn_point: 0}
+        - {type: pbox, owner: agent, position: [22, 14], spawn_point: 0}
+        - {type: pbox, owner: agent, position: [22, 16], spawn_point: 0}
+        - {type: pbox, owner: agent, position: [24, 11], spawn_point: 0}
+        - {type: pbox, owner: agent, position: [24, 13], spawn_point: 0}
+        - {type: weap, owner: agent, position: [10, 16], spawn_point: 0}
+        - {type: gun,  owner: agent, position: [24, 9],  spawn_point: 0}
+        - {type: e1,   owner: agent, position: [20, 12], stance: 3, count: 5, spawn_point: 0}
+        - {type: e3,   owner: agent, position: [20, 14], stance: 3, count: 1, spawn_point: 0}
+        # South-base spawn (spawn_point 1) — symmetric layout.
+        - {type: fact, owner: agent, position: [16, 28], spawn_point: 1}
+        - {type: tent, owner: agent, position: [8,  30], spawn_point: 1}
+        - {type: powr, owner: agent, position: [6,  28], spawn_point: 1}
+        - {type: powr, owner: agent, position: [6,  26], spawn_point: 1}
+        - {type: proc, owner: agent, position: [10, 32], spawn_point: 1}
+        - {type: harv, owner: agent, position: [10, 26], spawn_point: 1}
+        - {type: pbox, owner: agent, position: [22, 24], spawn_point: 1}
+        - {type: pbox, owner: agent, position: [22, 26], spawn_point: 1}
+        - {type: pbox, owner: agent, position: [22, 28], spawn_point: 1}
+        - {type: pbox, owner: agent, position: [22, 30], spawn_point: 1}
+        - {type: pbox, owner: agent, position: [22, 32], spawn_point: 1}
+        - {type: pbox, owner: agent, position: [24, 27], spawn_point: 1}
+        - {type: pbox, owner: agent, position: [24, 29], spawn_point: 1}
+        - {type: weap, owner: agent, position: [10, 24], spawn_point: 1}
+        - {type: gun,  owner: agent, position: [24, 31], spawn_point: 1}
+        - {type: e1,   owner: agent, position: [20, 28], stance: 3, count: 5, spawn_point: 1}
+        - {type: e3,   owner: agent, position: [20, 26], stance: 3, count: 1, spawn_point: 1}
+        # Two ore patches, one per spawn cluster (engine doesn't
+        # filter neutral actors by spawn_point — both placed).
+        - {type: mine, owner: neutral, position: [2, 12]}
+        - {type: mine, owner: neutral, position: [2, 28]}
+        # Doubled hunt bands at BOTH latitudes — enemies place
+        # regardless of spawn_point so the threat is symmetric.
+        - {type: e1, owner: enemy, position: [95, 12], stance: 3, count: 5}
+        - {type: e3, owner: enemy, position: [97, 12], stance: 3, count: 1}
+        - {type: e1, owner: enemy, position: [95, 28], stance: 3, count: 5}
+        - {type: e3, owner: enemy, position: [97, 28], stance: 3, count: 1}
+        # Persistent unarmed enemy marker — LOSS-not-DRAW guarantee.
+        - {type: fact, owner: enemy, position: [122, 20]}
+    win_condition:
+      all_of:
+        - building_count_gte: {type: pbox, n: 8}
+        - building_count_gte: {type: gun, n: 2}
+        - building_count_gte: {type: fact, n: 1}
+        - own_units_gte: 3
+        - within_ticks: 5400
+    fail_condition:
+      any_of:
+        - after_ticks: 5401
+        - not: {building_count_gte: {type: fact, n: 1}}
+        - not: {own_units_gte: 1}
+    max_turns: 62

tests/test_expansion_turtle_1_base_fortified.py

@@ -0,0 +1,375 @@
+"""expansion-turtle-1-base-fortified — Wave-4 Group B TURTLE 1-base
+fortification.
+
+Scripted-policy no-defect / no-cheat validation. The pack hands the
+agent a SINGLE pre-placed base (fact + tent + 2× powr + proc + harv +
+mine + a SEED defence line of pre-placed pbox + 1 gun + weap) PLUS a
+small starting screen, and asks the agent to FORTIFY it densely
+enough to repel an incoming hunt-bot assault while reaching a higher
+defence bar (≥3/≥6/≥8 pbox + ≥1/≥2/≥2 gun) and maintaining ≥3
+defenders alive, all before tick 5400 with the conyard still standing.
+
+Expansion is structurally forbidden: no MCV is provided and `deploy`
+is removed from the tools list. The discrimination is whether the
+model embraces the deep-defence play (actively REINFORCES the
+pre-placed pbox / gun seed against the hunt's grinding attrition)
+instead of stalling, building pure army (no pbox replacement, defences
+bleed below the bar), or over-teching (cash spent on dome/fix
+research instead of pbox/gun reinforcement).
+
+The intended bar (CLAUDE.md): every lazy / single-axis / wrong-axis
+policy LOSES on every level and every hard seed (1–4); only the
+defence-reinforcement policy WINS.
+
+  - stall                     (only Command.observe())             → LOSS
+  - pure_army                 (only train e1, no defence builds)    → LOSS
+  - over_tech                 (build dome+fix instead of pbox/gun)  → LOSS
+  - intended_fortify          (reinforce pbox+gun, train e1)        → WIN
+"""
+
+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 / "expansion-turtle-1-base-fortified.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+# Per-level (pbox_target, gun_target) — must match the pack YAML.
+PARAMS = {"easy": (3, 1), "medium": (6, 2), "hard": (8, 2)}
+
+
+# ── helpers ───────────────────────────────────────────────────────────
+
+
+def _norm_prod(rs):
+    """Flatten the production list to item names (the engine emits
+    either dicts or bare strings depending on queue/version)."""
+    out = []
+    for p in (rs.get("production") or []):
+        if isinstance(p, dict):
+            out.append(p.get("item"))
+        elif isinstance(p, str):
+            out.append(p)
+    return out
+
+
+def _fact_xy(rs):
+    fact = next(
+        (b for b in (rs.get("own_buildings") or []) if b.get("type") == "fact"),
+        None,
+    )
+    if fact is None:
+        return None
+    return int(fact["cell_x"]), int(fact["cell_y"])
+
+
+def _building_counts(rs):
+    own = rs.get("own_buildings") or []
+    counts = {}
+    for b in own:
+        counts[b.get("type")] = counts.get(b.get("type"), 0) + 1
+    return counts
+
+
+# ── scripted policies ────────────────────────────────────────────────
+
+
+def stall(rs, C):
+    """Observe-only — pre-placed pbox / gun get bled down by the
+    hunt band; defences fall below the bar, screen wipes below 3."""
+    return [C.observe()]
+
+
+def pure_army(rs, C):
+    """Only ever train e1, never reinforce defences. Pre-placed pbox
+    bleeds below the bar; bar unmet at the deadline."""
+    prod = _norm_prod(rs)
+    if "e1" not in prod:
+        return [C.build("e1")]
+    return [C.observe()]
+
+
+def over_tech(rs, C):
+    """Build research buildings (dome, fix) instead of defence
+    reinforcement. Cash spent on tech; pbox bar bleeds below target."""
+    own = rs.get("own_buildings") or []
+    types = {b.get("type") for b in own}
+    prod = _norm_prod(rs)
+    xy = _fact_xy(rs)
+    if xy is None:
+        return [C.observe()]
+    fx, fy = xy
+    cmds = []
+    if "dome" not in types and "dome" not in prod:
+        cmds.append(C.build("dome"))
+    if "dome" not in types:
+        cmds.append(C.place_building("dome", fx - 6, fy + 6))
+    elif "fix" not in types and "fix" not in prod:
+        cmds.append(C.build("fix"))
+        cmds.append(C.place_building("fix", fx - 8, fy + 6))
+    if not cmds:
+        cmds.append(C.observe())
+    return cmds
+
+
+def make_intended(pbox_target: int, gun_target: int):
+    """Intended fortification policy: continuously REINFORCE the
+    pre-placed pbox seed against the hunt band's grinding attrition,
+    cap with the gun bar once pbox is at target, and train a stream
+    of replacement infantry to maintain own_units_gte:3 as the
+    starting screen takes damage.
+
+    Defence queue is SERIAL (Defense), Infantry queue is PARALLEL —
+    both held continuously full. The pbox_target+3 buffer keeps the
+    queue requesting reinforcement even when attrition holds the
+    count at target (so any single pbox kill is replaced before the
+    count dips below the bar).
+    """
+
+    placed = set()
+
+    def policy(rs, C):
+        own = rs.get("own_buildings") or []
+        occupied = {(b["cell_x"], b["cell_y"]) for b in own}
+        pbox_count = sum(1 for b in own if b.get("type") == "pbox")
+        gun_count = sum(1 for b in own if b.get("type") == "gun")
+        weap_count = sum(1 for b in own if b.get("type") == "weap")
+        prod = _norm_prod(rs)
+        n_pbox = prod.count("pbox")
+        n_gun = prod.count("gun")
+        n_e1 = prod.count("e1")
+        xy = _fact_xy(rs)
+        if xy is None:
+            return [C.observe()]
+        fx, fy = xy
+        units = rs.get("units_summary") or []
+        n_units = sum(
+            1
+            for u in units
+            if str(u.get("type", "")).lower() in ("e1", "e3")
+        )
+        cmds = []
+        # Candidate placement cells: east of fact (lane mouth), in
+        # bounds (y∈[2,38] on rush-hour-arena, x∈[2,126]).
+        cells = []
+        for dx in (6, 8, 10, 12, 14, 4, 16, 5, 7, 9, 11, 13, 15):
+            for dy in (-3, -1, 1, 3, -2, 2, 0, -4, 4):
+                cells.append((fx + dx, fy + dy))
+
+        # Defence queue (Serial): prioritise gun once pbox at target
+        # and weap is online, otherwise reinforce pbox up to
+        # target+3 buffer to absorb attrition.
+        if n_pbox + n_gun == 0:
+            if (
+                gun_count < gun_target
+                and weap_count >= 1
+                and pbox_count >= pbox_target
+            ):
+                cmds.append(C.build("gun"))
+            elif pbox_count < pbox_target + 3:
+                cmds.append(C.build("pbox"))
+            elif gun_count < gun_target and weap_count >= 1:
+                cmds.append(C.build("gun"))
+
+        # Place any in-flight defence at the next free east cell.
+        if n_pbox >= 1:
+            for cx, cy in cells:
+                if (
+                    2 <= cy <= 38
+                    and 2 <= cx <= 126
+                    and (cx, cy) not in occupied
+                    and (cx, cy) not in placed
+                ):
+                    cmds.append(C.place_building("pbox", cx, cy))
+                    placed.add((cx, cy))
+                    break
+        if n_gun >= 1:
+            for cx, cy in cells:
+                if (
+                    2 <= cy <= 38
+                    and 2 <= cx <= 126
+                    and (cx, cy) not in occupied
+                    and (cx, cy) not in placed
+                ):
+                    cmds.append(C.place_building("gun", cx, cy))
+                    placed.add((cx, cy))
+                    break
+
+        # Infantry queue (Parallel): keep training replacements so
+        # own_units_gte:3 holds through screen attrition.
+        if n_units < 6 and n_e1 == 0:
+            cmds.append(C.build("e1"))
+
+        if not cmds:
+            cmds.append(C.observe())
+        return cmds
+
+    return policy
+
+
+# ── scenario-shape invariants ─────────────────────────────────────────
+
+
+def test_pack_compiles_with_three_levels_and_hunt_bot():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "expansion-turtle-1-base-fortified"
+    assert pack.meta.capability == "reasoning"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+    anchors = pack.meta.benchmark_anchor
+    assert any("fortress" in a.lower() or "1-base" in a for a in anchors), anchors
+    assert any("market" in a.lower() or "deeply" in a for a in anchors), anchors
+    assert any("fortress doctrine" in a.lower() or "impregnable" in a.lower() for a in anchors), anchors
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.map_supported
+        enemy = c.scenario.enemy
+        bot = getattr(enemy, "bot_type", None) or getattr(enemy, "bot", None)
+        assert str(bot).lower() == "hunt", (lvl, bot)
+
+
+def test_deploy_not_in_tools():
+    """TURTLE contract: `deploy` is structurally absent so the agent
+    cannot expand (the bench advertises only what the agent can do)."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        tools = [str(t).lower() for t in c.scenario.tools]
+        assert "deploy" not in tools, f"{lvl}: deploy must not be in tools"
+
+
+def test_no_mcv_provided():
+    """Belt-and-suspenders TURTLE contract: no MCV pre-placed either,
+    so even if the deploy tool sneaks back the agent cannot deploy
+    what does not exist."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        mcvs = [a for a in c.scenario.actors if a.type == "mcv"]
+        assert mcvs == [], f"{lvl}: no MCV must be pre-placed; got {mcvs}"
+
+
+@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 must be
+    strictly below the tick reachable at max_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"
+    reachable = 93 + 90 * (c.max_turns - 1)
+    assert deadline < reachable, (
+        f"{level}: deadline {deadline} unreachable within "
+        f"{c.max_turns} turns (max tick {reachable}) → DRAW degeneracy"
+    )
+
+
+def test_hard_has_two_spawn_point_groups():
+    """Hard-tier contract: ≥2 distinct seed-driven spawn_point groups
+    so the home base latitude flips per seed (anti-memorisation)."""
+    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
+    # All actors must be inside the rush-hour-arena playable bounds.
+    for a in c.scenario.actors:
+        x, y = a.position
+        assert 2 <= x <= 126 and 2 <= y <= 38, (a.type, a.position)
+
+
+def test_win_uses_per_tick_fact_count_not_monotonic_has_building():
+    """CLAUDE.md footgun: `has_building` is monotonic (never un-sets
+    after the fact dies), so the "conyard still standing" clause
+    must use `building_count_gte:{type:fact,n:1}` (per-tick
+    refreshed) — otherwise an in-progress razed-conyard run still
+    "passes" the predicate."""
+    for lvl in LEVELS:
+        c = compile_level(load_pack(PACK), lvl)
+        win = c.win_condition.model_dump(exclude_none=True)
+        clauses = win.get("all_of", []) or []
+        fact_keep = any(
+            isinstance(cl.get("building_count_gte"), dict)
+            and cl["building_count_gte"].get("type") == "fact"
+            for cl in clauses
+        )
+        assert fact_keep, (
+            f"{lvl}: 'fact still standing' clause must use "
+            f"building_count_gte (per-tick refreshed), not has_building "
+            f"(monotonic)."
+        )
+
+
+# ── solvency: intended WINS every level + every hard seed ────────────
+
+
+@pytest.mark.parametrize("level", LEVELS)
+def test_intended_fortify_policy_wins_every_level_and_seed(level):
+    c = compile_level(load_pack(PACK), level)
+    pbox_t, gun_t = PARAMS[level]
+    for seed in SEEDS:
+        r = run_level(c, make_intended(pbox_t, gun_t), seed=seed)
+        assert r.outcome == "win", (
+            f"{level} seed{seed}: intended dense-fortification "
+            f"reinforcement policy must WIN; got {r.outcome} "
+            f"(tick={r.signals.game_tick}, "
+            f"kills={r.signals.units_killed}, "
+            f"lost={r.signals.units_lost}, "
+            f"buildings={r.signals.own_buildings})"
+        )
+
+
+# ── no-cheat: every lazy / single-axis policy LOSES (not draws) ──────
+
+
+@pytest.mark.parametrize("level", LEVELS)
+@pytest.mark.parametrize(
+    "policy_name,policy",
+    [
+        ("stall", stall),
+        ("pure_army", pure_army),
+        ("over_tech", over_tech),
+    ],
+)
+def test_lazy_and_single_axis_policies_lose_every_level_and_seed(
+    level, policy_name, policy
+):
+    """Stall (defences bleed below bar), pure-army (no defence
+    replacement → pbox falls below bar), over-tech (cash spent on
+    dome/fix → no pbox reinforcement, bar unmet) must ALL LOSE on
+    every level + every seed — a real reachable LOSS, never a draw."""
+    c = compile_level(load_pack(PACK), level)
+    for seed in SEEDS:
+        r = run_level(c, policy, seed=seed)
+        assert r.outcome == "loss", (
+            f"{level} seed{seed} {policy_name}: must LOSE (real fail, "
+            f"not a draw); got {r.outcome} "
+            f"(tick={r.signals.game_tick}, "
+            f"kills={r.signals.units_killed}, "
+            f"buildings={r.signals.own_buildings})"
+        )
+
+
+# ── determinism ───────────────────────────────────────────────────────
+
+
+def test_intended_run_is_deterministic_on_easy():
+    c = compile_level(load_pack(PACK), "easy")
+    pbox_t, gun_t = PARAMS["easy"]
+    a = run_level(c, make_intended(pbox_t, gun_t), seed=3)
+    b = run_level(c, make_intended(pbox_t, gun_t), seed=3)
+    assert (a.outcome, a.turns) == (b.outcome, b.turns), (
+        "same seed must be deterministic"
+    )

tests/test_hard_tier.py

@@ -192,6 +192,14 @@ UPGRADED = [
     # flips per seed and no memorised "retreat west on y=20" opening
     # generalises.
     "combat-kite-jeep-vs-tank",
+    # Wave-4 Group B TURTLE node of the expansion triple (SC2 fortress
+    # macro / 1-base mass-defence; military fortress doctrine; risk-
+    # averse single-market deep-investment anchor). Hard tier defines
+    # two agent spawn_point groups (NORTH y=12 / SOUTH y=28) round-
+    # robined by seed; symmetric hunt bands arrive at BOTH latitudes
+    # regardless (enemy actors don't honour spawn_point — CLAUDE.md),
+    # so a memorised pbox layout from one spawn does not generalise.
+    "expansion-turtle-1-base-fortified",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation