feat(persona): resource_reward feature + greedy persona + predator-optional reference

proteus/game/metrics/persona.py

@@ -6,8 +6,9 @@ participant's action against this reference — *without ever showing the weight
 to the model. Only additive trace/metric fields are produced; the weights stay
 server-side (the participant sees only the public ``persona_weight_id``).
 
-Predator-only world (spec §0): the single strong feature is ``risk_exposure``.
-``resource_reward`` / ``norm_cost`` / ``social_weight`` are deferred to Pass 5.
+Predator-only world (spec §0): the primary feature is ``risk_exposure``;
+``resource_reward`` is now implemented (``greedy`` persona).
+``norm_cost`` / ``social_weight`` are deferred to a later pass.
 
 These helpers reuse the scenario's free-cell BFS geometry (``safety_distance``,
 ``max_bfs_distance``, and the per-cell ``_bfs_distance``/``_is_free`` primitives).
@@ -44,9 +45,9 @@ class PersonaWeights:
     """
 
     persona_weight_id: str
-    risk_cost: float
+    risk_cost: float = 0.0
     capture_penalty: float = 50.0
-    # resource_reward / norm_cost / social_weight arrive in Pass 5.
+    resource_reward: float = 0.0   # weight on proximity to the nearest resource
 
 
 def _clamp(x: float, lo: float, hi: float) -> float:
@@ -74,17 +75,30 @@ def reward_rw(
 ) -> float:
     """Return ``R_w(s, a)`` for one hypothetical focal *action* (spec §3/§6.3).
 
-    ``R_w = -risk_cost * risk_exposure  (- capture_penalty if captured)`` where
-    ``risk_exposure = 1 / (1 + dist(post_focal, predator_before))`` (closer to the
-    predator → higher exposure). Distance is BFS to the **pre-move** predator cell,
-    so the predator's chase response never distorts the reward.
+    Formula (terms omitted when not applicable):
+
+    ``R_w = -risk_cost * risk_exposure  (- capture_penalty if captured)``
+        where ``risk_exposure = 1 / (1 + dist(post_focal, predator_before))``
+        (closer to predator → higher exposure); omitted when no predator is present.
+
+    ``     + resource_reward * (1 / (1 + nearest_resource_distance))``
+        omitted when ``resource_reward`` is 0 or no resource distance is available.
+
+    Distance is BFS to the **pre-move** predator/resource cell so neither chase
+    response nor resource collection distorts the reward.
     """
     post = _post_focal(scenario, game, focal_before, action, blocked)
-    d = scenario._bfs_distance(game, post, predator_before)
-    risk_exposure = 1.0 if d is None else 1.0 / (1.0 + d)
-    r = -weights.risk_cost * risk_exposure
-    if captured:
-        r -= weights.capture_penalty
+    r = 0.0
+    if game.predator_sprite is not None:
+        d = scenario._bfs_distance(game, post, predator_before)
+        risk_exposure = 1.0 if d is None else 1.0 / (1.0 + d)
+        r -= weights.risk_cost * risk_exposure
+        if captured:
+            r -= weights.capture_penalty
+    if weights.resource_reward:
+        rd = scenario.nearest_resource_distance(game, post)
+        if rd is not None:
+            r += weights.resource_reward * (1.0 / (1.0 + rd))
     return r
 
 
@@ -96,11 +110,11 @@ def reference_actions(weights: PersonaWeights, scenario, game) -> list[str]:
     full winning set so ``action_agreement`` can credit any reference-optimal move.
     """
     focal = game.focal_sprite
-    predator = game.predator_sprite
-    if focal is None or predator is None:
+    if focal is None:
         return ["stay"]
+    predator = game.predator_sprite
     focal_before = (focal.x, focal.y)
-    predator_before = (predator.x, predator.y)
+    predator_before = (predator.x, predator.y) if predator is not None else (-1, -1)
 
     scored: dict[str, float] = {}
     for action in _ACTION_ORDER:
@@ -138,6 +152,9 @@ BUILTIN_PERSONAS: dict[str, PersonaWeights] = {
     "survival_optimal": PersonaWeights(
         persona_weight_id="survival_optimal", risk_cost=3.0, capture_penalty=100.0
     ),
+    "greedy": PersonaWeights(
+        persona_weight_id="greedy", risk_cost=1.0, resource_reward=6.0
+    ),
 }
 
 

proteus/game/scenarios/base.py

@@ -288,6 +288,17 @@ class Scenario(ABC):
         """
         return None
 
+    def nearest_resource_distance(self, game, cell) -> int | None:
+        """Distance from *cell* (focal anchor) to the nearest collectible resource.
+
+        ``None`` by default (no resources). Resource scenarios override this so
+        the persona reward's resource term can pull the reference toward the
+        nearest resource. Distance metric is the scenario's choice (BFS or
+        Manhattan); smaller = closer.
+        """
+        del game, cell
+        return None
+
 
 # --------------------------------------------------------------------------- #
 # Scenario registry

tests/metrics/test_persona_resource.py

@@ -0,0 +1,52 @@
+# tests/metrics/test_persona_resource.py
+"""Greedy persona seeks resources; reference works with no predator."""
+from proteus.game.metrics.persona import (
+    PersonaWeights, get_persona, reference_actions, reward_rw,
+)
+
+
+class _FakeSprite:
+    def __init__(self, x, y):
+        self.x, self.y = x, y
+
+
+class _ResourceWorld:
+    """Minimal scenario+game stand-in: open 10x10, one resource at (9,5), no predator."""
+    grid_size = (10, 10)
+    _resource = (9, 5)
+
+    # --- scenario surface persona.py uses ---
+    def _is_free(self, game, cell):
+        x, y = cell
+        return 0 <= x < 10 and 0 <= y < 10
+
+    def nearest_resource_distance(self, game, cell):
+        return abs(cell[0] - self._resource[0]) + abs(cell[1] - self._resource[1])
+
+    # --- game surface persona.py uses ---
+    @property
+    def focal_sprite(self):
+        return _FakeSprite(5, 5)
+
+    @property
+    def predator_sprite(self):
+        return None
+
+
+def test_greedy_reference_steps_toward_resource():
+    world = _ResourceWorld()
+    greedy = get_persona("greedy")
+    # focal at (5,5), resource at (9,5) -> "right" reduces distance most.
+    assert "right" in reference_actions(greedy, world, world)
+
+
+def test_reward_rw_no_predator_uses_resource_only():
+    world = _ResourceWorld()
+    greedy = get_persona("greedy")
+    r_right = reward_rw(greedy, world, world, (5, 5), (-1, -1), "right")
+    r_left = reward_rw(greedy, world, world, (5, 5), (-1, -1), "left")
+    assert r_right > r_left  # closer to the resource scores higher
+
+
+def test_resource_reward_defaults_zero_for_existing_personas():
+    assert get_persona("risk_averse").resource_reward == 0.0