feat(scenario): tech-turtle-defensive-tech — fortify-then-tech (SC2 turtle macro / military fortify-then-research anchor)

Wave-4 TURTLE node of the tech triple (alongside tech-aggro-all-in
AGGRO and tech-balanced-econ-then-tech BALANCED). Allied agent must
fortify the lane FIRST (3 pbox + 1 gun) and THEN tech up (weap +
dome), in that order, under real attack pressure from a scripted
hunt-bot enemy band of e1+e3 closing on the base.

Idiom: Wave-2 then:[A,B,C,D] happened-before composite enforces the
defence-then-tech sequencing:
1. building_count_gte: {type: pbox, n: 3|8}
2. building_count_gte: {type: gun, n: 1}
3. has_building: weap
4. has_building: dome

Engine-prereq nuance: gun requires weap, so the natural build order
becomes pbox×3, weap (clause 3 latent), gun (clause 2 latches, clause
3 greedily latches), dome — the chain still encodes 'defence FIRST
then tech' because pbox×3 must be observed before clause 2 can
advance, and the hunt-bot pressure is the discriminator against
pure-tech-skip-defence (no defences ⇒ chain stuck and/or fact razed).

Real-world anchors:
- SC2 turtle macro / 'turtle to victory' defensive-tech timing
- Military fortify-then-research doctrine
- Cold War nuclear-shield-then-research analogue
- Risk-averse capital allocation: hedge first, THEN bet

Discriminations verified by scripted policies (tests/test_tech_turtle
_defensive_tech.py × seeds 1..4 × 3 levels):
- stall (observe only): LOSS (clock + fail)
- pure-aggro-skip-defence (race weap+dome, no pbox/gun): LOSS
(chain never advances past phase 1; or fact razed)
- only-defence-no-tech (spam pbox forever): LOSS (chain stuck
at phase 1; no weap/dome ever)
- intended fortify-then-tech (pbox×3, weap, gun, dome): WIN

Difficulty axis:
- easy: 4× e1 hunt at x=95, generous clock 7200
- medium: 4× e1 + 1× e3 hunt at x=105, units_lost_lte: 6
- hard: 2 hunt bands (north+south) at x=100, pbox×8 bar,
≥2 spawn_point groups (NORTH/SOUTH base) round-robined by seed

Pre-placed agent base: fact + tent + powr + 2nd powr (for pbox×3
power drain) + proc + harv + mine (so income flows from turn 1
and the chain can be funded inside the 3000 starting_cash + ~95
cr/turn harv income window).

Model smoke (Together Qwen3.6-Plus, medium s=1): loss
composite=0.3675 (perception=0.0342 reasoning=0.6548 action=1.0
objective=0.9999) — clean run, no crash.

Hard tier registered in tests/test_hard_tier.py::UPGRADED (the
spawn-variation contract: ≥2 agent spawn_point groups round-
robined by seed).

openra_bench/scenarios/packs/tech-turtle-defensive-tech.yaml

@@ -0,0 +1,342 @@
+# tech-turtle-defensive-tech.yaml
+#
+# REASONING capability — Wave-4 TURTLE variant of the tech triple.
+# Siblings: `tech-aggro-all-in` (AGGRO — race tech, skip everything
+# else) and `tech-balanced-econ-then-tech` (BALANCED — econ floor
+# first, then tech). This pack is the TURTLE cell: build defences
+# FIRST, then tech up safely behind them. A scripted `hunt` enemy
+# band of e1+e3 closes on the agent base by ~tick 1500 and will
+# raze ANY tech building (or the construction yard itself) unless
+# the lane is hardened first.
+#
+# The Wave-2 `then:[A,B,C,D]` happened-before composite enforces the
+# defence-then-tech sequencing:
+#   1. building_count_gte: {type: pbox, n: 3}   # phase 1 — anti-inf wall
+#   2. building_count_gte: {type: gun,  n: 1}   # phase 2 — anti-armour cap
+#   3. has_building: weap                       # phase 3 — tech step 1
+#   4. has_building: dome                       # phase 4 — tech step 2
+#
+# IMPORTANT engine-prereq nuance: `gun` (allied gun turret) requires
+# `weap` (engine prereq). So the natural BUILD order is:
+#   pbox×3   (clause 1 latches — defences up)
+#   weap     (clause 3 satisfied but NOT latched — chain blocked at 2)
+#   gun×1    (clause 2 latches; clause 3 greedily latches in same eval)
+#   dome     (clause 4 latches — chain complete)
+# The `then` chain still encodes "defence FIRST then tech": pbox×3
+# must be observed BEFORE the chain can advance past phase 1, so any
+# pure-tech skip cannot satisfy phase 1 → chain stuck. The hunt-bot
+# pressure is the discriminator against "skip pbox and race tech":
+# without 3 pbox up before the hunt band arrives (~tick 1500), the
+# tech buildings (or the fact itself) get razed and the
+# `not has_building: fact` fail clause fires.
+#
+# Real-world anchors:
+#   - SC2 turtle macro / "turtle to victory" defensive-tech timing
+#   - Military fortify-then-research doctrine (Cold War nuclear-shield
+#     -then-research analogue): build the shield BEFORE the new
+#     capability, so the new capability isn't lost before it ships.
+#   - Risk-averse capital allocation: hedge first (downside cap), THEN
+#     bet (upside).
+#
+# DISCRIMINATIONS (bar from CLAUDE.md — no defect, no cheat):
+#   - stall (observe only): LOSS — clock + hunt razes fact.
+#   - pure-aggro-skip-defence (race weap+dome, no pbox/gun): LOSS —
+#     hunt band reaches fact ~tick 1500 with no defences ⇒ fact razed
+#     ⇒ `not has_building: fact` fail fires.
+#   - build-only-defence-no-tech (only pbox spam, no weap/dome): LOSS
+#     — chain stuck at phase 1; clock expires.
+#   - intended defence-then-tech (pbox×3, weap, gun, dome): WIN.
+#
+# ENGINE FACTS used (CLAUDE.md / SCENARIO_QUALITY.md):
+#   - allied agent: `tent` (barracks) prereq for `pbox` (600cr)
+#   - `pbox` prereq `tent`; allied + 600cr each
+#   - `gun` prereq `weap` (engine-enforced); allied + 800cr
+#   - `weap` (~2000cr) prereq `proc`
+#   - `dome` (~1000cr) prereq `proc`
+#   - `proc` (1400cr) prereq `powr` — pre-placed harv harvests it
+#   - hunt bot: every unit attacks the nearest agent unit / building
+#   - inert enemy `fact` marker far east prevents auto-DRAW on
+#     enemy-elim (the hunt band would all die otherwise)
+#   - `then:` greedy advance — once a prior clause latches, any
+#     currently-true later clauses latch in the same evaluation
+#     (proven by tests/test_then_composite.py)
+#
+# Validate (no model / no network):
+#   python3 -m openra_bench.scenarios.validate \
+#     openra_bench/scenarios/packs/tech-turtle-defensive-tech.yaml
+
+meta:
+  id: tech-turtle-defensive-tech
+  title: 'Tech Turtle — Fortify the Lane FIRST, THEN Tech Up Safely'
+  capability: reasoning
+  real_world_meaning: >
+    Defensive-tech sequencing under real attack pressure: build the
+    static defence line (pillboxes covering the lane mouth, then a
+    gun turret cap) BEFORE committing the budget to deeper tech
+    buildings (war factory, radar dome). A `hunt` enemy band is
+    closing on the base by ~tick 1500 and will raze any tech
+    building (or the construction yard) unless the lane is hardened
+    first. Pure aggro (race tech, skip defence) loses the base to
+    the hunt band; pure turtle (defences only, no tech) never
+    satisfies the tech clauses; only the fortify-then-research
+    sequence wins inside the budget.
+  robotics_analogue: >
+    Capability development under live adversarial threat: ship the
+    operational hardening (perimeter, monitoring, redundancy) BEFORE
+    rolling out the new capability that the adversary is incentivised
+    to disrupt. A roadmap that ships the capability without first
+    standing up the perimeter loses the capability the moment the
+    adversary arrives; a roadmap that only ever hardens never ships
+    the capability the mission requires.
+  benchmark_anchor:
+    - "SC2 turtle macro / defensive-tech timing"
+    - "military strategic-defense doctrine (fortify before research)"
+    - "Cold War nuclear-shield-then-research analogue"
+    - "risk-averse capital allocation: hedge first then bet"
+  author: openra-bench
+
+base_map: rush-hour-arena
+
+base:
+  agent:
+    faction: allies
+  enemy:
+    faction: soviet
+    bot_type: hunt
+  tools:
+    - observe
+    - build
+    - place_building
+    - harvest
+    - move_units
+    - attack_unit
+    - attack_move
+    - stop
+  planning: true
+  termination:
+    max_ticks: 40000
+
+starting_cash: 3000
+
+levels:
+  # ── EASY ─────────────────────────────────────────────────────────
+  # Bare turtle-then-tech rehearsal: a smaller hunt band (4× e1)
+  # closing slowly from the mid-map, generous clock. The chain still
+  # bites (pbox×3 must be observed-before gun-1 / weap / dome) but
+  # the income window is forgiving. Stall / pure-aggro / pure-turtle
+  # all LOSE; intended fortify-then-tech WINS.
+  # max_turns 90 → reachable tick 93 + 90·89 = 8103 ≥ 7200.
+  easy:
+    description: >
+      A small hunt-band of 4 enemy rifle infantry is closing on your
+      base from the mid-map. Build the defence line FIRST, then tech
+      up — in this order: (1) build at least 3 pillboxes (pbox), then
+      (2) build at least 1 gun turret (gun — needs a war factory),
+      (3) own a war factory (weap), (4) own a radar dome (dome). The
+      pre-placed refinery and harvester give you income. If you skip
+      defences the hunt band razes your base; if you only build
+      defences and never tech, the chain stalls; stalling loses on
+      the clock. Win = the defence-then-tech chain completed before
+      tick 7200, with the construction yard still standing and ≥1
+      own unit.
+    starting_cash: 3000
+    overrides:
+      actors:
+        # Agent base — fact + tent + powr per spec, PLUS proc + harv +
+        # mine so income flows from turn 1 (the tech chain needs
+        # ~5600 cash on top of the ~1800 for the 3 pbox; without harv
+        # income the bare starting_cash cannot fund the chain). Layout
+        # puts vulnerable buildings (fact, proc) WEST and the screen
+        # / pbox lane mouth to the EAST so the hunt band hits the
+        # defences BEFORE the income building.
+        - {type: fact, owner: agent, position: [10, 20]}
+        - {type: tent, owner: agent, position: [8,  18]}
+        - {type: powr, owner: agent, position: [6,  20]}
+        # Second powr — three pbox each drain -20 power and the
+        # tech buildings (weap −30, dome −40) push the surplus
+        # negative without it; underpowered queues construct very
+        # slowly, so weap never completes inside the clock.
+        - {type: powr, owner: agent, position: [6,  22]}
+        - {type: proc, owner: agent, position: [6,  16]}
+        - {type: harv, owner: agent, position: [8,  22]}
+        # Mine to the WEST of base so the harv has somewhere to go
+        # without crossing the lane mouth (the hunt band's lane).
+        - {type: mine, owner: neutral, position: [2,  20]}
+        # Three starting riflemen guarding the EAST lane mouth — the
+        # first line that engages the hunt band and gives pbox×3 time
+        # to come online.
+        - {type: e1,   owner: agent, position: [16, 20], stance: 3, count: 3}
+        # Hunt band — 4× e1 starting east at x=95. At ~3–4 cells/turn
+        # the band needs ~20+ turns (~tick 2200) to reach the lane
+        # mouth at x≈16 (where the screen sits) — enough budget for
+        # pbox×3 (build/place ≈ 15 turns) to stand up first. The
+        # starting riflemen blunt the leading edge for a few more
+        # turns.
+        - {type: e1, owner: enemy, position: [95, 20], stance: 3, count: 4}
+        # Unarmed high-HP enemy marker far east — prevents engine
+        # auto-DRAW on enemy-elimination once the hunt band dies
+        # (CLAUDE.md footgun).
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - then:
+            id: defense-then-tech-easy
+            clauses:
+              - {building_count_gte: {type: pbox, n: 3}}
+              - {building_count_gte: {type: gun,  n: 1}}
+              - {has_building: weap}
+              - {has_building: dome}
+        - {within_ticks: 7200}
+        - {own_units_gte: 1}
+    fail_condition:
+      any_of:
+        - {after_ticks: 7201}
+        - {not: {has_building: fact}}
+    max_turns: 90
+
+  # ── MEDIUM ───────────────────────────────────────────────────────
+  # +1 controlled variable: HEAVIER hunt band (6× e1 + e3 mix) closing
+  # FROM CLOSER, plus an attrition cap (units_lost_lte: 4). The hunt
+  # band reaches the lane mouth faster, so the pbox-first phase must
+  # be executed promptly — over-investing in tech before the wall
+  # bleeds the small starting unit pool past the cap.
+  # max_turns 80 → reachable tick 93 + 90·79 = 7203 ≥ 7200.
+  medium:
+    description: >
+      A heavier hunt-band — 4 rifle infantry plus 1 rocket soldier
+      (e3) — is closing on your base from the far east. Build the
+      defence line FIRST, then tech up — in this order: (1) ≥3
+      pillboxes (pbox), (2) ≥1 gun turret (gun — needs war factory),
+      (3) war factory (weap), (4) radar dome (dome). Same fail
+      conditions as easy plus an attrition cap: you may lose at most
+      6 of your own units. Skipping defences loses the base to the
+      hunt band; building only defences never satisfies the tech
+      chain; stalling loses on the clock; sloppy turtling that
+      bleeds the starting infantry past 6 lost also loses.
+    starting_cash: 3000
+    overrides:
+      actors:
+        - {type: fact, owner: agent, position: [10, 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: [6,  16]}
+        - {type: harv, owner: agent, position: [8,  22]}
+        - {type: mine, owner: neutral, position: [2,  20]}
+        # Starting defenders: 6 e1 + 2 e3 at the EAST lane mouth to
+        # blunt the hunt band's leading edge while the pbox wall
+        # stands up. The attrition cap (units_lost_lte: 6) is
+        # measurable from this real baseline and adds the "don't
+        # over-bleed the screen" axis.
+        - {type: e1,   owner: agent, position: [16, 20], stance: 3, count: 6}
+        - {type: e3,   owner: agent, position: [16, 22], stance: 3, count: 2}
+        # Hunt band — heavier (4 e1 + 2 e3) starting far east at
+        # x=105 so the band needs ~25 turns (~tick 2800) to reach
+        # the lane mouth at x≈18. The pbox×3 wall (built ≈ tick
+        # 1500) and starting screen blunt it before it reaches the
+        # fact / proc. Hunt is the discriminator against pure-aggro
+        # (no defences ⇒ fact razed ⇒ fail).
+        - {type: e1, owner: enemy, position: [105, 20], stance: 3, count: 4}
+        - {type: e3, owner: enemy, position: [107, 20], stance: 3, count: 1}
+        # Inert enemy `fact` marker (anti-DRAW).
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - then:
+            id: defense-then-tech-medium
+            clauses:
+              - {building_count_gte: {type: pbox, n: 3}}
+              - {building_count_gte: {type: gun,  n: 1}}
+              - {has_building: weap}
+              - {has_building: dome}
+        - {within_ticks: 7200}
+        - {own_units_gte: 1}
+        - {units_lost_lte: 6}
+    fail_condition:
+      any_of:
+        - {after_ticks: 7201}
+        - {not: {has_building: fact}}
+        - {not: {units_lost_lte: 6}}
+    max_turns: 80
+
+  # ── HARD ─────────────────────────────────────────────────────────
+  # +1 controlled variable: TWO hunt bands (8× total) hitting from
+  # TWO latitudes (north y=10 and south y=30), AND ≥2 spawn_point
+  # groups so the agent base latitude varies by seed. The pbox bar
+  # is raised to 8 to cover both lanes (4 per lane). Same clock; same
+  # attrition cap.
+  # max_turns 80 → reachable tick 93 + 90·79 = 7203 ≥ 7200.
+  hard:
+    description: >
+      Two hunt-bands hit your base from two different latitudes
+      (north and south). Your base stages from a seed-chosen
+      latitude — a single memorised pillbox cell cannot generalise.
+      Build the defence line FIRST, then tech up — in this order:
+      (1) ≥8 pillboxes (pbox — enough to cover both lanes),
+      (2) ≥1 gun turret (gun — needs war factory), (3) war factory
+      (weap), (4) radar dome (dome). Same attrition cap (≤6 own
+      lost) and clock (tick 7200) as medium. Skip defences, only-
+      defences, or over-attrition all lose; only the full fortify-
+      then-tech chain wins.
+    starting_cash: 3000
+    overrides:
+      actors:
+        # NORTH base spawn (spawn_point 0). Layout: vulnerable
+        # buildings (fact, proc) to the WEST; screen + future pbox
+        # lane mouth to the EAST so the hunt band hits defences
+        # BEFORE the income building.
+        - {type: fact, owner: agent, position: [10, 14], spawn_point: 0}
+        - {type: tent, owner: agent, position: [8,  12], spawn_point: 0}
+        - {type: powr, owner: agent, position: [6,  14], spawn_point: 0}
+        # Extra powr per spawn — 8 pbox is -160 power; needed.
+        - {type: powr, owner: agent, position: [6,  16], spawn_point: 0}
+        - {type: powr, owner: agent, position: [8,  10], spawn_point: 0}
+        - {type: proc, owner: agent, position: [6,  10], spawn_point: 0}
+        - {type: harv, owner: agent, position: [8,  16], spawn_point: 0}
+        - {type: e1,   owner: agent, position: [16, 14], stance: 3, count: 6, spawn_point: 0}
+        - {type: e3,   owner: agent, position: [16, 16], stance: 3, count: 2, spawn_point: 0}
+        # SOUTH base spawn (spawn_point 1) — symmetric.
+        - {type: fact, owner: agent, position: [10, 26], spawn_point: 1}
+        - {type: tent, owner: agent, position: [8,  28], spawn_point: 1}
+        - {type: powr, owner: agent, position: [6,  26], spawn_point: 1}
+        - {type: powr, owner: agent, position: [6,  24], spawn_point: 1}
+        - {type: powr, owner: agent, position: [8,  30], spawn_point: 1}
+        - {type: proc, owner: agent, position: [6,  30], spawn_point: 1}
+        - {type: harv, owner: agent, position: [8,  24], spawn_point: 1}
+        - {type: e1,   owner: agent, position: [16, 26], stance: 3, count: 6, spawn_point: 1}
+        - {type: e3,   owner: agent, position: [16, 24], stance: 3, count: 2, spawn_point: 1}
+        # Two ore patches, one per spawn cluster (engine doesn't
+        # filter neutral actors by spawn_point — both placed). Mines
+        # west of base so the harv loop doesn't cross the lane.
+        - {type: mine, owner: neutral, position: [2,  14]}
+        - {type: mine, owner: neutral, position: [2,  26]}
+        # Two hunt bands at distinct latitudes (both ALWAYS placed
+        # — enemy actors with no spawn_point are not filtered). The
+        # hunt bot drives each unit at the nearest agent target,
+        # so whichever lane the agent's base occupies will be hit
+        # by one band; the OTHER band will also turn in (the seed-
+        # varied spawn means the agent can't pre-commit to one lane).
+        - {type: e1, owner: enemy, position: [100, 10], stance: 3, count: 3}
+        - {type: e3, owner: enemy, position: [102, 10], stance: 3, count: 1}
+        - {type: e1, owner: enemy, position: [100, 30], stance: 3, count: 3}
+        - {type: e3, owner: enemy, position: [102, 30], stance: 3, count: 1}
+        # Inert enemy `fact` marker (anti-DRAW).
+        - {type: fact, owner: enemy, position: [120, 20]}
+    win_condition:
+      all_of:
+        - then:
+            id: defense-then-tech-hard
+            clauses:
+              - {building_count_gte: {type: pbox, n: 8}}
+              - {building_count_gte: {type: gun,  n: 1}}
+              - {has_building: weap}
+              - {has_building: dome}
+        - {within_ticks: 7200}
+        - {own_units_gte: 1}
+        - {units_lost_lte: 6}
+    fail_condition:
+      any_of:
+        - {after_ticks: 7201}
+        - {not: {has_building: fact}}
+        - {not: {units_lost_lte: 6}}
+    max_turns: 80

tests/test_hard_tier.py

@@ -170,6 +170,13 @@ UPGRADED = [
     # flips per seed (an off-axis diagonal busts the tick budget
     # and brushes the wrong-corner patrol).
     "mfb-base-1-defend-base-2-build",
+    # Wave-4 TURTLE node of the tech triple (SC2 turtle macro /
+    # military fortify-before-research doctrine anchor). Hard defines
+    # two agent spawn_point groups (NORTH base / SOUTH base) so the
+    # base latitude varies by seed; the two hunt bands (north + south)
+    # always place and hit whichever latitude the agent occupies, so
+    # a memorised pbox-lane placement cannot generalise across seeds.
+    "tech-turtle-defensive-tech",
 ]
 
 # Consciously NOT spawn-varied, with the reason (keeps the curation

tests/test_tech_turtle_defensive_tech.py

@@ -0,0 +1,375 @@
+"""tech-turtle-defensive-tech pack — full no-cheat validation on Rust.
+
+Wave-4 TURTLE tech-triple pack. Uses the Wave-2 `then:[A,B,C,D]`
+happened-before composite to enforce the defence-then-tech order:
+  1. building_count_gte: {type: pbox, n: 3|8}   # phase 1 — anti-inf wall
+  2. building_count_gte: {type: gun,  n: 1}     # phase 2 — anti-armour cap
+  3. has_building: weap                          # phase 3 — tech step 1
+  4. has_building: dome                          # phase 4 — tech step 2
+
+Bar (per CLAUDE.md): the intended fortify-then-tech policy must WIN
+on every (level, seed); stall / pure-aggro-skip-defence / build-only-
+defence-no-tech must LOSE on every (level, seed). No draws.
+
+Scenario shape:
+  - rush-hour-arena, allied agent, soviet hunt-bot enemy band.
+  - Pre-placed agent base: fact + tent + powr + proc + harv + mine
+    + starting riflemen (so income flows from turn 1 and `own_units_
+    gte:1` is satisfied immediately).
+  - Inert enemy `fact` marker far east prevents auto-DRAW on
+    enemy-elim.
+  - Hunt band closes on agent base by ~tick 1500 and would raze the
+    fact unless pbox×3 (medium: pbox×3, hard: pbox×8) is up first.
+  - hard: ≥2 spawn_point groups (north / south) per the hard-tier
+    contract.
+"""
+
+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 / "tech-turtle-defensive-tech.yaml"
+LEVELS = ("easy", "medium", "hard")
+SEEDS = (1, 2, 3, 4)
+
+
+# ── Policies ──────────────────────────────────────────────────────
+
+
+def _stall_policy():
+    """Idles every turn — must LOSE (clock + hunt razes fact)."""
+    def pol(obs, Cmd):
+        return [Cmd.observe()]
+    return pol
+
+
+def _pure_aggro_skip_defence_policy():
+    """Race weap+dome, never build a pbox/gun. The hunt band reaches
+    the base by ~tick 1500 with no defences ⇒ fact razed ⇒
+    `not has_building: fact` fail fires ⇒ LOSS."""
+    def pol(obs, Cmd):
+        own_b = {b["type"] for b in (obs.get("own_buildings", []) or [])}
+        prod = obs.get("production", []) or []
+        base = next((b for b in (obs.get("own_buildings", []) or [])
+                     if b["type"] == "fact"), None)
+        cmds = []
+        if "weap" not in own_b and "weap" not in prod:
+            cmds.append(Cmd.build("weap"))
+        if base and "weap" not in own_b:
+            cmds.append(Cmd.place_building(
+                "weap", base["cell_x"] + 6, base["cell_y"]
+            ))
+        if "dome" not in own_b and "dome" not in prod:
+            cmds.append(Cmd.build("dome"))
+        if base and "dome" not in own_b:
+            cmds.append(Cmd.place_building(
+                "dome", base["cell_x"] + 8, base["cell_y"] + 2
+            ))
+        if not cmds:
+            cmds.append(Cmd.observe())
+        return cmds
+    return pol
+
+
+def _only_defence_no_tech_policy():
+    """Spam pbox forever — never build weap/dome. The then-chain
+    cannot advance past phase 2 (gun needs weap, which is never
+    built); clock expires ⇒ LOSS."""
+    state = {"placed": 0}
+
+    def pol(obs, Cmd):
+        own_b_list = obs.get("own_buildings", []) or []
+        prod = obs.get("production", []) or []
+        base = next((b for b in own_b_list if b["type"] == "fact"), None)
+        cmds = []
+        if "pbox" not in prod:
+            cmds.append(Cmd.build("pbox"))
+        if base:
+            # Spread pbox placements so they don't collide.
+            dx = 3 + (state["placed"] % 4)
+            dy = -2 + (state["placed"] // 4)
+            cmds.append(Cmd.place_building(
+                "pbox", base["cell_x"] + dx, base["cell_y"] + dy
+            ))
+            state["placed"] += 1
+        if not cmds:
+            cmds.append(Cmd.observe())
+        return cmds
+    return pol
+
+
+def _intended_defence_then_tech_policy(pbox_target: int):
+    """The intended TURTLE capability play:
+       turn 1: kick the pre-placed harvester onto the mine
+       phase 1: queue pbox one at a time until ≥pbox_target standing
+       phase 2: once phase 1 done, build weap (gun's engine prereq)
+       phase 3: once weap up, build gun (this latches the then-chain
+                clause 2; weap latches greedily as clause 3)
+       phase 4: build dome (clause 4 latches → chain complete)
+       The fortify-first ordering survives the hunt band's arrival
+       at ~tick 1500.
+    """
+    state = {
+        "placed_pbox": 0,
+        "weap_attempts": 0,
+        "gun_attempts": 0,
+        "dome_attempts": 0,
+        "harv_kicked": False,
+    }
+
+    def pol(obs, Cmd):
+        ob = obs.get("own_buildings", []) or []
+        own_b = {b["type"] for b in ob}
+        pbox_have = sum(1 for b in ob if b["type"] == "pbox")
+        prod = obs.get("production", []) or []
+        cash = int(obs.get("cash", 0) or 0)
+        units = obs.get("units_summary", []) or []
+        base = next((b for b in ob if b["type"] == "fact"), None)
+        bx = base["cell_x"] if base else 10
+        by = base["cell_y"] if base else 20
+        cmds = []
+
+        # Kick the pre-placed harvester at the nearest mine. Mine is
+        # WEST of base (at bx-8) in every scenario (easy/medium:
+        # (2,20); hard: (2,14)/(2,26)) — placed west so the harv loop
+        # doesn't cross the lane the hunt band is closing down.
+        if not state["harv_kicked"]:
+            harv = next((u for u in units if u.get("type") == "harv"), None)
+            if harv:
+                cmds.append(Cmd.harvest([harv["id"]], bx - 8, by))
+                state["harv_kicked"] = True
+
+        # Phase 1: pbox first. Queue ONE at a time (wait for it to
+        # complete before queueing the next) so we don't over-build
+        # before income arrives. Place each pbox on a distinct cell.
+        in_q_pbox = "pbox" in prod
+        if pbox_have < pbox_target and not in_q_pbox and cash >= 600:
+            cmds.append(Cmd.build("pbox"))
+        # Place whenever a pbox is ready (we only have at most one
+        # queued at a time so a single place per turn is enough).
+        if pbox_have < pbox_target:
+            i = state["placed_pbox"]
+            row = -3 + 2 * (i % 4)              # y offsets: -3,-1,+1,+3
+            col = 3 + (i // 4)                  # x offsets: 3,4,5,…
+            cmds.append(Cmd.place_building(
+                "pbox", bx + col, by + row
+            ))
+            state["placed_pbox"] += 1
+
+        # Phase 2/3: once pbox wall is up, build weap (gun's prereq).
+        # weap needs proc (pre-placed) so the queue accepts it.
+        # Retry placement on a sliding offset until the building
+        # actually completes (the engine silently blocks placements
+        # that collide with existing footprints / units).
+        if pbox_have >= pbox_target and "weap" not in own_b \
+                and "weap" not in prod and cash >= 2000:
+            cmds.append(Cmd.build("weap"))
+        if pbox_have >= pbox_target and "weap" not in own_b:
+            i = state["weap_attempts"]
+            cmds.append(Cmd.place_building(
+                "weap", bx + 8 + (i % 6), by - 4 + (i // 6)
+            ))
+            state["weap_attempts"] += 1
+
+        # gun needs weap — queue it once weap is up.
+        gun_have = sum(1 for b in ob if b["type"] == "gun")
+        if "weap" in own_b and gun_have < 1 and "gun" not in prod \
+                and cash >= 800:
+            cmds.append(Cmd.build("gun"))
+        if "weap" in own_b and gun_have < 1:
+            i = state["gun_attempts"]
+            cmds.append(Cmd.place_building(
+                "gun", bx + 8 + (i % 6), by + 4 + (i // 6)
+            ))
+            state["gun_attempts"] += 1
+
+        # dome needs proc (pre-placed); build in parallel once weap
+        # is up — but keep the spec's gun-before-dome ordering so the
+        # then-chain advances cleanly.
+        if "weap" in own_b and gun_have >= 1 and "dome" not in own_b \
+                and "dome" not in prod and cash >= 1000:
+            cmds.append(Cmd.build("dome"))
+        if "weap" in own_b and gun_have >= 1 and "dome" not in own_b:
+            i = state["dome_attempts"]
+            cmds.append(Cmd.place_building(
+                "dome", bx + 12 + (i % 4), by + (i // 4)
+            ))
+            state["dome_attempts"] += 1
+
+        if not cmds:
+            cmds.append(Cmd.observe())
+        return cmds
+    return pol
+
+
+# ── Pack-shape tests (cheap; do not run the engine) ──────────────
+
+
+def test_pack_compiles_with_three_levels():
+    pack = load_pack(PACK)
+    assert pack.meta.id == "tech-turtle-defensive-tech"
+    assert pack.meta.capability == "reasoning"
+    assert set(pack.levels) == {"easy", "medium", "hard"}
+
+
+def test_meta_benchmark_anchor_set():
+    pack = load_pack(PACK)
+    anchors = pack.meta.benchmark_anchor or []
+    assert any("turtle" in a for a in anchors), anchors
+    assert any("fortify" in a or "shield" in a for a in anchors), anchors
+    assert any("hedge" in a or "risk" in a for a in anchors), anchors
+
+
+def test_hard_tier_has_seed_driven_spawn_groups():
+    c = compile_level(load_pack(PACK), "hard")
+    sp = {a.spawn_point for a in c.scenario.actors if a.owner == "agent"}
+    assert len(sp) >= 2, f"hard needs ≥2 spawn groups, got {sp}"
+
+
+def test_every_level_has_fail_condition():
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        c = compile_level(pack, lvl)
+        assert c.fail_condition is not None, f"{lvl} missing fail_condition"
+
+
+def test_then_composite_used_in_win():
+    """Confirms the defence-then-tech chain wired through to the
+    compiled win condition (the whole point of the TURTLE pack)."""
+    for lvl in LEVELS:
+        c = compile_level(load_pack(PACK), lvl)
+        win = c.win_condition.model_dump(exclude_none=True)
+        ao = win.get("all_of") or []
+        assert any("then" in clause for clause in ao), (
+            f"{lvl} win has no then-composite: {win}"
+        )
+        then_clause = next(cl["then"] for cl in ao if "then" in cl)
+        clauses = then_clause["clauses"]
+        # Must be exactly: pbox → gun → weap → dome.
+        assert "building_count_gte" in clauses[0]
+        assert clauses[0]["building_count_gte"]["type"] == "pbox"
+        assert "building_count_gte" in clauses[1]
+        assert clauses[1]["building_count_gte"]["type"] == "gun"
+        assert "has_building" in clauses[2] and clauses[2]["has_building"] == "weap"
+        assert "has_building" in clauses[3] and clauses[3]["has_building"] == "dome"
+
+
+def test_tick_budget_aligned_with_max_turns():
+    """within_ticks must be reachable inside max_turns."""
+    pack = load_pack(PACK)
+    for lvl in LEVELS:
+        level_def = pack.levels[lvl]
+        max_turns = level_def.max_turns
+        reachable = 93 + 90 * (max_turns - 1)
+        win = compile_level(pack, lvl).win_condition.model_dump(exclude_none=True)
+
+        def _collect(node, key, out):
+            if isinstance(node, dict):
+                if key in node:
+                    out.append(node[key])
+                for v in node.values():
+                    _collect(v, key, out)
+            elif isinstance(node, list):
+                for v in node:
+                    _collect(v, key, out)
+        wts = []
+        _collect(win, "within_ticks", wts)
+        assert wts, f"{lvl} has no within_ticks leaf (no clock teeth)"
+        for wt in wts:
+            assert wt <= reachable, (
+                f"{lvl} within_ticks={wt} > reachable={reachable} "
+                f"(max_turns={max_turns}) — deadline never bites ⇒ draw"
+            )
+
+
+# ── Engine-bound tests (parameterised over seeds 1..4) ────────────
+
+
+def _pbox_target(level: str) -> int:
+    return 8 if level == "hard" else 3
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_intended_defence_then_tech_wins(level, seed):
+    """The intended TURTLE policy (pbox first, then weap+gun+dome)
+    must WIN on every (level, seed). Load-bearing solvency test."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(
+        c, _intended_defence_then_tech_policy(_pbox_target(level)), seed=seed
+    )
+    own_b = res.signals.own_building_types
+    assert res.outcome == "win", (
+        f"intended defence-then-tech must WIN on {level} s={seed}; "
+        f"got {res.outcome} turns={res.turns} "
+        f"own_buildings={own_b} cash={res.signals.cash} "
+        f"units_lost={res.signals.units_lost} "
+        f"then_progress={getattr(res.signals, 'then_progress', {})}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_stall_loses(level, seed):
+    """Do-nothing must LOSE on every (level, seed)."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _stall_policy(), seed=seed)
+    assert res.outcome == "loss", (
+        f"stall must LOSE on {level} s={seed}; got {res.outcome}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_pure_aggro_skip_defence_loses(level, seed):
+    """Pure aggro (race weap+dome without any defence) must LOSE:
+    hunt band reaches the base ~tick 1500, no pbox/gun to blunt it
+    ⇒ fact razed ⇒ `not has_building: fact` fail fires (or the
+    then-chain never advances past phase 1 ⇒ clock expires)."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _pure_aggro_skip_defence_policy(), seed=seed)
+    own_b = res.signals.own_building_types
+    assert res.outcome == "loss", (
+        f"pure-aggro-skip-defence must LOSE on {level} s={seed}; got "
+        f"{res.outcome} own_buildings={own_b} "
+        f"then_progress={getattr(res.signals, 'then_progress', {})}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+@pytest.mark.parametrize("level", LEVELS)
+def test_only_defence_no_tech_loses(level, seed):
+    """Build only pbox forever — never weap/dome. Phase 2 (gun)
+    requires weap (engine prereq), which is never built; the
+    then-chain stalls at phase 1; clock expires ⇒ LOSS."""
+    c = compile_level(load_pack(PACK), level)
+    res = run_level(c, _only_defence_no_tech_policy(), seed=seed)
+    own_b = res.signals.own_building_types
+    assert res.outcome == "loss", (
+        f"only-defence-no-tech must LOSE on {level} s={seed}; got "
+        f"{res.outcome} own_buildings={own_b} "
+        f"then_progress={getattr(res.signals, 'then_progress', {})}"
+    )
+    # Sanity: tech buildings never built.
+    assert "weap" not in own_b, (
+        f"only-defence-no-tech built weap on {level} s={seed}"
+    )
+    assert "dome" not in own_b, (
+        f"only-defence-no-tech built dome on {level} s={seed}"
+    )
+
+
+@pytest.mark.parametrize("seed", SEEDS)
+def test_hard_seeds_produce_distinct_starts(seed):
+    """Hard's two spawn_point groups must round-robin per seed."""
+    c = compile_level(load_pack(PACK), "hard")
+    res = run_level(c, _stall_policy(), seed=seed)
+    assert res.outcome == "loss"  # stall must lose
+    sp = {a.spawn_point for a in c.scenario.actors if a.owner == "agent"}
+    assert len(sp) >= 2