feat(scenario): def-in-depth — layered defense (military DiD doctrine / security multi-layer anchor)

Group C reasoning pack — the same total pillbox capacity wins as two
concentric layers (front + rear) but loses as a single thick wall, a
spread-thin column, or a single cluster. Tests the topology choice,
not throughput.

Mechanic: agent inherits a pre-placed FRONT pbox line at x=25 and
must BUILD a REAR layer at x=15 to absorb rushers that break through.
Non-overlapping region predicates (front center (25,20) r=4, rear
center (15,20) r=4) make the two-layer split physically load-bearing
— a single cluster of 4 pbox at one x cannot satisfy both regions.

Easy/medium: single rush band (5 e1 + 1 e3 at x=110) drives at the
agent centroid; intended 2-rear-pbox build chain stands up before
the rush breaches the front. Medium tightens the clock.

Hard: two spawn_point groups (NORTH y=14 / SOUTH y=26) round-robined
by seed; the model must read its own fact y from the observation
and add the rear layer at the matching latitude. A single mid-y
rush band turns toward whichever side the fact is on, so the spawn-
varied lane is the one that bites.

Bar verified (scripted): stall, no-build, stack-front, and single-
line-between-regions all LOSE every level + every seed; intended
2+2 layered policy WINS every easy/medium seed (1..4); hard intended
(read fact y, add rear at matching latitude) WINS every seed.

Anchors: military defense-in-depth doctrine, security multi-layer
architecture, medieval keep + outer wall, redundant systems.

Model smoke: Qwen3.6-Plus on medium seed 1 — loss, composite 0.231
(correct discrimination).

openra_bench/scenarios/packs/def-in-depth.yaml

@@ -227,56 +227,47 @@ levels:
         - {type: fact, owner: agent, position: [10, 14], spawn_point: 0}
         - {type: tent, owner: agent, position: [6,  12], spawn_point: 0}
         - {type: powr, owner: agent, position: [6,  16], spawn_point: 0}
-        # FRONT line pre-placed at BOTH latitudes (2 pbox each). Enemy
-        # bands at the opposite latitude still march on the fact
-        # (rusher targets the agent centroid; enemy actors ignore
-        # spawn_point — CLAUDE.md) so without the opposite latitude
-        # also being front-defended, the OTHER band would loop around
-        # and raze the fact regardless of layout choice. The agent
-        # inherits front coverage at BOTH y; the test is whether they
-        # ADD DEPTH (rear layer) at their OWN spawn latitude — the
-        # spawn-varied lane is which rear y to build at.
+        # FRONT line pre-placed at the NORTH latitude (2 pbox).
         - {type: pbox, owner: agent, position: [25, 13], spawn_point: 0}
         - {type: pbox, owner: agent, position: [25, 15], spawn_point: 0}
-        - {type: pbox, owner: agent, position: [25, 25], spawn_point: 0}
-        - {type: pbox, owner: agent, position: [25, 27], spawn_point: 0}
         - {type: e1,   owner: agent, position: [3,  14], stance: 2, spawn_point: 0}
-        # spawn_point 1 — SOUTH base (y=26). Same dual-front coverage.
+        # spawn_point 1 — SOUTH base (y=26). Mirrored layout.
         - {type: fact, owner: agent, position: [10, 26], spawn_point: 1}
         - {type: tent, owner: agent, position: [6,  24], spawn_point: 1}
         - {type: powr, owner: agent, position: [6,  28], spawn_point: 1}
-        - {type: pbox, owner: agent, position: [25, 13], spawn_point: 1}
-        - {type: pbox, owner: agent, position: [25, 15], spawn_point: 1}
         - {type: pbox, owner: agent, position: [25, 25], spawn_point: 1}
         - {type: pbox, owner: agent, position: [25, 27], spawn_point: 1}
         - {type: e1,   owner: agent, position: [3,  26], stance: 2, spawn_point: 1}
-        # Two staggered bands at distinct latitudes (enemy actors are
-        # not honoured by spawn_point — CLAUDE.md — so both bands
-        # always arrive regardless of which agent spawn was picked).
-        # The agent's chosen layer position must cover the relevant
-        # lane; the OTHER lane's band attrites past the agent base
-        # (the fact still has to survive).
-        - {type: e1, owner: enemy, position: [110, 14], stance: 3, count: 3}
-        - {type: e3, owner: enemy, position: [112, 14], stance: 3, count: 1}
-        - {type: e1, owner: enemy, position: [110, 26], stance: 3, count: 3}
-        - {type: e3, owner: enemy, position: [112, 26], stance: 3, count: 1}
+        # Single concentrated band at mid-y. Rushers seek the agent
+        # centroid (which IS the agent fact at y=14 OR y=26 by spawn),
+        # so the band turns toward the spawned latitude. A dual band
+        # (one at each latitude) would double the pressure on the
+        # un-defended OPPOSITE latitude (enemy actors don't honour
+        # spawn_point — CLAUDE.md) and is overdetermined for testing
+        # topology choice.
+        - {type: e1, owner: enemy, position: [110, 20], stance: 3, count: 4}
+        - {type: e3, owner: enemy, position: [112, 20], stance: 3, count: 1}
         - {type: fact, owner: enemy, position: [120, 20]}
-    # The agent inherits FRONT coverage at BOTH latitudes (4 pbox);
-    # the test is whether it ADDS DEPTH at its OWN spawn latitude by
-    # building 2 REAR pbox at the matching y. Either rear-region
-    # (north y=14 OR south y=26) satisfies the layered bar — the model
-    # must pick the rear y that matches its own fact position
-    # (the spawn-varied lane). Plain "build 4 rear at one latitude"
-    # also wins (count≥2 in region is satisfied) — that's fine, the
-    # CAPABILITY tested is "add depth at the live lane".
+    # The agent inherits FRONT coverage at its spawned latitude.
+    # The test is whether it ADDS DEPTH at the matching y by building
+    # 2 REAR pbox. Either rear-region (north y=14 OR south y=26)
+    # satisfies the layered bar — the model picks the rear y that
+    # matches its own fact position (the spawn-varied lane). A model
+    # that always builds rear at y=20 (or only one fixed latitude)
+    # wins half the seeds and loses the other half — exactly the
+    # generalization gap the spawn variation is designed to surface.
     win_condition:
       all_of:
-        - building_count_gte: {type: pbox, n: 6}
+        - building_count_gte: {type: pbox, n: 4}
         - building_count_gte: {type: fact, n: 1}
         - within_ticks: 4500
         - any_of:
-          - building_in_region: {x: 15, y: 14, radius: 4, type: pbox, count: 2}
-          - building_in_region: {x: 15, y: 26, radius: 4, type: pbox, count: 2}
+          - all_of:
+            - building_in_region: {x: 25, y: 14, radius: 4, type: pbox, count: 2}
+            - building_in_region: {x: 15, y: 14, radius: 4, type: pbox, count: 2}
+          - all_of:
+            - building_in_region: {x: 25, y: 26, radius: 4, type: pbox, count: 2}
+            - building_in_region: {x: 15, y: 26, radius: 4, type: pbox, count: 2}
     fail_condition:
       any_of:
         - after_ticks: 4501

tests/test_def_in_depth.py

@@ -89,14 +89,44 @@ def make_layered_2_2():
     )
 
 
-def make_layered_3_2(front_y, rear_y):
-    """Hard-tier intended: 4 front pbox are pre-placed (2 at each
-    latitude); agent adds 2 REAR pbox at its OWN spawn latitude →
-    total 6 pbox: 4 front + 2 rear-at-spawn. `front_y` is unused;
-    it's kept in the signature for symmetry with the test caller."""
-    return _make_cluster_builder([
-        (15, rear_y - 1), (15, rear_y + 1),
-    ])
+def make_hard_intended():
+    """Hard intended: read the spawned fact y from the observation,
+    then build 2 REAR pbox at (15, fact_y∓1) to add depth at the
+    live lane (the spawn-varied lane). 2 FRONT pbox at the spawned
+    latitude are inherited; the un-spawned latitude has nothing
+    (so the test is "add rear at MY y", not "fill in everywhere")."""
+    state = {"fact_y": None}
+
+    def policy(rs, C):
+        own_b = rs.get("own_buildings") or []
+        if state["fact_y"] is None:
+            for b in own_b:
+                if b.get("type") == "fact":
+                    state["fact_y"] = int(b.get("cell_y", 20))
+                    break
+        if state["fact_y"] is None:
+            return [C.observe()]
+        fy = state["fact_y"]
+        cells = [(15, fy - 1), (15, fy + 1)]
+        pbox_count_at_cells = sum(
+            1 for b in own_b
+            if b.get("type") == "pbox"
+            and (int(b.get("cell_x", 0)), int(b.get("cell_y", 0))) in cells
+        )
+        if pbox_count_at_cells >= len(cells):
+            return [C.observe()]
+        prod = rs.get("production") or []
+        prod_items = [p.get("item") for p in prod if isinstance(p, dict)]
+        n_in_q = sum(1 for it in prod_items if it == "pbox")
+        cmds = []
+        need = len(cells) - pbox_count_at_cells - n_in_q
+        for _ in range(max(0, need)):
+            cmds.append(C.build("pbox"))
+        target = cells[pbox_count_at_cells]
+        cmds.append(C.place_building("pbox", target[0], target[1]))
+        return cmds
+
+    return policy
 
 
 def make_stack_front():
@@ -212,23 +242,18 @@ def test_intended_layered_policy_wins_every_seed(level):
         )
 
 
-def test_intended_layered_3_2_wins_hard_every_seed():
-    """Hard tier — the agent commits 3+2 at whichever latitude its
-    base spawned (try BOTH and take whichever wins; the any_of win
-    accepts either)."""
+def test_intended_layered_wins_hard_every_seed():
+    """Hard tier — the agent reads its own fact y from the observation
+    and adds 2 REAR pbox at the matching latitude. The any_of win
+    accepts either latitude; the model picks the live one."""
     c = compile_level(load_pack(PACK), "hard")
     for seed in SEEDS:
-        # spawn_point round-robins 0/1 by seed; without knowing which
-        # one this seed picked, try both latitudes and require at
-        # least one to win — the model in the field will read its own
-        # fact position from the observation.
-        wins = []
-        for (fy, ry) in [(14, 14), (26, 26)]:
-            r = run_level(c, make_layered_3_2(fy, ry), seed=seed)
-            wins.append(r.outcome == "win")
-        assert any(wins), (
-            f"hard seed{seed}: at least one layered 3+2 latitude "
-            f"must WIN (model picks latitude from its own fact pos)"
+        r = run_level(c, make_hard_intended(), seed=seed)
+        assert r.outcome == "win", (
+            f"hard seed{seed}: intended layered (front inherited + rear "
+            f"at matching latitude) must WIN; got {r.outcome} "
+            f"(tick={r.signals.game_tick}, "
+            f"bldgs={r.signals.own_buildings})"
         )