feat(runtime): auto-regressive play — handover memory every turn + the model's own prior moves in each observation (Markovian -> auto-regressive)

proteus/runtime/_session_core.py

@@ -119,26 +119,40 @@ def build_observation(
     cut_frames: list[str],
     turn_idx: int,
     memory: MemoryCheckpoint | None = None,
+    prior_actions: list[str] | None = None,
 ) -> str:
-    """The ASCII observation the agent sees (turn 1 replays the Cut history).
+    """The self-contained, auto-regressive observation the agent sees this turn.
 
-    Behaviour-identical to SessionRunner._observation. When a CP7 memory
-    checkpoint is supplied, its rendered block is prepended on turn 1.
+    Each turn the agent is called statelessly, so the observation must carry the
+    full context the model needs to continue its OWN trajectory:
+
+    * the handover ``memory`` (the prior episode / persona demonstration), shown
+      EVERY turn so the model never loses it after turn 1;
+    * the scripted ``cut_frames`` pre-roll (the lead-up before it took control);
+    * ``prior_actions`` — the moves the model has already committed THIS run, so
+      it plays auto-regressively (it can see and maintain its own line of play);
+    * the current grid (``"Now:"``).
+
+    ``turn_idx`` is retained for the call signature; at turn 1 there are no
+    prior_actions and the current grid is the handover state, so the observation
+    matches the historical turn-1 layout.
     """
     legend = scenario.legend()
     parts: list[str] = []
-    if turn_idx == 1 and memory is not None:
+    if memory is not None:
         parts.append(render_memory_block(memory))
         parts.append("NOW — this run so far:")
-    if turn_idx == 1 and cut_frames:
+    if cut_frames:
         for i, frame in enumerate(cut_frames[:-1], start=1):
             parts.append(f"Cut {i}:")
             parts.append(frame)
-        parts.append("Now:")
-        parts.append(cut_frames[-1])
-    else:
-        parts.append("Now:")
-        parts.append(render_ascii(scenario, game))
+    if prior_actions:
+        parts.append(
+            "Your moves so far this run (most recent last): "
+            + ", ".join(prior_actions)
+        )
+    parts.append("Now:")
+    parts.append(render_ascii(scenario, game))
     parts.append(legend_text(legend))
     parts.append(f"Available actions: [{', '.join(_ACTIONS)}]")
     return "\n".join(parts)

proteus/runtime/interactive.py

@@ -111,6 +111,7 @@ class InteractiveSession:
         observation = core.build_observation(
             self._scenario, self._game, self._cut_frames, turn_idx,
             memory=self._memory,
+            prior_actions=[t.action for t in self._turns],
         )
         probe_fields: dict[str, object] = {}
         if self._use_probe:

proteus/runtime/memory_gen.py

@@ -79,10 +79,17 @@ def generate_memory(
             action = reference_actions(persona, scenario, game)[0]
             reasoning = ""
         else:
-            observation = "\n".join([
+            obs_parts: list[str] = []
+            if turns:  # auto-regressive: the model's own moves this practice run
+                obs_parts.append(
+                    "Your moves so far this run (most recent last): "
+                    + ", ".join(t.action for t in turns)
+                )
+            obs_parts += [
                 "Now:", frame, legend_text(scenario.legend()),
                 f"Available actions: [{', '.join(_ACTIONS)}]",
-            ])
+            ]
+            observation = "\n".join(obs_parts)
             result = agent.act(observation, list(_ACTIONS), brief)
             action = result.action
             reasoning = result.reasoning[:_REASONING_LIMIT]

proteus/runtime/session.py

@@ -74,6 +74,7 @@ class SessionRunner:
         for turn_idx in range(1, self._play_turns + 1):
             observation = core.build_observation(
                 scenario, game, built.cut_frames, turn_idx, memory=memory,
+                prior_actions=[t.action for t in turns],
             )
 
             probe_fields: dict[str, object] = {}

proteus/runtime/spectate.py

@@ -106,6 +106,7 @@ class SpectateSession:
         observation = core.build_observation(
             self._scenario, self._game, self._cut_frames, turn_idx,
             memory=self._memory,
+            prior_actions=[t.action for t in self._turns],
         )
         result = self._agent.act(observation, list(core._ACTIONS), self._system_prompt)
         self._turns.append(core.make_turn_trace(

tests/runtime/test_auto_regressive.py

@@ -0,0 +1,43 @@
+"""The agent plays auto-regressively: each turn's observation carries the model's
+OWN prior moves this run AND the handover memory every turn (not just turn 1,
+not just the current grid) — so a stateless agent can maintain its trajectory."""
+from __future__ import annotations
+
+import proteus.grid  # noqa: F401
+from proteus.agents.human import HumanAgent
+from proteus.grid.difficulty import Difficulty
+from proteus.runtime.session import SessionRunner
+
+
+def _human(actions):
+    feed = iter(actions)
+    return HumanAgent(input_fn=lambda _p: next(feed), output_fn=lambda _t: None)
+
+
+def _move_log(observation: str) -> str:
+    """The 'your moves so far' segment of an observation (empty if absent)."""
+    if "Your moves so far" not in observation:
+        return ""
+    return observation.split("Your moves so far", 1)[1].split("Now:", 1)[0]
+
+
+def test_memory_shown_every_turn_and_prior_actions_are_auto_regressive():
+    actions = ["up", "left", "down", "right"]
+    runner = SessionRunner(
+        "pack_evade", _human(actions), difficulty=Difficulty.EASY, seed=42,
+        play_turns=len(actions), use_probe=False,
+    )
+    trace = runner.run()
+    # pack_evade attaches a persona memory by default -> it is present on EVERY
+    # turn now (previously only turn 1).
+    assert all("MEMORY" in t.observation for t in trace.turns)
+    # Turn 1: nothing chosen yet.
+    assert _move_log(trace.turns[0].observation) == ""
+    # Turn 2: the turn-1 move is fed back.
+    assert "up" in _move_log(trace.turns[1].observation)
+    # Turn 3: the running line of play accumulates (auto-regressive).
+    log3 = _move_log(trace.turns[2].observation)
+    assert "up" in log3 and "left" in log3
+    # Turn 4: all three prior moves.
+    log4 = _move_log(trace.turns[3].observation)
+    assert log4.count(",") == 2  # three actions -> two separators

tests/runtime/test_session_memory.py

@@ -70,8 +70,13 @@ def test_memory_injection_lengthens_turn1_and_preserves_measurement():
     assert base.memory_ref is None
 
 
-def test_memory_does_not_change_turn2_observation():
+def test_memory_is_shown_every_turn_for_auto_regressive_play():
     base = _runner().run()
     withmem = _runner(memory=_memory(), memory_ref="x").run()
-    # turn 2+ never carry the memory block (only turn 1 does)
-    assert base.turns[1].observation == withmem.turns[1].observation
+    # Auto-regressive play: the handover memory is now carried on turn 2+ as well
+    # (not only turn 1), so a stateless agent never loses it mid-episode. Without
+    # memory the block is absent; with memory it is present and the observations
+    # differ.
+    assert "MEMORY" not in base.turns[1].observation
+    assert "MEMORY" in withmem.turns[1].observation
+    assert base.turns[1].observation != withmem.turns[1].observation