feat(cp8): persona-driven memory generation (hidden weights, public id)

proteus/runtime/memory.py

@@ -48,6 +48,10 @@ class MemoryCheckpoint(BaseModel):
         memory_turns: The episode's per-turn records, in play order.
         outcome: ``"survived"`` or ``"eliminated"``.
         transparent_prompt: The full-info brief used to drive the episode.
+        persona_weight_id: Public id of the hidden persona that drove this
+            demonstration (CP8), or ``None`` for a model self-play memory. Only
+            the id is stored — the raw reward weights are never serialized into
+            the participant-visible checkpoint.
     """
 
     model: str
@@ -59,6 +63,7 @@ class MemoryCheckpoint(BaseModel):
     memory_turns: list[MemoryTurn] = Field(default_factory=list)
     outcome: str
     transparent_prompt: str
+    persona_weight_id: str | None = None
 
 
 def _safe(name: str) -> str:

proteus/runtime/memory_gen.py

@@ -18,6 +18,7 @@ from proteus.grid.difficulty import Difficulty
 from proteus.grid.game import MotiveGridGame
 from proteus.grid.scenario import get_scenario
 from proteus.runtime.memory import MemoryCheckpoint, MemoryTurn
+from proteus.runtime.persona import PersonaWeights, reference_actions
 
 _ACTIONS = ["up", "down", "left", "right", "stay"]
 _REASONING_LIMIT = 2000  # cap stored reasoning so checkpoints stay small
@@ -37,18 +38,28 @@ def generate_memory(
     memory_turns: int,
     model_name: str,
     clock: Callable[[], str] = _utc_now_stamp,
+    persona: PersonaWeights | None = None,
 ) -> MemoryCheckpoint:
     """Run a full-info self-play episode and return it as a MemoryCheckpoint.
 
     Args:
         scenario_name: Registered scenario key.
-        agent: The playing agent (its provider drives the actions).
+        agent: The playing agent (its provider drives the actions). May be
+            ``None`` when *persona* is set (the reference policy plays instead).
         difficulty: Difficulty band of the memory world (= the scored game).
         seed: Seed of the memory world (= the scored game).
         memory_turns: Max self-play turns; the episode also stops on terminal.
         model_name: Identifier stored on the checkpoint.
         clock: Returns the ``created_at`` stamp (injected for deterministic tests).
+        persona: When set, the memory is a *persona demonstration* — each action
+            is the deterministic reference action (first tie-break of
+            ``reference_actions``) for the hidden weights, not a model self-play.
+            The public ``persona_weight_id`` is recorded; the raw weights are
+            never serialized, and the transparent brief stays weight-agnostic so
+            the eval model must infer the persona from behaviour alone (spec §3).
     """
+    if persona is None and agent is None:
+        raise ValueError("generate_memory needs an agent unless a persona is given")
     scenario = get_scenario(scenario_name)()
     rng = random.Random(seed)
     game = MotiveGridGame(scenario, rng, difficulty, max_steps=memory_turns)
@@ -62,23 +73,31 @@ def generate_memory(
         predator_pos = (predator.x, predator.y) if predator else (-1, -1)
 
         frame = frame_to_ascii(game.current_grid(), scenario.legend())
-        observation = "\n".join([
-            "Now:", frame, legend_text(scenario.legend()),
-            f"Available actions: [{', '.join(_ACTIONS)}]",
-        ])
-        result = agent.act(observation, list(_ACTIONS), brief)
+
+        if persona is not None:
+            # Deterministic persona demonstration: the reference policy plays.
+            action = reference_actions(persona, scenario, game)[0]
+            reasoning = ""
+        else:
+            observation = "\n".join([
+                "Now:", frame, legend_text(scenario.legend()),
+                f"Available actions: [{', '.join(_ACTIONS)}]",
+            ])
+            result = agent.act(observation, list(_ACTIONS), brief)
+            action = result.action
+            reasoning = result.reasoning[:_REASONING_LIMIT]
 
         turns.append(MemoryTurn(
             turn_idx=turn_idx,
             frame_ascii=frame,
-            action=result.action,
-            reasoning=result.reasoning[:_REASONING_LIMIT],
+            action=action,
+            reasoning=reasoning,
             focal_pos=focal_pos,
             predator_pos=predator_pos,
         ))
 
-        game.apply_motive_action(result.action)
-        scenario.record_focal_move(result.action)
+        game.apply_motive_action(action)
+        scenario.record_focal_move(action)
         if game.eliminated or game.survived:
             break
 
@@ -93,4 +112,5 @@ def generate_memory(
         memory_turns=turns,
         outcome=outcome,
         transparent_prompt=brief,
+        persona_weight_id=persona.persona_weight_id if persona else None,
     )

tests/runtime/test_memory_persona.py

@@ -0,0 +1,17 @@
+from proteus.grid.difficulty import Difficulty
+from proteus.runtime.memory_gen import generate_memory
+from proteus.runtime.persona import PersonaWeights
+
+
+def test_persona_memory_is_deterministic_and_tags_persona():
+    w = PersonaWeights(persona_weight_id="risk_averse", risk_cost=5.0)
+    ck = generate_memory(
+        "predator_evade", agent=None, difficulty=Difficulty.EASY, seed=42,
+        memory_turns=5, model_name="ref", clock=lambda: "FIXED", persona=w,
+    )
+    assert ck.persona_weight_id == "risk_averse"
+    assert 1 <= len(ck.memory_turns) <= 5
+    # risk-averse demo never walks into the dead-end wall on the diagnostic turn
+    assert ck.memory_turns[0].action in ("up", "down", "right", "stay")
+    # weights are NOT in the participant-visible checkpoint text
+    assert "risk_cost" not in ck.model_dump_json()