feat(errand): director grass-aware persona routing — civic avoids lawn, cut personas take the grass shortcut

proteus/game/runtime/multiagent_director.py

@@ -446,18 +446,20 @@ def _errand_route_action(a: _Agent, tick: int, wallet_present: bool, ped: _Agent
 
 
 def author_errand_runner(*, seed: int, persona: str | None = None,
-                         max_turns: int = 200) -> MemoryCheckpoint:
+                         max_turns: int = 300) -> MemoryCheckpoint:
     """Author a single-agent errand memory on MEMORY_LAYOUT for one persona.
 
-    The lone courier BFS-routes from start to the donut hollow, resolving the
-    crosswalk / construction / wallet / pedestrian per *persona* (default: the
-    seed-chosen persona, matching the live scenario).
-
-    "detour" personas (e.g. civic) route on a home field that treats the
-    construction block as impassable, so BFS organically takes the genuine
-    bypass (V3->H1->V2 converging left of the construction) instead of
-    oscillating at its edge; "pass" personas route straight through on the
-    plain home field (construction is not a wall)."""
+    The lone courier BFS-routes from start to the brown house (the goal),
+    resolving crosswalk / construction / grass / wallet / pedestrian per
+    *persona* (default: the seed-chosen persona, matching the live scenario).
+
+    The routing field mirrors the live scenario's per-persona ``_policy_field``:
+    grass-'avoid' personas (civic) treat the lawn as impassable and route the
+    longer road-only way around it; grass-'cut' personas (warm_outlaw,
+    opportunist) keep the plain field and BFS naturally takes the grass
+    shortcut. construction-'detour' personas likewise treat the construction
+    block as impassable so BFS takes the genuine bypass instead of oscillating
+    at its edge; 'pass' personas route straight through."""
     from proteus.game.scenarios import errand_world as w
     lay = w.MEMORY_LAYOUT
     r = random.Random(seed)
@@ -466,11 +468,12 @@ def author_errand_runner(*, seed: int, persona: str | None = None,
     policy = w.PERSONAS[persona_id]
     walls = w.wall_cells(lay)
     home_anchor = w.home_target_anchor(lay)
+    extra: set[tuple[int, int]] = set()
+    if policy["grass"] == "avoid":
+        extra |= set(w.grass_cells(lay))
     if policy["construction"] == "detour":
-        home_field = w.bfs_field(home_anchor, w.AGENT,
-                                 walls | w.constr_cells(lay), lay.grid)
-    else:
-        home_field = w.bfs_field(home_anchor, w.AGENT, walls, lay.grid)
+        extra |= w.constr_cells(lay)
+    home_field = w.bfs_field(home_anchor, w.AGENT, walls | frozenset(extra), lay.grid)
     wallet_field = w.bfs_field((lay.wallet[0], lay.wallet[1]), w.AGENT, walls, lay.grid)
 
     chosen = _Agent(id="a0", x=lay.start[0], y=lay.start[1], size=w.AGENT, is_chosen=True)

tests/runtime/test_director_errand_runner.py

@@ -16,7 +16,7 @@ def test_single_agent_deterministic():
     assert len(couriers) == 1 and couriers[0].is_chosen          # exactly ONE moving agent
     assert "npc_down" in {ag.kind for ag in t0.agents}           # pedestrian present
     idxs = {i for (_x, _y, i) in t0.cells}
-    assert {w.C_ROAD, w.C_HOME} <= idxs                          # overlay carried
+    assert {w.C_ROAD, w.C_GRASS, w.C_HOUSE} <= idxs              # overlay carried (road+grass+house)
     assert a.wall_rects                                          # walls carried for replay
 
 
@@ -54,10 +54,32 @@ def test_default_memory_attached():
     assert ck is not None and ck.scenario == "errand_runner"
 
 
-def test_memory_paints_walls_donut_and_one_courier():
+def test_memory_paints_walls_grass_house_and_one_courier():
     ck = author_errand_runner(seed=7, persona="civic")
     scen = get_scenario("errand_runner")()
     g = memory_frames(ck, legend=scen.legend(), grid_size=scen.grid_size)[0]["grid"]
     flat = [v for row in g for v in row]
-    assert w.C_WALL in flat and w.C_HOME in flat and w.C_ROAD in flat   # walls/donut/road painted
+    # walls/grass/house/road painted
+    assert w.C_WALL in flat and w.C_HOUSE in flat and w.C_GRASS in flat and w.C_ROAD in flat
     assert flat.count(w.C_COURIER) == w.AGENT * w.AGENT                  # exactly ONE 2x2 courier
+
+
+def test_civic_avoids_grass_cut_personas_step_on_it():
+    from proteus.game.scenarios import errand_world as w
+    lay = w.MEMORY_LAYOUT
+    grass = set(w.grass_cells(lay))
+    def grass_cells_walked(ck):
+        # any tick where the chosen agent's 2x2 footprint overlaps grass
+        hits = 0
+        for t in ck.memory_turns:
+            ag = next((a for a in t.agents if a.kind == "agent"), None)
+            if ag is None:
+                continue
+            fp = {(ag.pos[0]+i, ag.pos[1]+j) for i in range(ag.size) for j in range(ag.size)}
+            if fp & grass:
+                hits += 1
+        return hits
+    civic = author_errand_runner(seed=7, persona="civic")
+    outlaw = author_errand_runner(seed=7, persona="warm_outlaw")
+    assert grass_cells_walked(civic) == 0          # civic keeps off the lawn
+    assert grass_cells_walked(outlaw) > 0          # warm_outlaw cuts across the grass