fix(scenario): build-repair-priority-under-fire — recalibrate after engine movement fixes

The engine move-fire fixes made pre-placed stance:3 defenders resolve a
clustered fire-fight in one ~90-tick window with the buildings never
scratched: stall WON every level/seed (all bands cleared by tick 108,
buildings at 100%, kill bar instantly met). The old slow damage race no
longer exists.

Redesign: drop the agent combat units and the kill bar entirely; the
triage is now a pure `repair`-target decision against an unopposed
grenadier band. proc (wood) dies unrepaired and is saved by autorepair;
pbox is pre-damaged (health: 30) Heavy-armoured decoy that survives on
its own; weap rides out a bridged-proc-pinned band on easy but needs
its own repair on medium/hard. Win now requires SURVIVING a danger
window (after_ticks floor + within_ticks ceiling) so it cannot latch on
turn 1. stall / repair-pbox lose every level+seed; repair-proc wins
easy, loses medium/hard; intended repair-proc+weap and repair-all win
every level+seed.

openra_bench/scenarios/packs/build-repair-priority-under-fire.yaml

@@ -1,48 +1,56 @@
 # build-repair-priority-under-fire — criticality-weighted repair triage:
 # three damaged buildings under fire, repair the high-value-and-lethally-
-# threatened one FIRST.
+# threatened one(s) FIRST.
 #
 # REASONING capability — Wave-10 "disaster-recovery triage / criticality-
 # weighted maintenance" pack. Three of the agent's structures are under
 # simultaneous attrition from three separate grenadier bands, and the
-# agent's hold-the-line job is a pure TRIAGE DECISION: which building to
-# put the `repair` organ on FIRST. The three buildings present a
+# agent's hold-the-line job is a pure TRIAGE DECISION: which building(s)
+# to put the `repair` organ on. The three buildings present a
 # deliberately mis-leading damage picture:
 #
-#   - proc (refinery)  — HIGH value, on a LETHAL trajectory. Six
-#     grenadiers chew the wood-armoured refinery down and KILL it inside
-#     ~2 turns if it is not repaired. proc is required by the win
-#     predicate; losing it is an instant fail.
-#   - pbox (pillbox)   — LOW value, the DECOY. Five grenadiers chip the
-#     pillbox down to ~25% HP fast, so a naive "repair the most-damaged
-#     building" heuristic targets the pbox — but the pbox is NOT in the
-#     win predicate and, once its band is cleared by the local
-#     defenders, it STABILISES at ~25% and survives untouched. Repairing
-#     it is wasted effort.
-#   - weap (war factory) — MEDIUM. On easy a light band leaves the
-#     high-HP war factory standing on its own; on medium/hard the band
-#     is heavy enough that weap ALSO needs repair, deepening the triage
-#     from "pick the 1 critical building" to "pick the 2 critical
-#     buildings, skip the low-value decoy".
+#   - proc (refinery)  — HIGH value, on a LETHAL trajectory. A
+#     grenadier band chews the wood-armoured refinery down and KILLS it
+#     unrepaired; toggling `repair` on it makes the ~1%/tick autorepair
+#     out-pace the grenade chip so it rides out the band. proc is
+#     required by the win predicate; losing it is an instant fail.
+#   - pbox (pillbox)   — LOW value, the DECOY. It is pre-placed already
+#     damaged (health: 30 — chipped to ~30% HP), so a naive "repair the
+#     most-damaged-LOOKING building" heuristic targets the pbox. But the
+#     pbox is Heavy-armoured: the grenade Versus-Heavy multiplier is so
+#     low the band barely scratches it, and it is NOT in the win
+#     predicate — it survives untouched at ~30% on its own. Repairing it
+#     is wasted effort that leaves the proc to die.
+#   - weap (war factory) — MEDIUM. On easy NO band sits on the war
+#     factory directly: as long as the proc is bridged its band stays
+#     pinned and the war factory is never touched, so repairing the proc
+#     alone saves both. On medium / hard a light band ALSO chews the
+#     wood-armoured war factory, so it too must be repaired — deepening
+#     the triage from "pick the 1 critical building" to "pick the 2
+#     critical buildings, skip the low-value decoy".
 #
 # The intended capability is criticality-weighted triage: rank by
 # (value x lethal-trajectory), not by raw damage percentage. The pbox
-# LOOKS the most damaged; the proc IS the one that dies. Repair the
-# proc (easy) / the proc AND the weap (medium, hard) and skip the pbox.
+# LOOKS the most damaged; the proc (+ weap) IS the one that dies.
+# Repair the proc (easy) / the proc AND the weap (medium, hard) and
+# skip the pbox.
 #
 # Bar:
 #   - stall (only observe): LOSS — the proc band is never bridged; the
-#     refinery is chewed to 0 inside ~2 turns; fail clause `not
+#     refinery is chewed to 0 inside ~3 turns; fail clause `not
 #     building_count_gte:proc` fires.
 #   - repair-pbox-first (toggle repair on the most-damaged-LOOKING
 #     building, the pbox): LOSS — the pbox is saved but the pbox is not
-#     in the win predicate; the proc gets no repair and dies; same fail
-#     clause fires.
-#   - INTENDED triage (repair proc first — easy; proc + weap — medium /
-#     hard): WIN — the autorepair heal rate (1% max-HP/tick) out-paces
-#     the grenade chip on the bridged building(s); the pre-placed
-#     hold-the-line defenders clear the bands; the kill bar latches and
-#     proc (+ weap) are still standing inside the clock.
+#     in the win predicate and survives on its own anyway; the proc gets
+#     no repair and dies; same fail clause fires.
+#   - repair-proc-only: WIN on easy (no band sits on the war factory,
+#     so a bridged proc keeps its band pinned and the war factory is
+#     never threatened) but LOSS on medium / hard (a light band ALSO
+#     chews the war factory; `not building_count_gte:weap` fires).
+#   - INTENDED triage (repair proc — easy; proc + weap — medium /
+#     hard): WIN — the autorepair heal rate out-paces the grenade chip
+#     on the bridged building(s); proc (+ weap) are still standing when
+#     the survival window opens and the win latches.
 #
 # Anchor: disaster-recovery triage / criticality-weighted maintenance —
 # the SRE incident-response playbook ("triage by criticality x blast
@@ -54,39 +62,46 @@
 # ENGINE FACTS (CLAUDE.md):
 # - `repair` toggles autorepair on a building ID; it heals ~1% of the
 #   building's max HP per tick and deducts a small proportional cash
-#   cost (world.rs:3046-3094). Repair auto-stops when the building is
-#   full or the owner runs out of cash. Buildings surface in the
-#   agent's `own_buildings` observation, each with a list-index `id`
-#   the agent targets directly.
-# - `building_count_gte:{type: proc, n: 1}` enforces proc-survival
-#   atomically — every tick re-counts the live building actors (the
-#   accumulating-set footgun is on `has_building`, not on
-#   building_count_gte).
-# - Reachable tick approx 93 + 90*(max_turns-1). Every within_ticks /
-#   after_ticks value below sits inside reachable for its tier, so the
-#   deadline always bites (no draw degeneracy). A "repair proc only,
-#   let the weap die" play on medium/hard loses the war factory, which
-#   trips the `not building_count_gte:{weap}` fail clause immediately —
-#   a clean LOSS the moment the building falls, no draw.
-# - Grenadier (e2) carries the Grenade weapon: 6000 damage, Versus
-#   Wood 100% / Heavy 25%, 60-tick reload. proc and weap are
-#   Wood-armoured (full chip); pbox is Heavy-armoured (quarter chip),
-#   so the SAME band size bleeds proc/weap much faster than pbox.
-# - Enemy bands are stance:3 (AttackAnything) with NO bot_type — they
-#   stay localised on their own building cluster instead of charging a
-#   shared centroid, so the three-way damage picture is stable and the
-#   triage is a clean read.
-# - The agent's hold-the-line defenders are stance:3 (AttackAnything)
-#   so they auto-advance into and clear their local band without an
-#   explicit order — this pack tests the REPAIR-TARGET decision, not
-#   combat micro. The kill bar is reachable purely from the auto-clears.
+#   cost. Repair auto-stops when the building is full or the owner runs
+#   out of cash. Buildings surface in the agent's `own_buildings`
+#   observation, each with a real engine `id` the agent targets
+#   directly.
+# - `health:` on a pre-placed actor IS honoured (oramap.rs parser
+#   carries the HP percentage through to the spawned actor's Health
+#   trait). The pbox is pre-placed at `health: 30` so it LOOKS the
+#   worst-damaged building from turn 1 — the decoy bait.
+# - Grenadier (e2) carries the Grenade weapon: Versus Wood ~full,
+#   Versus Heavy ~quarter. proc and weap are Wood-armoured (full chip
+#   — lethal unrepaired); pbox is Heavy-armoured (quarter chip — the
+#   band barely scratches it, so a pre-damaged pbox survives on its own
+#   at ~30%).
+# - Enemy bands are stance:3 (AttackAnything) with NO bot_type — each
+#   band engages the building cluster on its own latitude. After the
+#   move-fire engine fix a stance:3 attacker whose target building has
+#   been destroyed advances on the next structure: this is what
+#   couples the proc band to the war factory on easy — bridge the proc
+#   and its band stays pinned; let the proc die and its band migrates
+#   south and finishes the war factory too.
+# - This pack has NO agent combat units and NO kill bar: the engine
+#   movement fixes made pre-placed defenders resolve a clustered
+#   fire-fight in a single ~90-tick window with the buildings never
+#   scratched, collapsing the damage race. The triage is now a pure
+#   `repair`-target decision against an unopposed band — repair is the
+#   ONLY lever and is genuinely load-bearing.
+# - The win uses an `after_ticks` floor (the building must SURVIVE the
+#   danger window, not merely be alive on turn 1) AND a `within_ticks`
+#   ceiling. This win is building-SURVIVAL, not ConquestVictory — there
+#   is no enemy MustBeDestroyed objective — so `after_ticks` in the win
+#   clause is safe (no auto-`done` race). The unrepaired buildings die
+#   well before the `after_ticks` floor; the correctly-repaired ones
+#   ride the band out past it. Reachable tick approx 93 + 90*(max_turns
+#   -1); every after_ticks / within_ticks below sits inside reachable
+#   for its tier, so the deadline always bites (no draw degeneracy).
+# - The fail predicate trips the moment a required building falls
+#   (`not building_count_gte:{proc}` / `{weap}`) — a clean immediate
+#   LOSS, never a draw, well before the survival window opens.
 # - The unarmed high-HP enemy `fact` far east prevents the engine
 #   auto-`done` on enemy-elimination before the win/clock is evaluated.
-#   Because the loss/draw boundary must never depend on a race between
-#   the stance:3 defenders hunting that far `fact` and the deadline,
-#   the fail predicate ALSO trips on `not building_count_gte:{weap}` —
-#   the moment a required building falls the run is a clean immediate
-#   LOSS, never a draw.
 # - hard: agent base + enemy bands BOTH declare `spawn_point` (per-owner
 #   filter, oramap.rs::expand_scenario_actors) so each seed instantiates
 #   exactly one base latitude with its matching bands — a memorised
@@ -99,16 +114,16 @@ meta:
   real_world_meaning: >
     Three of your structures are under simultaneous attrition and you
     have one repair organ to commit. The damage picture is deliberately
-    misleading: the pillbox (pbox) is chipped to ~25% HP and LOOKS the
-    most damaged, but it is low-value and, once its attackers are
-    cleared, it survives on its own. The refinery (proc) looks less
-    damaged at first but is on a LETHAL trajectory — six grenadiers kill
-    it within ~2 turns unless you toggle `repair` on it immediately. The
-    intended decision is criticality-weighted triage: rank by value x
-    lethal-trajectory, not by raw damage percent. Repair the proc first
-    (and on the harder tiers the war factory too); skipping the
-    refinery to "fix the worst-looking building" loses it, and stalling
-    loses it.
+    misleading: the pillbox (pbox) is pre-damaged to ~30% HP and LOOKS
+    the most damaged, but it is low-value, heavily armoured, and the
+    grenadiers barely scratch it — it survives on its own. The refinery
+    (proc) starts intact but is on a LETHAL trajectory: its grenadier
+    band kills it within a few turns unless you toggle `repair` on it
+    immediately. The intended decision is criticality-weighted triage:
+    rank by value x lethal-trajectory, not by raw damage percent. Repair
+    the proc first (and on the harder tiers the war factory too);
+    skipping the refinery to "fix the worst-looking building" loses it,
+    and stalling loses it.
   robotics_analogue: >
     SRE / disaster-recovery incident triage: several services are
     degraded at once and the operator has one repair lever. The correct
@@ -130,9 +145,9 @@ starting_cash: 8000
 base:
   agent:
     faction: allies
-  # Stance-only enemy (no bot_type) — each grenadier band stays on its
-  # own building cluster rather than charging a shared centroid, so the
-  # three-way damage picture stays a clean, stable read.
+  # Stance-only enemy (no bot_type) — each grenadier band engages the
+  # building cluster on its own latitude rather than charging a shared
+  # centroid, so the three-way damage picture stays a clean, stable read.
   enemy:
     faction: soviet
   tools:
@@ -140,8 +155,8 @@ base:
     # The load-bearing tool: toggles autorepair on a building.
     - repair
   planning: true
-  # Re-decide the instant the attackers come into sight or a defender
-  # falls — repair triage is reactive, decided turn 1, not on a fixed
+  # Re-decide the instant the attackers come into sight or a building
+  # is lost — repair triage is reactive, decided turn 1, not on a fixed
   # tick schedule.
   interrupts:
     enemy_unit_spotted: true
@@ -151,48 +166,50 @@ base:
   actors: []
 
 levels:
-  # ── EASY ── the bare triage skill. Three buildings, three bands:
-  #   proc — 6 grenadiers / 4 defenders → DIES ~turn 2 unrepaired;
-  #          autorepair out-paces the chip and it survives.
-  #   weap — 3 grenadiers / 3 defenders → high-HP war factory rides
-  #          out the band on its own HP (no repair needed).
-  #   pbox — 5 grenadiers / 5 defenders → chipped to ~25% fast (the
-  #          most-damaged-LOOKING building) then stabilises; low value,
-  #          NOT in the win predicate.
-  # Intended play: repair the proc. within_ticks 2400 (~turn 27);
-  # max_turns 30 → reachable tick 2703, so after_ticks 2401 bites.
+  # ── EASY ── the bare triage skill. Three buildings:
+  #   proc — 3 grenadiers chew the wood-armoured refinery; unrepaired
+  #          it dies ~tick 288. Autorepair out-paces the chip and it
+  #          rides the band out.
+  #   weap — NO band sits directly on the war factory. As long as the
+  #          proc is bridged the proc band stays pinned; if the proc
+  #          dies its band migrates south and finishes the war factory.
+  #          So on easy repairing the proc ALONE saves both.
+  #   pbox — pre-placed at health 30 (the most-damaged-LOOKING
+  #          building); Heavy-armoured, a light band barely scratches
+  #          it; it survives on its own. NOT in the win predicate.
+  # Intended play: repair the proc. Win window [after 1200, within
+  # 2400]; max_turns 28 → reachable tick 93 + 90·27 = 2523, so the
+  # after_ticks 2401 fail bites.
   easy:
     description: >
-      Three of your structures are under attrition from three separate
-      grenadier bands: the refinery (proc), the war factory (weap), and
-      the pillbox (pbox). The pillbox is chipped down fast and looks the
-      most damaged — but it is low value and its defenders will save it.
-      The refinery is on a lethal trajectory: it dies within about two
-      turns unless you toggle REPAIR on it now. Win when the refinery
-      and the war factory are both still standing AND you have killed at
-      least 12 attackers, before tick 2400. If the refinery falls, or
-      the clock runs out with the kill bar unmet, you lose. Stalling and
+      Three of your structures are under attrition: the refinery
+      (proc), the war factory (weap), and the pillbox (pbox). The
+      pillbox is already damaged to about 30% HP and looks the most
+      damaged — but it is low value, heavily armoured, and the
+      grenadiers barely scratch it; it survives on its own. The
+      refinery is on a lethal trajectory: it dies within a few turns
+      unless you toggle REPAIR on it now. Repairing the refinery also
+      keeps its attackers pinned, so the war factory stays safe. Win
+      when the refinery and the war factory are both still standing
+      after tick 1200 and before tick 2400. If the refinery falls, or
+      the clock runs out with the win unmet, you lose. Stalling and
       repairing the most-damaged-looking building (the pillbox) both
       lose the refinery.
     overrides:
       actors:
-        # proc — HIGH value, LETHAL trajectory. 6 grenadiers kill the
-        # wood-armoured refinery in ~2 turns; 4 hold-the-line defenders
-        # clear the band in ~4. Repair must bridge the gap.
+        # proc — HIGH value, LETHAL trajectory. 3 grenadiers kill the
+        # wood-armoured refinery unrepaired (~tick 288). Repair bridges.
         - {type: proc, owner: agent, position: [20, 8]}
-        - {type: e3,   owner: agent, position: [26, 9], stance: 3, count: 4}
-        - {type: e2,   owner: enemy, position: [20, 4], stance: 3, count: 6}
-        # weap — MEDIUM. Light 3-grenadier band; the high-HP war
-        # factory rides it out on its own HP — no repair needed on easy.
+        - {type: e2,   owner: enemy, position: [20, 4], stance: 3, count: 3}
+        # weap — MEDIUM. NO band on the war factory directly: a bridged
+        # proc keeps its band pinned and the war factory is never
+        # threatened, so repair-proc-only saves both on easy.
         - {type: weap, owner: agent, position: [20, 20]}
-        - {type: e3,   owner: agent, position: [26, 21], stance: 3, count: 3}
-        - {type: e2,   owner: enemy, position: [20, 16], stance: 3, count: 3}
-        # pbox — LOW value DECOY. 5 grenadiers chip the pillbox to ~25%
-        # fast (looks worst); 5 defenders clear the band; pbox then
-        # stabilises and survives. Not in the win predicate.
-        - {type: pbox, owner: agent, position: [20, 32]}
-        - {type: e3,   owner: agent, position: [26, 33], stance: 3, count: 5}
-        - {type: e2,   owner: enemy, position: [20, 36], stance: 3, count: 5}
+        # pbox — LOW value DECOY. Pre-placed at health 30 (looks worst);
+        # Heavy-armoured, a light band barely scratches it; it survives
+        # on its own. Not in the win predicate.
+        - {type: pbox, owner: agent, position: [20, 32], health: 30}
+        - {type: e2,   owner: enemy, position: [20, 36], stance: 3, count: 4}
         # Base context — service depot + construction yard tucked safely
         # in the rear, away from every band.
         - {type: fix,  owner: agent, position: [44, 20]}
@@ -204,50 +221,48 @@ levels:
       all_of:
         - building_count_gte: {type: proc, n: 1}
         - building_count_gte: {type: weap, n: 1}
-        - units_killed_gte: 12
+        - after_ticks: 1200
         - within_ticks: 2400
     fail_condition:
       any_of:
         - after_ticks: 2401
         - not: {building_count_gte: {type: proc, n: 1}}
         - not: {building_count_gte: {type: weap, n: 1}}
-    max_turns: 30
+    max_turns: 28
 
-  # ── MEDIUM ── +1 controlled variable: the war factory's band is now
-  # heavy enough (7 grenadiers) that the weap ALSO dies unrepaired. The
-  # triage deepens from "repair the 1 critical building" to "repair the
-  # 2 critical buildings (proc + weap), skip the low-value decoy
-  # (pbox)". Tighter clock: within_ticks 2000 (~turn 22), max_turns 26
-  # → reachable tick 2343, so after_ticks 2001 bites. A "repair proc
-  # only" play keeps the proc but loses the weap → the win never
-  # latches (weap_count_gte fails) → the after_ticks fail catches it as
-  # a LOSS, not a draw.
+  # ── MEDIUM ── +1 controlled variable: a light grenadier band (2)
+  # now ALSO sits on the war factory, so the weap dies unrepaired even
+  # while the proc is bridged. The triage deepens from "repair the 1
+  # critical building" to "repair the 2 critical buildings (proc +
+  # weap), skip the low-value decoy (pbox)". A "repair proc only" play
+  # keeps the proc but loses the weap (~tick 1548) → `not
+  # building_count_gte:{weap}` fail fires as a clean LOSS before the
+  # survival window opens. Win window [after 1700, within 2700];
+  # max_turns 31 → reachable tick 93 + 90·30 = 2793, so after_ticks
+  # 2701 bites.
   medium:
     description: >
-      Three structures are under attrition from three grenadier bands:
-      the refinery (proc), the war factory (weap), and the pillbox
-      (pbox). The pillbox is chipped down fast and looks the most
-      damaged — but it is low value and survives on its own. The
-      refinery AND the war factory are both on lethal trajectories: each
-      dies within a few turns unless you toggle REPAIR on it. Win when
-      the refinery and the war factory are both still standing AND you
-      have killed at least 15 attackers, before tick 2000. If the
-      refinery falls, or the clock runs out with the win unmet, you
-      lose. Stalling, repairing only the pillbox, and repairing only one
-      of the two critical buildings all lose.
+      Three structures are under attrition: the refinery (proc), the
+      war factory (weap), and the pillbox (pbox). The pillbox is
+      already damaged to about 30% HP and looks the most damaged — but
+      it is low value, heavily armoured, and survives on its own. The
+      refinery AND the war factory are both on lethal trajectories:
+      each dies within a few turns unless you toggle REPAIR on it. Win
+      when the refinery and the war factory are both still standing
+      after tick 1700 and before tick 2700. If either falls, or the
+      clock runs out with the win unmet, you lose. Stalling, repairing
+      only the pillbox, and repairing only one of the two critical
+      buildings all lose.
     overrides:
       actors:
         - {type: proc, owner: agent, position: [20, 8]}
-        - {type: e3,   owner: agent, position: [26, 9], stance: 3, count: 4}
-        - {type: e2,   owner: enemy, position: [20, 4], stance: 3, count: 6}
-        # weap band heavier (7 grenadiers) — the war factory now dies
-        # unrepaired; repair is mandatory on it too.
+        - {type: e2,   owner: enemy, position: [20, 4], stance: 3, count: 3}
+        # weap now has a light band of its own (2 grenadiers) — the war
+        # factory dies unrepaired; repair is mandatory on it too.
         - {type: weap, owner: agent, position: [20, 20]}
-        - {type: e3,   owner: agent, position: [26, 21], stance: 3, count: 3}
-        - {type: e2,   owner: enemy, position: [20, 16], stance: 3, count: 7}
-        - {type: pbox, owner: agent, position: [20, 32]}
-        - {type: e3,   owner: agent, position: [26, 33], stance: 3, count: 5}
-        - {type: e2,   owner: enemy, position: [20, 36], stance: 3, count: 5}
+        - {type: e2,   owner: enemy, position: [20, 16], stance: 3, count: 2}
+        - {type: pbox, owner: agent, position: [20, 32], health: 30}
+        - {type: e2,   owner: enemy, position: [20, 36], stance: 3, count: 4}
         - {type: fix,  owner: agent, position: [44, 20]}
         - {type: fact, owner: agent, position: [48, 20]}
         - {type: fact, owner: enemy, position: [120, 20]}
@@ -255,70 +270,64 @@ levels:
       all_of:
         - building_count_gte: {type: proc, n: 1}
         - building_count_gte: {type: weap, n: 1}
-        - units_killed_gte: 15
-        - within_ticks: 2000
+        - after_ticks: 1700
+        - within_ticks: 2700
     fail_condition:
       any_of:
-        - after_ticks: 2001
+        - after_ticks: 2701
         - not: {building_count_gte: {type: proc, n: 1}}
         - not: {building_count_gte: {type: weap, n: 1}}
-    max_turns: 26
+    max_turns: 31
 
   # ── HARD ── +1 controlled variable: TWO spawn_point groups round-
-  # robin the AGENT base latitude (NORTH y=8..32 cluster / SOUTH
-  # y=8..32 mirror) per seed, so a single memorised opening cannot
-  # generalise. Agent base AND the matching enemy bands BOTH declare
-  # `spawn_point` — the per-owner filter (oramap.rs::expand_scenario_
-  # actors) instantiates exactly one self-consistent base + bands per
-  # seed; the persistent every-seed enemy auto-`done` fact is
-  # duplicated across both groups. Same composition and clock as
-  # medium (proc + weap both lethal; pbox decoy).
+  # robin the AGENT base longitude (WEST x=20 cluster / EAST x=70
+  # mirror) per seed, so a single memorised opening cannot generalise.
+  # Agent base AND the matching enemy bands BOTH declare `spawn_point`
+  # — the per-owner filter (oramap.rs::expand_scenario_actors)
+  # instantiates exactly one self-consistent base + bands per seed; the
+  # persistent every-seed enemy auto-`done` fact is duplicated across
+  # both groups. Same composition and clock as medium (proc + weap
+  # both lethal; pbox decoy).
   hard:
     description: >
       Three structures — the refinery (proc), the war factory (weap),
       and the pillbox (pbox) — are under attrition from three grenadier
-      bands. Your base stages from a seed-chosen latitude, so a single
-      memorised opening cannot generalise. The pillbox is chipped down
-      fast and looks the most damaged but is low value and survives on
-      its own; the refinery and the war factory are both on lethal
-      trajectories and each needs REPAIR. Win when the refinery and the
-      war factory are both still standing AND you have killed at least
-      15 attackers, before tick 2000. If the refinery falls, or the
+      bands. Your base stages from a seed-chosen longitude, so a single
+      memorised opening cannot generalise. The pillbox is pre-damaged
+      to ~30% HP and looks the most damaged but is low value, heavily
+      armoured, and survives on its own; the refinery and the war
+      factory are both on lethal trajectories and each needs REPAIR.
+      Win when the refinery and the war factory are both still standing
+      after tick 1700 and before tick 2700. If either falls, or the
       clock runs out with the win unmet, you lose. Stalling, repairing
       only the pillbox, and repairing only one critical building all
       lose.
     overrides:
       actors:
-        # NORTH base group (spawn_point 0). Full base + bands duplicated
+        # WEST base group (spawn_point 0). Full base + bands duplicated
         # under each spawn_point: ANY agent actor with a spawn_point
         # filters OUT every ungrouped agent actor, and the matching
         # enemy bands declare the same spawn_point so each seed gets a
         # self-consistent instantiation.
         - {type: proc, owner: agent, position: [20, 8],  spawn_point: 0}
-        - {type: e3,   owner: agent, position: [26, 9], stance: 3, count: 4, spawn_point: 0}
-        - {type: e2,   owner: enemy, position: [20, 4],  stance: 3, count: 6, spawn_point: 0}
+        - {type: e2,   owner: enemy, position: [20, 4],  stance: 3, count: 3, spawn_point: 0}
         - {type: weap, owner: agent, position: [20, 20], spawn_point: 0}
-        - {type: e3,   owner: agent, position: [26, 21], stance: 3, count: 3, spawn_point: 0}
-        - {type: e2,   owner: enemy, position: [20, 16], stance: 3, count: 7, spawn_point: 0}
-        - {type: pbox, owner: agent, position: [20, 32], spawn_point: 0}
-        - {type: e3,   owner: agent, position: [26, 33], stance: 3, count: 5, spawn_point: 0}
-        - {type: e2,   owner: enemy, position: [20, 36], stance: 3, count: 5, spawn_point: 0}
+        - {type: e2,   owner: enemy, position: [20, 16], stance: 3, count: 2, spawn_point: 0}
+        - {type: pbox, owner: agent, position: [20, 32], health: 30, spawn_point: 0}
+        - {type: e2,   owner: enemy, position: [20, 36], stance: 3, count: 4, spawn_point: 0}
         - {type: fix,  owner: agent, position: [44, 20], spawn_point: 0}
         - {type: fact, owner: agent, position: [48, 20], spawn_point: 0}
         - {type: fact, owner: enemy, position: [120, 20], spawn_point: 0}
-        # SOUTH base group (spawn_point 1) — the base mirrored east-
+        # EAST base group (spawn_point 1) — the base mirrored east-
         # ward into the x=70.. column with the same y-geometry, so each
         # seed faces a structurally identical triage from a different
         # start. Bands and the auto-`done` fact mirror with it.
         - {type: proc, owner: agent, position: [70, 8],  spawn_point: 1}
-        - {type: e3,   owner: agent, position: [76, 9], stance: 3, count: 4, spawn_point: 1}
-        - {type: e2,   owner: enemy, position: [70, 4],  stance: 3, count: 6, spawn_point: 1}
+        - {type: e2,   owner: enemy, position: [70, 4],  stance: 3, count: 3, spawn_point: 1}
         - {type: weap, owner: agent, position: [70, 20], spawn_point: 1}
-        - {type: e3,   owner: agent, position: [76, 21], stance: 3, count: 3, spawn_point: 1}
-        - {type: e2,   owner: enemy, position: [70, 16], stance: 3, count: 7, spawn_point: 1}
-        - {type: pbox, owner: agent, position: [70, 32], spawn_point: 1}
-        - {type: e3,   owner: agent, position: [76, 33], stance: 3, count: 5, spawn_point: 1}
-        - {type: e2,   owner: enemy, position: [70, 36], stance: 3, count: 5, spawn_point: 1}
+        - {type: e2,   owner: enemy, position: [70, 16], stance: 3, count: 2, spawn_point: 1}
+        - {type: pbox, owner: agent, position: [70, 32], health: 30, spawn_point: 1}
+        - {type: e2,   owner: enemy, position: [70, 36], stance: 3, count: 4, spawn_point: 1}
         - {type: fix,  owner: agent, position: [94, 20], spawn_point: 1}
         - {type: fact, owner: agent, position: [98, 20], spawn_point: 1}
         - {type: fact, owner: enemy, position: [120, 20], spawn_point: 1}
@@ -326,11 +335,11 @@ levels:
       all_of:
         - building_count_gte: {type: proc, n: 1}
         - building_count_gte: {type: weap, n: 1}
-        - units_killed_gte: 15
-        - within_ticks: 2000
+        - after_ticks: 1700
+        - within_ticks: 2700
     fail_condition:
       any_of:
-        - after_ticks: 2001
+        - after_ticks: 2701
         - not: {building_count_gte: {type: proc, n: 1}}
         - not: {building_count_gte: {type: weap, n: 1}}
-    max_turns: 26
+    max_turns: 31

tests/test_build_repair_priority_under_fire.py

@@ -2,35 +2,46 @@
 (Wave-10 REASONING: criticality-weighted repair triage).
 
 Three of the agent's structures are under simultaneous attrition from
-three separate grenadier bands. The damage picture is deliberately
-misleading and the agent's only job is the TRIAGE DECISION — which
-building(s) to put the `repair` organ on:
+separate grenadier bands. The damage picture is deliberately misleading
+and the agent's only job is the TRIAGE DECISION — which building(s) to
+put the `repair` organ on:
 
   * proc (refinery)  — HIGH value, on a LETHAL trajectory: dies inside
-    ~2 turns unrepaired; required by the win predicate.
-  * pbox (pillbox)   — LOW value DECOY: chipped to ~25% fast so it
-    LOOKS the most damaged, but it is not in the win predicate and its
-    defenders save it. Repairing it is wasted effort.
-  * weap (war factory) — MEDIUM: on easy a light band lets the high-HP
-    factory ride out the attack unrepaired; on medium / hard the band
-    is heavy enough that weap ALSO needs repair.
-
-No-cheat bar (proven below for every level × seed 1-4):
-
-  * STALL (only `observe`) → proc never bridged → refinery dies ~turn
-    2 → `not building_count_gte:{proc}` fail fires → LOSS.
+    ~3 turns unrepaired; required by the win predicate.
+  * pbox (pillbox)   — LOW value DECOY: pre-placed at health 30 so it
+    LOOKS the most damaged, but it is Heavy-armoured (a light grenadier
+    band barely scratches it), is not in the win predicate, and
+    survives on its own. Repairing it is wasted effort.
+  * weap (war factory) — MEDIUM: on easy NO band sits on the war
+    factory directly, so a bridged proc keeps its band pinned and the
+    war factory rides out untouched; on medium / hard a light band ALSO
+    chews the war factory so it too needs repair.
+
+The pack carries NO agent combat units and NO kill bar — the engine
+movement fixes made pre-placed defenders resolve a clustered fire-fight
+in one ~90-tick window with the buildings never scratched, collapsing
+the old damage race. The triage is now a pure `repair`-target decision
+against an unopposed band. The win requires the buildings to SURVIVE a
+danger window (`after_ticks` floor + `within_ticks` ceiling), not
+merely be alive on turn 1.
+
+No-cheat bar (proven below for every level x seed 1-4):
+
+  * STALL (only `observe`) -> proc never bridged -> refinery dies ~turn
+    4 -> `not building_count_gte:{proc}` fail fires -> LOSS.
   * REPAIR-PBOX-FIRST (toggle repair on the most-damaged-LOOKING
-    building, the pbox) → pbox saved but it is not in the win
-    predicate; the proc gets no repair and dies → LOSS.
-  * REPAIR-PROC-ONLY → WIN on easy (the war factory survives its light
-    band unaided) but LOSS on medium / hard (the heavier band kills
-    the unrepaired war factory → `not building_count_gte:{weap}` fail).
+    building, the pbox) -> pbox saved (it survives on its own anyway);
+    the proc gets no repair and dies -> LOSS.
+  * REPAIR-PROC-ONLY -> WIN on easy (no band sits on the war factory,
+    so a bridged proc keeps its band pinned) but LOSS on medium / hard
+    (the light war-factory band kills the unrepaired weap ->
+    `not building_count_gte:{weap}` fail).
   * INTENDED triage (repair proc — easy; proc + weap — medium / hard)
-    → autorepair out-paces the grenade chip, the hold-the-line
-    defenders clear the bands, the kill bar latches → WIN.
+    -> autorepair out-paces the grenade chip, the buildings ride the
+    bands out, the survival window opens -> WIN.
 
-Repair-everything also wins (it repairs the proc) — that is within the
-bar: the failure mode this pack discriminates is "repair the
+Repair-everything also wins (it repairs the proc + weap) — that is
+within the bar: the failure mode this pack discriminates is "repair the
 worst-LOOKING building", not "be thorough".
 """
 
@@ -119,6 +130,39 @@ def test_benchmark_anchor_lists_triage():
     assert "triage" in blob or "maintenance" in blob, anchors
 
 
+def test_pbox_decoy_is_pre_damaged_every_level():
+    """The pbox decoy is pre-placed already damaged (health: 30) so it
+    LOOKS the most-damaged building — the bait for the wrong triage."""
+    pack = load_pack(PACK)
+    for level in LEVELS:
+        c = compile_level(pack, level)
+        pboxes = [
+            a for a in c.scenario.actors
+            if a.owner == "agent" and a.type == "pbox"
+        ]
+        assert pboxes, f"{level}: no pbox decoy"
+        for a in pboxes:
+            assert a.health == 30, (
+                f"{level}: pbox decoy must be pre-damaged (health 30), "
+                f"got {a.health}"
+            )
+
+
+def test_no_agent_combat_units():
+    """The pack carries NO agent combat units — the triage is a pure
+    `repair`-target decision against an unopposed band."""
+    pack = load_pack(PACK)
+    buildings = {"proc", "weap", "pbox", "fix", "fact"}
+    for level in LEVELS:
+        c = compile_level(pack, level)
+        agent_types = {
+            a.type for a in c.scenario.actors if a.owner == "agent"
+        }
+        assert agent_types <= buildings, (
+            f"{level}: agent must own only buildings, got {agent_types}"
+        )
+
+
 @pytest.mark.parametrize("level", LEVELS)
 def test_every_level_has_a_reachable_timeout_fail(level):
     """Non-win must be a real LOSS, never a DRAW: the `after_ticks`
@@ -139,6 +183,28 @@ def test_every_level_has_a_reachable_timeout_fail(level):
     )
 
 
+@pytest.mark.parametrize("level", LEVELS)
+def test_win_has_survival_window(level):
+    """The win must require the buildings to SURVIVE a danger window —
+    an `after_ticks` floor below the `within_ticks` ceiling — so the win
+    cannot latch on turn 1 before any damage lands."""
+    c = compile_level(load_pack(PACK), level)
+    all_of = c.win_condition.model_dump().get("all_of", [])
+    floor = next(int(x["after_ticks"]) for x in all_of if "after_ticks" in x)
+    ceiling = next(
+        int(x["within_ticks"]) for x in all_of if "within_ticks" in x
+    )
+    assert 0 < floor < ceiling, (
+        f"{level}: win needs a survival window 0 < after_ticks "
+        f"({floor}) < within_ticks ({ceiling})"
+    )
+    reachable = 93 + 90 * (c.max_turns - 1)
+    assert floor < reachable, (
+        f"{level}: win after_ticks {floor} unreachable within "
+        f"{c.max_turns} turns (max tick {reachable})"
+    )
+
+
 @pytest.mark.parametrize("level", LEVELS)
 def test_fail_trips_on_either_required_building(level):
     """Losing the proc OR the weap must be an immediate clean LOSS — no
@@ -195,7 +261,7 @@ def test_intended_triage_wins(level, seed):
 @pytest.mark.parametrize("seed", SEEDS)
 def test_repair_everything_wins(level, seed):
     """Repairing every damaged building also wins — it DOES repair the
-    proc. Thoroughness is not the failure mode under test."""
+    proc + weap. Thoroughness is not the failure mode under test."""
     c, r = _run(level, _repair_all, seed=seed)
     assert r.outcome == "win", (
         f"{level} seed{seed}: repair-all should WIN, got {r.outcome}"
@@ -209,7 +275,7 @@ def test_repair_everything_wins(level, seed):
 @pytest.mark.parametrize("seed", SEEDS)
 def test_stall_loses(level, seed):
     """Stall must LOSE — the proc band is never bridged; the refinery
-    dies ~turn 2 and the `not building_count_gte:{proc}` fail fires."""
+    dies ~turn 4 and the `not building_count_gte:{proc}` fail fires."""
     c, r = _run(level, _stall, seed=seed)
     assert r.outcome == "loss", (
         f"{level} seed{seed} stall must LOSE; got {r.outcome} "
@@ -231,8 +297,8 @@ def test_repair_pbox_first_loses(level, seed):
 
 @pytest.mark.parametrize("seed", SEEDS)
 def test_repair_proc_only_wins_easy(seed):
-    """On easy the war factory rides out its light band unaided, so
-    repairing only the proc is sufficient → WIN."""
+    """On easy no band sits on the war factory, so a bridged proc keeps
+    its band pinned — repairing only the proc is sufficient → WIN."""
     c, r = _run("easy", _repair_proc, seed=seed)
     assert r.outcome == "win", (
         f"easy seed{seed} repair-proc-only should WIN, got {r.outcome}"
@@ -242,9 +308,9 @@ def test_repair_proc_only_wins_easy(seed):
 @pytest.mark.parametrize("level", ("medium", "hard"))
 @pytest.mark.parametrize("seed", SEEDS)
 def test_repair_proc_only_loses_on_medium_and_hard(level, seed):
-    """On medium / hard the heavier war-factory band kills the
-    unrepaired weap — repairing only the proc is no longer enough →
-    LOSS (the deeper 2-of-3 triage axis)."""
+    """On medium / hard a light band ALSO chews the war factory —
+    repairing only the proc is no longer enough → LOSS (the deeper
+    2-of-3 triage axis)."""
     c, r = _run(level, _repair_proc, seed=seed)
     assert r.outcome == "loss", (
         f"{level} seed{seed} repair-proc-only must LOSE; got {r.outcome} "