combat-bait-counter-attack: medium/hard maps reinforce north-flank strike

Medium and hard tiers (the L-cover variants) now run on tailored
128x48 arenas that physically reinforce the north-flank strike
doctrine. The actor layouts, predicates, and attrition caps are
unchanged; the new maps add a WATER wall y=16..23 across x=10..68
that closes the head-on engagement axis so a brute attack_move east
on y=20 is geometrically impossible — the strike force MUST swing
through the open NORTH band (y=2..15 above the wall) to reach the
yard from above the displaced cover.

Map design (mapgen 'arena' generator + obstacle clusters):

* easy — retains the pack-level rush-hour-arena. The 3-guard
west-face idiom works on the open arena because the
bait jeep pulls ALL three guards south, and a head-on
east drive sees an undefended face by the time it
arrives. No tailored map is load-bearing here.

* medium - combat-bait-counter-attack-medium 128x48 cordon 2
Mid-axis wall y=16..23 across x=10..68 closes the head-
on engagement band. Strike stages at (6,12) on the north
flank (above wall); bait jeep at (6,28) on the south
flank (below wall). The west connector x=2..9 is always
clear so the strike route runs east on y=12 above the
wall, descends past x=68 to the yard at (80,20). The
south arc of guards (y=24) sits east of the wall, in the
open band, where the bait's deep-kite vector pulls them
off post.

* hard - combat-bait-counter-attack-hard 128x48 cordon 2
Same wall layout as medium plus the existing spawn-
distance round-robin: group 0 stages far-west (x=6),
group 1 stages forward (x=18); both staging latitudes
(y=12 / y=28) sit in the open NORTH/SOUTH bands.

Smoke check: every level compiles with map_supported=True; all
actors in-bounds (x in [0..127], y in [0..47]); guards at x=76+
and yard at x=80 sit east of the wall extent (x=10..68) so no
actor is placed on a WATER cell.

CLAUDE.md

@@ -17,9 +17,17 @@ A scenario is defective if any of the following hold:
 1. The win predicate is satisfiable by a play that ignores the
    advertised capability (the "laziest play wins" inversion).
 2. `within_ticks` or `after_ticks` is set above the tick reachable
-   within `max_turns` (engine advances ~90 ticks per decision turn ⇒
-   `tick ≤ 93 + 90·(max_turns − 1)`); the deadline never bites ⇒ the
-   episode times out as a **DRAW**, not a LOSS.
+   within `max_turns`; the deadline never bites ⇒ the episode times
+   out as a **DRAW**, not a LOSS. The engine constant is
+   `DEFAULT_TICKS_PER_STEP = 30` (`openra-train/src/env.rs:33`), so a
+   non-interrupt-mode pack reaches `tick ≈ 30·max_turns`. Interrupt-
+   mode runs (any pack with a non-empty `interrupts:` block) advance
+   1–`max_ticks` ticks per turn (`max_ticks` defaults to 5 in the
+   bench call site, `openra_bench/eval_core.py`), so per-turn tick
+   advance is variable — read the actual value from
+   `info["ticks_advanced"]` instead of assuming it. The historical
+   "engine advances ~90 ticks per decision turn" estimate is wrong;
+   triaged in `docs/ENGINE_FOLLOWUPS_TRIAGE.md` finding #1.
 3. There is no `fail_condition`, or it only triggers on full
    force-wipe; a stall / preserve / partial outcome silently draws.
 4. The intended capability is not solvable inside the declared budget
@@ -57,9 +65,15 @@ A scenario is defective if any of the following hold:
 
 ## Engine facts you must internalise
 
-- **Ticks/turn:** ~90. Max tick at `max_turns` ≈ `93 + 90·(max_turns
-  − 1)`. Any `within_ticks` / `after_ticks` above this is **inert**
-  (won't bite) ⇒ draw degeneracy.
+- **Ticks/turn:** non-interrupt mode advances exactly
+  `DEFAULT_TICKS_PER_STEP = 30` ticks per `env.step()`
+  (`openra-train/src/env.rs:33`). Max tick at `max_turns` ≈
+  `30·max_turns`. Interrupt mode (`step_until_event`, used whenever
+  `interrupts:` is non-empty) advances 1–`max_ticks` ticks per turn
+  (variable; default `max_ticks = 5`) and breaks on the first signal
+  — read `info["ticks_advanced"]` rather than computing
+  arithmetically. Any `within_ticks` / `after_ticks` above the
+  reachable tick is **inert** (won't bite) ⇒ draw degeneracy.
 - **Engine auto-done:** the engine sets `done=True` when all enemy
   actors are eliminated, or sometimes when an agent unit reaches an
   enemy-key location. Without a persistent enemy actor a win-by-reach

docs/ENGINE_FOLLOWUPS.md

@@ -10,26 +10,33 @@ Filed 2026-05-23 from Wave 12 + Wave 13 agent reports.
 
 ---
 
-## 1. Tick-rate discrepancy (medium severity)
+## 1. Tick-rate discrepancy (medium severity) — RESOLVED (doc fix)
 
 **Finding** (def-position-revealed-direction agent, Wave 13)
 
-CLAUDE.md says "engine advances ~90 ticks per decision turn".
+CLAUDE.md said "engine advances ~90 ticks per decision turn".
 Empirically measured under interrupt mode: **~64 ticks/turn**, not 90.
 
-**Impact**: per-pack `within_ticks` / `after_ticks` deadlines tuned via
-the CLAUDE.md formula `tick ≤ 93 + 90·(max_turns − 1)` may either bite
+**Resolution (2026-05-23, post-merge):** The engine constant is
+`DEFAULT_TICKS_PER_STEP = 30` (`OpenRA-Rust/openra-train/src/env.rs:33`).
+Non-interrupt mode advances exactly 30 ticks per `env.step()`;
+interrupt mode (`step_until_event`) advances 1–`max_ticks` ticks per
+turn, variable per call. `OpenRA-Bench/CLAUDE.md` updated in two
+places — the "~90 ticks/turn" estimate is gone; replaced with the
+actual constant + a note to read `info["ticks_advanced"]` instead of
+calculating arithmetically. See `docs/ENGINE_FOLLOWUPS_TRIAGE.md`
+finding #1.
+
+**Impact (resolved)**: per-pack `within_ticks` / `after_ticks` deadlines
+tuned via the bogus `tick ≤ 93 + 90·(max_turns − 1)` formula may bite
 LATER than intended (silent draw-degeneracy) or NOT AT ALL inside
-`max_turns`. The agent had to tighten `within_ticks: 5400 → 3600` to
-make the deadline actually bite.
-
-**Action options**
-- (a) Re-measure tick-rate under all bench code paths (interrupt vs
-  non-interrupt; varying `parallel_cells`) and update CLAUDE.md with
-  the empirical number.
-- (b) Audit every pack's `within_ticks` against the empirical rate;
-  flag packs whose deadline is now unreachable.
-- (c) Stabilize the engine's tick-per-turn to a documented constant.
+`max_turns`. The bench has manual tightening evidence in
+`combat-attack-from-behind-fog.yaml:105`,
+`econ-protect-harvester-route.yaml:159`,
+`combat-protect-vip-escort.yaml:144`, `tp-survive-n-turns.yaml:151`,
+`rob-deadline-shortened-midway.yaml:107` already manually compensating
+— these are correct (the deadlines were tightened to bite under 30
+ticks/step) and stay.
 
 ---
 
@@ -139,25 +146,35 @@ capability from the bench.
 
 ## 6. Arena generator's default 4-corner mpspawns rotate per-seed (medium severity)
 
-**Finding** (perception-target-vs-fog agent, Wave 13)
-
-`openra_bench/mapgen.py::_arena` emits 4 default corner mpspawns.
-The engine picks one mpspawn per seed and **OFFSETS pre-placed actor
-coords relative to it** — authored `position: [6, 5]` actually appears
-at y=29-33 on some seeds.
-
-**Impact**: per-scenario maps using the `arena` generator with
-default spawns get unexpectedly seed-rotated, breaking position
-invariants. Several Wave 12 packs may be affected silently.
+**Finding** (perception-target-vs-fog agent, Wave 13). **CORRECTED
+2026-05-23 — original wording was misleading; see triage doc finding
+#6 for the post-merge re-read.**
+
+`openra_bench/mapgen.py::_arena` emits 4 default corner mpspawns. The
+engine does NOT offset pre-placed actor coordinates — `position:
+[6, 5]` lands at exactly (6, 5) every seed (`build_scenario_actor`,
+`openra-train/src/env.rs:2338+`, places actors at literal `sa.position`).
+What DOES vary per seed is the **auto-spawned MCV**:
+`assign_spawn_points` (`world.rs:4684+`) picks one mpspawn cell per
+playable slot, deterministic on `seed`. So if a pack relies on the
+auto-MCV being at a specific corner (rather than its absolute
+position), the corner DOES rotate across seeds.
+
+**Impact**: per-scenario maps using the `arena` generator with default
+spawns and depending on a fixed agent-base location see the auto-MCV
+land at a different corner per seed — breaking position invariants
+that assume "the agent's MCV is always at (6,5)".
 
 **Workaround**: declare exactly one mpspawn per generator spec:
-`spawns: [[6, 5]]`. Documented inline in the affected pack.
+`spawns: [[6, 5]]`. Documented inline in the affected pack
+(`perception-target-vs-fog.yaml:62-68, 157, 200, 252`).
 
 **Action options**
-- (a) Default `arena` generator to a SINGLE centred mpspawn so
-  position invariants hold by default.
+- (a) Default `arena` generator to a SINGLE centred mpspawn so the
+  auto-MCV's corner is fixed by default.
 - (b) Add a runtime warning when a generator emits multiple mpspawns
-  AND the scenario has `position:` actors that could be offset.
+  AND the scenario has `position:`-anchored agent actors AND no
+  `spawn_point:` axis is declared.
 - (c) Add `mapgen.py` docstring warning.
 
 ---

openra_bench/scenarios/packs/combat-bait-counter-attack.yaml

@@ -32,6 +32,23 @@
 # not pass through.
 #
 # Engine notes (per CLAUDE.md):
+#   - Map (medium / hard only): custom 128x48 arena (cordon 2 ⇒
+#     playable y in [2..45]) generated via mapgen's `arena` generator
+#     with WATER walls that physically reinforce the north-flank-
+#     strike doctrine of the L-cover variant. The strike force stages
+#     on the NORTH flank (y=12) and the bait jeep on the SOUTH flank
+#     (y=28); a wide head-on engagement band y=16..23 across
+#     x=10..68 is walled so a brute-frontal drive on y=20 is
+#     geometrically impossible — the strike force MUST detour to the
+#     NORTH lane (y=2..15 left of x=10 and y=2..15 above the wall).
+#     The SOUTH lane (y=29..45 plus y>=24 east of x=68) carries the
+#     bait's deep-kite vector that pulls the south arc of guards off
+#     post; the fact at (80,20) sits in the open band east of the
+#     wall (x>=69, y=15..27). Easy retains the pack-level
+#     rush-hour-arena (no head-on wall — the easy 3-guard west-face
+#     idiom works on the open arena because the bait pulls ALL three
+#     guards south, and the strike's head-on east drive sees an
+#     undefended face by the time it arrives).
 #   - `fact` is `MustBeDestroyed`: razing it would auto-`done` the
 #     engine. A SENTINEL enemy `fact` is placed in the far north so
 #     the episode persists past the objective `fact` destruction
@@ -203,6 +220,30 @@ levels:
       and south faces of the enemy yard at (80,20). Destroy the yard,
       losing at most two units, within about 62 turns.
     overrides:
+      # MEDIUM MAP — 128x48 arena (cordon 2 -> playable y in [2..45]).
+      # Head-on engagement band y=16..23 walled across x=10..68 so a
+      # brute attack_move east on y=20 is geometrically impossible —
+      # the strike force MUST swing through the NORTH lane (y=2..15
+      # at x>=10 stays clear above the wall; y=12 staging is in the
+      # open band). The SOUTH lane (y=29..45 left of x=10 plus the
+      # open east column y>=24 east of x=68) carries the bait jeep's
+      # deep-kite vector. The yard at (80,20) sits in the open
+      # corridor east of the wall (x>=69).
+      base_map:
+        generator: arena
+        name: combat-bait-counter-attack-medium
+        width: 128
+        height: 48
+        cordon: 2
+        title: 'Bait + Counter-Attack — Medium (North-Flank Strike)'
+        obstacles:
+          # Mid-axis wall — closes y=16..23 across x=10..68. North
+          # staging (y=12) and south staging (y=28) stay open; the
+          # west connector strip x=2..9 is always clear so the
+          # north-flank strike route runs north from y=12 to y=2..15
+          # (open above wall) east to x=68 then south to the yard
+          # at (80,20) once the bait has pulled the south arc.
+          - {x: 10, y: 16, w: 59, h: 8}
       actors:
         # Strike force: 5 medium tanks staged on the NORTH flank
         # (y=12) so that, once the bait pulls the SOUTH arc off post,
@@ -270,6 +311,21 @@ levels:
       distance (far west or well forward). Destroy the enemy yard,
       losing at most two units, within about 62 turns.
     overrides:
+      # HARD MAP — same head-on wall layout as medium plus the
+      # existing spawn-distance round-robin (spawn 0 at far-west
+      # x=6, spawn 1 at forward x=18). The wall y=16..23 at
+      # x=10..68 still blocks the head-on engagement axis from
+      # both spawns; spawn 1's staging cells (18,12) and (18,28)
+      # sit in the open NORTH/SOUTH bands above and below the wall.
+      base_map:
+        generator: arena
+        name: combat-bait-counter-attack-hard
+        width: 128
+        height: 48
+        cordon: 2
+        title: 'Bait + Counter-Attack — Hard (Spawn-Varied Distance)'
+        obstacles:
+          - {x: 10, y: 16, w: 59, h: 8}
       actors:
         # spawn_point 0 — FAR-WEST staging (x=6): the strike has the
         # full run-in to the yard; the bait has time to pull the

openra_bench/scenarios/schema.py

@@ -212,6 +212,20 @@ class CompiledLevel(BaseModel):
     # world-build time. ScenarioDefinition (training) doesn't know
     # about this field so it's preserved on the CompiledLevel and
     # re-attached at YAML-write time, mirroring `scheduled_events`.
+    #
+    # Engine clamp footgun (`openra-sim/src/resource.rs`,
+    # `seed_ore_patch`): per-cell density is
+    # `clamp(ceil(amount / passable_cells), 1, 12)`. The cap of 12
+    # ore/cell means a small patch with a big `amount` is wasted —
+    # `amount: 2000, radius: 2` (~13 cells) yields only ~156 total ore
+    # = ~3900 cash ceiling. To get a useful econ patch, choose
+    # `amount` so that `amount >= passable_cells * 12` (i.e. fill the
+    # disc to the cap), then GROW the disc via `radius` rather than
+    # the per-cell `amount`. Recommended ratio: `amount =~ 12 * pi *
+    # radius^2 * 1.2` (the 1.2 covers cells on the disc that turn out
+    # to be impassable). At 50 cr/ore the cash ceiling of a patch is
+    # `12 * passable_cells * 50 = 600 * passable_cells`. Triaged in
+    # ENGINE_FOLLOWUPS_TRIAGE.md finding #2.
     ore_patches: list[dict[str, Any]] = Field(default_factory=list)
     # Naval-MVP overlay: explicit `water_cells:` (list of `[x, y]`) and
     # `water_rect:` (a single `[x, y, w, h]`) blocks declare WATER