feat(cp8): persona-maintenance metrics (agreement/regret/pressure-weighted/drift)

proteus/runtime/metrics.py

@@ -130,7 +130,7 @@ def compute_metrics(
     min_distance = float(min(post_dists)) if post_dists else 0.0
     near_capture_count = float(sum(1 for d in post_dists if d <= 1))
 
-    return {
+    base = {
         "motive_reading_accuracy": congruent / n * 100.0,
         "reactivity_index": (diag_congruent / len(diagnostic) * 100.0) if diagnostic else 0.0,
         "survival_fraction": survival,
@@ -144,3 +144,57 @@ def compute_metrics(
         "min_distance": min_distance,
         "near_capture_count": near_capture_count,
     }
+    base.update(_persona_metrics(turns))
+    return base
+
+
+def _persona_metrics(turns: list[TurnTrace]) -> dict[str, float]:
+    """Persona-maintenance metrics (spec §6.3), only when persona fields exist.
+
+    Returns an empty dict for non-persona runs so the metric-key set is unchanged
+    (additive, category-agnostic). When present:
+
+    - ``action_agreement`` = % of turns whose action is a reference action.
+    - ``reward_regret`` = mean per-turn ``reference_reward − model_reward``.
+    - ``pressure_weighted_agreement`` = pressure-weighted agreement %, so high-
+      danger turns count more (0.0 when total pressure is 0).
+    - ``persona_drift_turn`` = first turn where the rolling-mean (window 3)
+      agreement falls below 0.5, else 0.0 (never drifted).
+    """
+    scored = [t for t in turns if t.reference_actions is not None]
+    if not scored:
+        return {}
+
+    agreements = [1.0 if t.action in (t.reference_actions or []) else 0.0 for t in scored]
+    n = len(scored)
+    action_agreement = sum(agreements) / n * 100.0
+
+    regrets = [
+        (t.reference_reward - t.model_reward)
+        for t in scored
+        if t.reference_reward is not None and t.model_reward is not None
+    ]
+    reward_regret = sum(regrets) / len(regrets) if regrets else 0.0
+
+    pressures = [t.pressure if t.pressure is not None else 0.0 for t in scored]
+    total_pressure = sum(pressures)
+    if total_pressure > 0:
+        pressure_weighted = (
+            sum(a * p for a, p in zip(agreements, pressures)) / total_pressure * 100.0
+        )
+    else:
+        pressure_weighted = 0.0
+
+    drift_turn = 0.0
+    for i in range(n):
+        window = agreements[max(0, i - 2): i + 1]
+        if sum(window) / len(window) < 0.5:
+            drift_turn = float(scored[i].turn_idx)
+            break
+
+    return {
+        "action_agreement": action_agreement,
+        "reward_regret": reward_regret,
+        "pressure_weighted_agreement": pressure_weighted,
+        "persona_drift_turn": drift_turn,
+    }

proteus/runtime/session.py

@@ -25,6 +25,12 @@ from proteus.grid.game import MotiveGridGame
 from proteus.grid.scenario import Scenario, get_scenario
 from proteus.runtime.memory import MemoryCheckpoint, render_memory_block
 from proteus.runtime.metrics import compute_metrics
+from proteus.runtime.persona import (
+    PersonaWeights,
+    pressure as persona_pressure,
+    reference_actions,
+    reward_rw,
+)
 from proteus.runtime.rollout import optimal_rollout
 from proteus.runtime.trace import SessionTrace, TurnTrace
 
@@ -66,6 +72,7 @@ class SessionRunner:
         motive_category: str = "survival",
         memory: MemoryCheckpoint | None = None,
         memory_ref: str | None = None,
+        persona: PersonaWeights | None = None,
     ) -> None:
         self._scenario_name = scenario_name
         self._agent = agent
@@ -76,6 +83,7 @@ class SessionRunner:
         self._motive_category = motive_category
         self._memory = memory
         self._memory_ref = memory_ref
+        self._persona = persona
 
         self._scenario: Scenario | None = None
         self._game: MotiveGridGame | None = None
@@ -113,6 +121,16 @@ class SessionRunner:
             focal_pos = (focal.x, focal.y) if focal else (-1, -1)
             predator_pos = (predator.x, predator.y) if predator else (-1, -1)
             pre_bfs = self._scenario.safety_distance(self._game)
+            # CP8 persona: reference action set + reference reward + pressure are
+            # read from the PRE-move state (the model never sees the weights).
+            ref_acts = ref_reward = turn_pressure = None
+            if self._persona is not None:
+                ref_acts = reference_actions(self._persona, self._scenario, self._game)
+                ref_reward = reward_rw(
+                    self._persona, self._scenario, self._game,
+                    focal_pos, predator_pos, ref_acts[0],
+                )
+                turn_pressure = persona_pressure(self._scenario, self._game)
 
             result = self._agent.act(observation, list(_ACTIONS), system_prompt)
 
@@ -132,6 +150,15 @@ class SessionRunner:
             agent_distance_delta = self._scenario.agent_distance_delta(
                 self._game, focal_pos, predator_pos
             )
+            # CP8 persona: the model's own R_w (BFS geometry is static, so the
+            # pre-move positions + actual blocked status fully determine it).
+            model_reward = reward_regret = None
+            if self._persona is not None:
+                model_reward = reward_rw(
+                    self._persona, self._scenario, self._game,
+                    focal_pos, predator_pos, result.action, blocked=blocked,
+                )
+                reward_regret = ref_reward - model_reward
 
             turns.append(
                 TurnTrace(
@@ -162,6 +189,11 @@ class SessionRunner:
                     pre_bfs_distance=pre_bfs,
                     post_bfs_distance=post_bfs,
                     agent_distance_delta=agent_distance_delta,
+                    reference_actions=ref_acts,
+                    reference_reward=ref_reward,
+                    model_reward=model_reward,
+                    reward_regret=reward_regret,
+                    pressure=turn_pressure,
                 )
             )
 
@@ -201,6 +233,9 @@ class SessionRunner:
             metrics=metrics,
             memory_ref=self._memory_ref,
             horizon=self._play_turns,
+            persona_weight_id=(
+                self._persona.persona_weight_id if self._persona else None
+            ),
         )
 
     # ------------------------------------------------------------------ #

proteus/runtime/trace.py

@@ -79,6 +79,14 @@ class TurnTrace(BaseModel):
     pre_bfs_distance: int | None = None
     post_bfs_distance: int | None = None
     agent_distance_delta: float | None = None
+    # CP8 persona-maintenance fields (spec §6.3/§7); set only when an eval runs
+    # against a hidden persona, else None. The weights are never serialized —
+    # only the public reference action set + scalar rewards/pressure.
+    reference_actions: list[str] | None = None
+    reference_reward: float | None = None
+    model_reward: float | None = None
+    reward_regret: float | None = None
+    pressure: float | None = None
 
 
 class SessionTrace(BaseModel):
@@ -121,3 +129,6 @@ class SessionTrace(BaseModel):
     turn_order: str = "focal_then_predator"
     capture_rule: str = "same_cell"
     horizon: int | None = None  # = play_turns
+    # CP8: public persona id when scored against a hidden persona (spec §7);
+    # the raw weights are never stored on the trace.
+    persona_weight_id: str | None = None

tests/runtime/test_persona.py

@@ -30,3 +30,51 @@ def test_pressure_in_unit_range():
     s, g = _sg()
     p = pressure(s, g)
     assert 0.0 <= p <= 1.0
+
+
+def _runner(action, persona_id="risk_averse", play_turns=1):
+    from proteus.providers import FakeProvider
+    from proteus.agents import VanillaAgent
+    from proteus.runtime import SessionRunner
+    from proteus.runtime.persona import get_persona
+    prov = FakeProvider([f"ACTION: {action}"] * 10, model_name="demo")
+    return SessionRunner(
+        "predator_evade", VanillaAgent(prov), difficulty=Difficulty.EASY,
+        seed=42, play_turns=play_turns, use_probe=False,
+        persona=get_persona(persona_id),
+    ).run()
+
+
+def test_persona_run_records_id_and_fields():
+    trace = _runner("up")
+    assert trace.persona_weight_id == "risk_averse"
+    t = trace.turns[0]
+    assert t.reference_actions is not None
+    assert t.pressure is not None
+    assert t.model_reward is not None
+
+
+def test_reference_action_yields_full_agreement_zero_regret():
+    # 'up' is a reference action at the EASY handover -> perfect maintenance.
+    m = _runner("up").metrics
+    assert m["action_agreement"] == 100.0
+    assert abs(m["reward_regret"]) < 1e-9
+
+
+def test_into_wall_lowers_agreement_and_positive_regret():
+    # 'left' walks into the dead-end wall: not a reference action, worse reward.
+    m = _runner("left").metrics
+    assert m["action_agreement"] == 0.0
+    assert m["reward_regret"] > 0.0
+
+
+def test_persona_metrics_absent_without_persona():
+    from proteus.providers import FakeProvider
+    from proteus.agents import VanillaAgent
+    from proteus.runtime import SessionRunner
+    prov = FakeProvider(["ACTION: up"] * 10, model_name="demo")
+    m = SessionRunner(
+        "predator_evade", VanillaAgent(prov), difficulty=Difficulty.EASY,
+        seed=42, play_turns=2, use_probe=False,
+    ).run().metrics
+    assert "action_agreement" not in m