refactor(scenario): delete predator_evade; template is the canonical scenario

proteus/cli/parser.py

@@ -25,7 +25,7 @@ def build_parser() -> argparse.ArgumentParser:
     sub = parser.add_subparsers(dest="command", required=True)
 
     run = sub.add_parser("run", help="run one session and append its trace")
-    run.add_argument("--scenario", default="predator_evade")
+    run.add_argument("--scenario", default="template")
     run.add_argument(
         "--model",
         required=True,
@@ -61,7 +61,7 @@ def build_parser() -> argparse.ArgumentParser:
     run.set_defaults(func=_cmd_run)
 
     play = sub.add_parser("play", help="play a session as a human via stdin")
-    play.add_argument("--scenario", default="predator_evade")
+    play.add_argument("--scenario", default="template")
     play.add_argument(
         "--difficulty", default="easy", choices=[d.value for d in Difficulty]
     )
@@ -82,7 +82,7 @@ def build_parser() -> argparse.ArgumentParser:
     memory = sub.add_parser(
         "memory", help="generate + save an LLM memory pre-roll checkpoint"
     )
-    memory.add_argument("--scenario", default="predator_evade")
+    memory.add_argument("--scenario", default="template")
     memory.add_argument(
         "--model", required=True,
         help=(

proteus/game/agents/vanilla.py

@@ -15,9 +15,9 @@ from proteus.providers.thinking_utils import parse_thinking_tags
 
 _DEFAULT_ACTION = "stay"
 
-# NOTE: this directive is predator_evade-scoped for the current slice; the spec
-# defers scenario generalization, so the "predator" framing is intentional here.
-# A future multi-scenario agent should make this directive configurable.
+# NOTE: this directive is template-scoped (predator-evasion) for the current
+# slice; the spec defers scenario generalization, so the "predator" framing is
+# intentional here. A future multi-scenario agent should make this configurable.
 _ACTION_DIRECTIVE = (
     "\n\nThink about where the predator is and where it is heading, then end "
     "your reply with a line:\nACTION: <one of {actions}>"

proteus/game/runtime/session.py

@@ -22,7 +22,7 @@ class SessionRunner:
     """Run one motive_grid session end-to-end and return a SessionTrace.
 
     Args:
-        scenario_name: Registered scenario (e.g. ``"predator_evade"``).
+        scenario_name: Registered scenario (e.g. ``"template"``).
         agent: The :class:`Agent` that plays after the handover.
         difficulty: Difficulty band (controls Cut length).
         seed: Seed for the deterministic world/Cut.

proteus/game/scenarios/__init__.py

@@ -4,9 +4,8 @@ Importing this package fires each scenario's ``@register_scenario`` decorator,
 populating the registry in :mod:`proteus.game.scenarios.base`.
 """
 
-from proteus.game.scenarios import predator_evade  # noqa: F401  — side-effect: register
 from proteus.game.scenarios import template  # noqa: F401  — side-effect: register
 from proteus.game.scenarios import predator_chase  # noqa: F401  — side-effect: register
 from proteus.game.scenarios import resource_race  # noqa: F401  — side-effect: register
 
-__all__ = ["predator_evade", "template", "predator_chase", "resource_race"]
+__all__ = ["template", "predator_chase", "resource_race"]

proteus/game/scenarios/base.py

@@ -13,13 +13,13 @@ decorator, mirroring the task-module registry at
         Scenario, register_scenario,
     )
 
-    @register_scenario("predator_evade")
-    class PredatorEvade(Scenario):
+    @register_scenario("template")
+    class Template(Scenario):
         ...
 
     # Elsewhere:
     from proteus.game.scenarios.base import get_scenario
-    scenario = get_scenario("predator_evade")()
+    scenario = get_scenario("template")()
 
 See ``docs/superpowers/specs/2026-06-01-motive-grid-design.md`` §4 for the
 interface contract.
@@ -69,8 +69,8 @@ class Scenario(ABC):
     # Turn resolution order. "focal_first" (default): focal moves, then the
     # threat advances (chasing the focal's NEW cell). "predator_first": the
     # threat advances first (chasing the focal's CURRENT cell), then the focal
-    # moves. Scenarios override this; predator_evade keeps the default so its
-    # dead-end diagnostic is preserved.
+    # moves. Scenarios override this as needed (e.g. template uses
+    # "predator_first").
     turn_order: str = "focal_first"
 
     @abstractmethod

proteus/game/scenarios/predator_evade.py

@@ -1,604 +0,0 @@
-"""predator_evade — the bear-chase evasion scenario for motive_grid.
-
-A predator pursues the focal agent across the grid (8x8 at EASY; larger at
-higher difficulties) by taking one shortest-path (BFS) step toward it every
-turn, so its motion reads as a clear
-*chase* intent rather than noise (the ToM signal the benchmark probes).  The
-world is laced with a short internal wall that forms a **dead-end to the west**,
-exactly where the focal agent has been walking.  At the Cut handover the only
-survival-correct move is to *detour* away from the wall while the fixed habit
-("keep walking west") runs the agent straight into the dead-end with the
-predator closing from behind.  That divergence — ``optimal_action`` (escape) vs
-``habit_action`` (keep west) — is the diagnostic the benchmark measures.
-
-Coordinate convention (shared with ``game.py``): ``y`` grows DOWNWARD.  Actions
-are the strings ``"up"`` ``(0,-1)``, ``"down"`` ``(0,1)``, ``"left"`` ``(-1,0)``,
-``"right"`` ``(1,0)``, ``"stay"`` ``(0,0)``.
-
-Deterministic EASY layout (seed-independent; placement is fixed, not random,
-so ``rng`` is threaded only for forward-compatible tie-breaks)::
-
-    col:  0 1 2 3 4 5 6 7      x ->
-    row 0 . . . . . . . .
-    row 1 . . . . . . . .
-    row 2 . . # . . . . .      '#' = wall  (PIXEL_PERFECT)
-    row 3 . . # A . S B .      'A' = focal start (5,3) ... walks west
-    row 4 . . # . . . . .      'B' = predator start (7,3)
-    row 5 . . # . . . . .      'S' = focal Cut-handover cell (3,3)
-    row 6 . . . . . . . .
-    row 7 . . . . . . . .
-
-Cut pre-roll (``cut_length`` EASY = 2, ``cut_focal_policy`` = "left"):
-
-    start    focal (5,3)  predator (7,3)
-    step 1   focal (4,3)  predator (6,3)
-    step 2   focal (3,3)  predator (5,3)      <- HANDOVER / diagnostic state
-
-At the handover the wall column ``x=2`` (rows 2..5) sits directly west of the
-focal at ``(3,3)``:
-
-    * ``habit_action``  = "left"  -> blocked by the wall (dead-end), no progress,
-      BFS distance to predator stays 2.
-    * ``optimal_action`` = "up"   -> steps to ``(3,2)``, the legal move that
-      MAXIMIZES BFS distance from the predator (distance 3).  ("up" and "down"
-      tie at distance 3; the fixed action order breaks the tie in favour of
-      "up".)
-
-Hence ``optimal_action != habit_action`` at the Cut — the property the whole
-discrimination metric depends on.
-
-Palette indices (consistent with :meth:`PredatorEvade.legend` and the pixels
-handed to each sprite in :meth:`PredatorEvade.build_level`):
-
-    * ``5`` -> ``'.'``  background (the arc_grid camera default)
-    * ``1`` -> ``'A'``  focal agent
-    * ``2`` -> ``'B'``  predator
-    * ``3`` -> ``'#'``  wall
-"""
-
-from __future__ import annotations
-
-import random
-from collections import deque
-from dataclasses import dataclass
-from typing import TYPE_CHECKING
-
-from proteus.game.engine import BlockingMode, Level, Sprite
-from proteus.game.engine.difficulty import Difficulty
-
-from .base import Scenario, register_scenario
-
-if TYPE_CHECKING:
-    from ..engine.grid import MotiveGridGame
-
-# --------------------------------------------------------------------------- #
-# Palette indices (must match build_level pixels and legend()).
-# --------------------------------------------------------------------------- #
-BACKGROUND_IDX = 5  # arc_grid Camera default background
-FOCAL_IDX = 1
-PREDATOR_IDX = 2
-WALL_IDX = 3
-
-# Survival-category reward constants (moved from SessionRunner; see CP6 spec §5).
-_REWARD_CAPTURED = -50.0
-_REWARD_SURVIVED = 50.0
-_REWARD_WALL_HIT = -3.0
-
-# --------------------------------------------------------------------------- #
-# EASY defaults consumed before build_level runs (class grid_size hint +
-# __init__'s pre-build wall set). The full per-difficulty layouts — including
-# focal/predator starts — live in _LAYOUTS below.
-# --------------------------------------------------------------------------- #
-_GRID_SIZE: tuple[int, int] = (8, 8)
-# Vertical wall column forming the dead-end west of the focal's path.
-_WALL_CELLS: tuple[tuple[int, int], ...] = (
-    (2, 2),
-    (2, 3),
-    (2, 4),
-    (2, 5),
-)
-
-# --------------------------------------------------------------------------- #
-# Per-difficulty hand-authored layouts.
-# --------------------------------------------------------------------------- #
-
-@dataclass(frozen=True)
-class _Layout:
-    """A hand-authored deterministic layout for one difficulty band."""
-
-    grid_size: tuple[int, int]
-    focal_start: tuple[int, int]
-    predator_start: tuple[int, int]
-    wall_cells: tuple[tuple[int, int], ...]
-
-
-# Candidate hand-authored layouts. Tuned under the golden invariant test
-# (Task 3): the pre-roll direction ("left") must dead-end into a wall at the
-# handover while a perpendicular move increases BFS distance, so
-# optimal_action != habit_action. Adjust coordinates if Task 3 fails.
-_LAYOUTS: dict[Difficulty, _Layout] = {
-    Difficulty.EASY: _Layout(
-        grid_size=(8, 8),
-        focal_start=(5, 3),
-        predator_start=(7, 3),
-        wall_cells=((2, 2), (2, 3), (2, 4), (2, 5)),
-    ),
-    Difficulty.MEDIUM: _Layout(
-        grid_size=(10, 10),
-        focal_start=(6, 4),
-        predator_start=(8, 4),
-        wall_cells=tuple((3, y) for y in range(2, 8)),
-    ),
-    Difficulty.HARD: _Layout(
-        grid_size=(12, 12),
-        focal_start=(7, 5),
-        predator_start=(9, 5),
-        wall_cells=(
-            tuple((3, y) for y in range(3, 9))
-            + tuple((x, 8) for x in range(4, 7))
-        ),
-    ),
-    Difficulty.EXPERT: _Layout(
-        grid_size=(12, 12),
-        focal_start=(7, 5),
-        predator_start=(9, 4),
-        wall_cells=(
-            tuple((3, y) for y in range(2, 10))
-            + ((4, 3), (5, 3))
-        ),
-    ),
-}
-
-# Action string -> (dx, dy).  Mirror of game._DIRECTION_DELTAS; duplicated here
-# so the scenario's answer-key reasoning is self-contained and does not import
-# private game internals.
-_DELTAS: dict[str, tuple[int, int]] = {
-    "up": (0, -1),
-    "down": (0, 1),
-    "left": (-1, 0),
-    "right": (1, 0),
-    "stay": (0, 0),
-}
-
-# Fixed deterministic tie-break order for both the predator's chase step and the
-# focal's optimal-action search.  Movement directions first (so a move that
-# strictly improves the objective is always preferred over "stay"), in the
-# canonical up/down/left/right order.
-_TIE_BREAK_ORDER: tuple[str, ...] = ("up", "down", "left", "right", "stay")
-
-# Cut pre-roll length per difficulty.  EASY = 2 (per spec §5).
-_CUT_LENGTH: dict[Difficulty, int] = {
-    Difficulty.EASY: 2,
-    Difficulty.MEDIUM: 2,
-    Difficulty.HARD: 3,
-    Difficulty.EXPERT: 3,
-}
-_DEFAULT_CUT_LENGTH = 2
-
-
-@register_scenario("predator_evade")
-class PredatorEvade(Scenario):
-    """Bear-chase evasion scenario (see module docstring for the geometry).
-
-    The scenario owns one piece of mutable bookkeeping that does not belong on
-    the world: ``_wall_cells`` (the set of wall coordinates, cached in
-    :meth:`build_level` so the BFS helpers can treat walls as blocked without
-    re-deriving them from the merged ``sys_static`` sprite) and
-    ``_last_focal_move`` (the focal's last committed move direction, used by
-    :meth:`habit_action`).  Per-game *world* state (sprite positions, step
-    count) lives on the injected :class:`~..game.MotiveGridGame`.
-    """
-
-    task_name: str = "predator_evade"
-    # Default hint only; build_level() overwrites this per instance with the
-    # difficulty-specific size. Read scenario.grid_size only AFTER build_level
-    # has been called (the game sizes its camera from it right after building).
-    grid_size: tuple[int, int] = _GRID_SIZE
-    rules_text: str = (
-        "You control the focal agent 'A' on a grid. A predator 'B' hunts "
-        "you, moving one cell along the shortest path toward you every turn. "
-        "Walls '#' block movement; '.' is open ground. You are eliminated if "
-        "the predator reaches your cell. Survive as long as you can. "
-        "Actions: up, down, left, right, stay (up decreases the row, down "
-        "increases it; left/right move along the column). Read the predator's "
-        "approach and move to stay away from it — do not walk into walls or "
-        "dead-ends."
-    )
-    memory_brief: str = (
-        "PRACTICE / MEMORY RUN. You control the focal agent 'A' on a grid. A "
-        "predator 'B' hunts you: every turn it takes one step along the SHORTEST "
-        "path (BFS) toward your current cell. Walls '#' block movement and form "
-        "dead-ends; '.' is open ground. You are eliminated if the predator reaches "
-        "your cell. This is a no-stakes practice run to build your own experience "
-        "of how the predator chases and how the walls trap you — play to survive "
-        "and learn the dynamics. Actions: up, down, left, right, stay (up decreases "
-        "the row, down increases it; left/right move along the column). End your "
-        "reply with a line: ACTION: <one of up, down, left, right, stay>"
-    )
-
-    def __init__(self) -> None:
-        """Initialize per-game scenario bookkeeping.
-
-        ``_last_focal_move`` defaults to ``"left"`` because the focal agent
-        walks west throughout the Cut pre-roll (:meth:`cut_focal_policy`); at the
-        handover the model's "habit" is therefore to keep going west, which the
-        dead-end geometry turns into the wrong move.
-        """
-        self._wall_cells: frozenset[tuple[int, int]] = frozenset(_WALL_CELLS)
-        self._last_focal_move: str = "left"
-
-    # ------------------------------------------------------------------ #
-    # World construction
-    # ------------------------------------------------------------------ #
-    def build_level(self, rng: random.Random, difficulty: Difficulty) -> Level:
-        """Build the hand-authored level for *difficulty* (deterministic).
-
-        Args:
-            rng: Seeded RNG (reserved for tie-breaks; layouts are fixed).
-            difficulty: The session difficulty band.
-
-        Returns:
-            A :class:`~proteus.game.engine.Level` with focal, predator, and walls.
-        """
-        del rng  # deterministic hand-authored layouts
-        layout = _LAYOUTS.get(difficulty, _LAYOUTS[Difficulty.EASY])
-        self._wall_cells = frozenset(layout.wall_cells)
-        # Instance attribute shadows the class default so the camera and
-        # within_bounds both see THIS band's size (they read scenario.grid_size).
-        self.grid_size = layout.grid_size
-
-        focal = Sprite(
-            pixels=[[FOCAL_IDX]],
-            name="focal",
-            x=layout.focal_start[0],
-            y=layout.focal_start[1],
-            blocking=BlockingMode.PIXEL_PERFECT,
-        )
-        predator = Sprite(
-            pixels=[[PREDATOR_IDX]],
-            name="predator",
-            x=layout.predator_start[0],
-            y=layout.predator_start[1],
-            blocking=BlockingMode.PIXEL_PERFECT,
-        )
-        sprites: list[Sprite] = [focal, predator]
-        for (wx, wy) in layout.wall_cells:
-            sprites.append(
-                Sprite(
-                    pixels=[[WALL_IDX]],
-                    name="wall",
-                    x=wx,
-                    y=wy,
-                    blocking=BlockingMode.PIXEL_PERFECT,
-                    tags=["sys_static"],
-                )
-            )
-        return Level(sprites=sprites)
-
-    # ------------------------------------------------------------------ #
-    # Cut pre-roll
-    # ------------------------------------------------------------------ #
-    def cut_focal_policy(self, game: MotiveGridGame) -> str:
-        """Drive the focal agent west during the Cut pre-roll.
-
-        The scripted westward walk sets up the dead-end tension: by the handover
-        the focal sits just east of the wall with the predator closing behind.
-
-        Args:
-            game: The live game (unused; the policy is unconditional).
-
-        Returns:
-            ``"left"``.
-        """
-        del game
-        return "left"
-
-    def cut_length(self, difficulty) -> int:
-        """Return the Cut pre-roll step count ``K`` for *difficulty*.
-
-        Args:
-            difficulty: The session difficulty (a :class:`Difficulty`, or any
-                value; unknown values fall back to the EASY length).
-
-        Returns:
-            ``2`` for EASY (placing the focal at ``(3,3)`` against the wall).
-        """
-        return _CUT_LENGTH.get(difficulty, _DEFAULT_CUT_LENGTH)
-
-    # ------------------------------------------------------------------ #
-    # Threat motion (motive = chase)
-    # ------------------------------------------------------------------ #
-    def advance_threat(self, game: MotiveGridGame) -> None:
-        """Move the predator one BFS step along a shortest path to the focal.
-
-        The predator pursues over *free* cells only (grid minus walls), so its
-        motion is purely a function of the focal position — a reactive chase,
-        never random.  The framework only guards the focal agent's bounds, so
-        this method excludes off-grid and wall cells itself.  If no path to the
-        focal exists, the predator stays put.
-
-        Tie-break: among the neighbours that lie on a shortest path, the first
-        in :data:`_TIE_BREAK_ORDER` (up, down, left, right) wins, which is fully
-        deterministic.
-
-        Args:
-            game: The live game whose predator sprite is moved in place.
-        """
-        predator = game.predator_sprite
-        focal = game.focal_sprite
-        if predator is None or focal is None:
-            return
-
-        src = (predator.x, predator.y)
-        dst = (focal.x, focal.y)
-        if src == dst:
-            return
-
-        next_cell = self._chase_step(game, src, dst)
-        if next_cell is None:
-            return
-        predator.move(next_cell[0] - predator.x, next_cell[1] - predator.y)
-
-    def _chase_step(
-        self,
-        game: MotiveGridGame,
-        src: tuple[int, int],
-        dst: tuple[int, int],
-    ) -> tuple[int, int] | None:
-        """Return the predator's next cell on a shortest path ``src`` -> ``dst``.
-
-        Picks the free neighbour of *src* (in :data:`_TIE_BREAK_ORDER`) whose BFS
-        distance to *dst* is minimal.  Returns ``None`` if *dst* is unreachable.
-
-        Args:
-            game: The live game (for bounds checks).
-            src: The predator's current ``(x, y)``.
-            dst: The focal's ``(x, y)``.
-        """
-        best_cell: tuple[int, int] | None = None
-        best_dist: int | None = None
-        for action in _TIE_BREAK_ORDER:
-            dx, dy = _DELTAS[action]
-            if dx == 0 and dy == 0:
-                continue
-            cand = (src[0] + dx, src[1] + dy)
-            if not self._is_free(game, cand):
-                continue
-            dist = self._bfs_distance(game, cand, dst)
-            if dist is None:
-                continue
-            if best_dist is None or dist < best_dist:
-                best_dist = dist
-                best_cell = cand
-        return best_cell
-
-    # ------------------------------------------------------------------ #
-    # Outcome
-    # ------------------------------------------------------------------ #
-    def check_elimination(self, game: MotiveGridGame) -> bool:
-        """Return whether the predator has captured the focal agent.
-
-        Args:
-            game: The live game to inspect.
-
-        Returns:
-            ``True`` iff the focal and predator occupy the same cell.
-        """
-        focal = game.focal_sprite
-        predator = game.predator_sprite
-        if focal is None or predator is None:
-            return False
-        return focal.x == predator.x and focal.y == predator.y
-
-    # ------------------------------------------------------------------ #
-    # Answer keys
-    # ------------------------------------------------------------------ #
-    def optimal_action(self, game: MotiveGridGame) -> str:
-        """Return the legal move that maximizes BFS distance from the predator.
-
-        Considers every action in :data:`_TIE_BREAK_ORDER`; an action is *legal*
-        only if its resulting cell is on-grid and not a wall (moves into a wall
-        or off-grid are discarded, never silently treated as "stay").  Among the
-        legal actions the one whose resulting cell has the greatest BFS distance
-        to the predator wins; ties break by the fixed action order.  This is the
-        motive-congruent escape — the prediction answer key.
-
-        Args:
-            game: The live game to inspect.
-
-        Returns:
-            One of ``"up"``, ``"down"``, ``"left"``, ``"right"``, ``"stay"``.
-            ``"stay"`` is returned only if no other action is legal (boxed in).
-        """
-        focal = game.focal_sprite
-        predator = game.predator_sprite
-        if focal is None or predator is None:
-            return "stay"
-
-        src = (focal.x, focal.y)
-        pred_cell = (predator.x, predator.y)
-
-        best_action = "stay"
-        best_dist: int | None = None
-        for action in _TIE_BREAK_ORDER:
-            dx, dy = _DELTAS[action]
-            cand = (src[0] + dx, src[1] + dy)
-            if not self._is_free(game, cand):
-                # Off-grid or into a wall: illegal, skip (covers blocked "left").
-                continue
-            dist = self._bfs_distance(game, cand, pred_cell)
-            if dist is None:
-                continue
-            if best_dist is None or dist > best_dist:
-                best_dist = dist
-                best_action = action
-        return best_action
-
-    def habit_action(self, game: MotiveGridGame) -> str:
-        """Return the fixed-habit action: repeat the last committed move.
-
-        The focal walks west all through the Cut pre-roll, so at the handover the
-        habit is ``"left"`` (which the dead-end geometry makes the wrong move).
-        ``MotiveGridModule`` (CP5) is expected to call :meth:`record_focal_move`
-        after each committed action so the habit tracks the live trajectory; the
-        default reflects the pre-roll direction.
-
-        Args:
-            game: The live game (unused; the habit is carried as scenario state).
-
-        Returns:
-            The last committed move direction (``"left"`` at the Cut).
-        """
-        del game
-        return self._last_focal_move
-
-    def record_focal_move(self, action: str) -> None:
-        """Record the focal's last committed move so :meth:`habit_action` tracks it.
-
-        A non-moving ``"stay"`` does not change the established habit direction
-        (the habit is "the direction I keep heading"), so it is ignored.
-
-        Args:
-            action: The action just committed by the focal agent.
-        """
-        if action in _DELTAS and action != "stay":
-            self._last_focal_move = action
-
-    def step_reward(
-        self,
-        game: MotiveGridGame,
-        action: str,
-        blocked: bool,
-        focal_before: tuple[int, int],
-        predator_before: tuple[int, int],
-    ) -> float:
-        """Survival reward: positive for moving away from the predator.
-
-        Terminal states dominate (capture / survival). Otherwise a blocked move
-        is penalised, and a legal move is scored by the change in BFS distance
-        from the focal to the predator's PRE-move cell (post-move focal cell vs
-        pre-move focal cell), isolating the agent's own contribution from the
-        predator's chase. Positive = moved away, negative = moved toward.
-        """
-        del action  # reward derives from the post-move focal cell, not the action string
-        if game.eliminated:
-            return _REWARD_CAPTURED
-        if game.survived:
-            return _REWARD_SURVIVED
-        if blocked:
-            return _REWARD_WALL_HIT
-        focal = game.focal_sprite
-        if focal is None:
-            return 0.0
-        focal_after = (focal.x, focal.y)
-        d_before = self._bfs_distance(game, focal_before, predator_before)
-        d_after = self._bfs_distance(game, focal_after, predator_before)
-        if d_before is None or d_after is None:
-            return 0.0
-        return float(d_after - d_before)
-
-    def safety_distance(self, game: MotiveGridGame) -> int | None:
-        """Return the BFS distance from the focal to the predator (None if N/A)."""
-        focal = game.focal_sprite
-        predator = game.predator_sprite
-        if focal is None or predator is None:
-            return None
-        return self._bfs_distance(game, (focal.x, focal.y), (predator.x, predator.y))
-
-    def max_bfs_distance(self, game: MotiveGridGame) -> int | None:
-        """Free-cell graph diameter: the max finite BFS distance between any two
-        free cells. Used to normalise distance metrics / pressure into [0, 1]."""
-        cells = [
-            (x, y)
-            for x in range(self.grid_size[0])
-            for y in range(self.grid_size[1])
-            if self._is_free(game, (x, y))
-        ]
-        best = 0
-        for i, a in enumerate(cells):
-            for b in cells[i + 1:]:
-                d = self._bfs_distance(game, a, b)
-                if d is not None and d > best:
-                    best = d
-        return best
-
-    def agent_distance_delta(
-        self, game: MotiveGridGame, focal_before, predator_before
-    ) -> float | None:
-        """Chase-corrected action quality (spec §6.2): how much the focal's own
-        move opened distance from the *pre-move* predator cell."""
-        focal = game.focal_sprite
-        if focal is None:
-            return None
-        d_after = self._bfs_distance(game, (focal.x, focal.y), predator_before)
-        d_before = self._bfs_distance(game, focal_before, predator_before)
-        if d_after is None or d_before is None:
-            return None
-        return float(d_after - d_before)
-
-    # ------------------------------------------------------------------ #
-    # ASCII legend
-    # ------------------------------------------------------------------ #
-    def legend(self) -> dict[int, str]:
-        """Return the palette-index -> single-character symbol map.
-
-        Returns:
-            ``{5: '.', 1: 'A', 2: 'B', 3: '#'}`` — background, focal, predator,
-            wall (consistent with the pixels assigned in :meth:`build_level`).
-        """
-        return {
-            BACKGROUND_IDX: ".",
-            FOCAL_IDX: "A",
-            PREDATOR_IDX: "B",
-            WALL_IDX: "#",
-        }
-
-    # ------------------------------------------------------------------ #
-    # BFS / free-cell helpers
-    # ------------------------------------------------------------------ #
-    def _is_free(self, game: MotiveGridGame, cell: tuple[int, int]) -> bool:
-        """Return whether *cell* is on-grid and not a wall.
-
-        Args:
-            game: The live game (for the bounds check).
-            cell: The ``(x, y)`` cell to test.
-        """
-        return game.within_bounds(cell[0], cell[1]) and cell not in self._wall_cells
-
-    def _bfs_distance(
-        self,
-        game: MotiveGridGame,
-        src: tuple[int, int],
-        dst: tuple[int, int],
-    ) -> int | None:
-        """Return the shortest 4-neighbour path length over free cells.
-
-        Args:
-            game: The live game (for bounds checks).
-            src: Start cell ``(x, y)`` (assumed free).
-            dst: Goal cell ``(x, y)``.
-
-        Returns:
-            The number of steps from *src* to *dst* over free cells, or ``None``
-            if *dst* is unreachable (or either endpoint is a wall).
-        """
-        if not self._is_free(game, src) or not self._is_free(game, dst):
-            return None
-        if src == dst:
-            return 0
-        seen = {src}
-        queue: deque[tuple[tuple[int, int], int]] = deque([(src, 0)])
-        while queue:
-            cell, dist = queue.popleft()
-            for action in _TIE_BREAK_ORDER:
-                dx, dy = _DELTAS[action]
-                if dx == 0 and dy == 0:
-                    continue
-                nxt = (cell[0] + dx, cell[1] + dy)
-                if nxt in seen or not self._is_free(game, nxt):
-                    continue
-                if nxt == dst:
-                    return dist + 1
-                seen.add(nxt)
-                queue.append((nxt, dist + 1))
-        return None

proteus/game/scenarios/template.py

@@ -27,7 +27,7 @@ if TYPE_CHECKING:
 BACKGROUND_IDX = 5  # arc_grid Camera default background
 FOCAL_IDX = 1
 PREDATOR_IDX = 2
-WALL_IDX = 3        # matches predator_evade + COLOR_MAP gray
+WALL_IDX = 3        # COLOR_MAP gray
 FOOD_IDX = 14       # COLOR_MAP green; observational food cells
 
 _GRID = (64, 64)

proteus/game/viz/reconstruct.py

@@ -21,7 +21,6 @@ from dataclasses import dataclass
 
 import numpy as np
 
-from proteus.game.engine.ascii_view import frame_to_ascii
 from proteus.game.engine.difficulty import Difficulty
 from proteus.game.engine.grid import MotiveGridGame
 from proteus.game.scenarios.base import get_scenario
@@ -78,13 +77,11 @@ def reconstruct(trace: SessionTrace) -> list[FrameStep]:
     game = MotiveGridGame(
         scenario, rng, difficulty, max_steps=cut_length + len(trace.turns),
     )
-    legend = scenario.legend()
-
     steps: list[FrameStep] = []
 
     # --- Cut pre-roll (deterministic scripted policy). ---
     steps.append(FrameStep(game.current_grid(), FrameMeta(phase="cut", index=0)))
-    _verify_cut(game, legend, trace, 0)
+    _verify_cut(game, scenario, trace, 0)
     for i in range(cut_length):
         action = scenario.cut_focal_policy(game)
         game.apply_motive_action(action)
@@ -92,7 +89,7 @@ def reconstruct(trace: SessionTrace) -> list[FrameStep]:
         steps.append(
             FrameStep(game.current_grid(), FrameMeta(phase="cut", index=i + 1))
         )
-        _verify_cut(game, legend, trace, i + 1)
+        _verify_cut(game, scenario, trace, i + 1)
 
     # --- Played turns (recorded actions). ---
     last = trace.turns[-1] if trace.turns else None
@@ -128,7 +125,7 @@ def reconstruct(trace: SessionTrace) -> list[FrameStep]:
 
 
 def _verify_cut(
-    game: MotiveGridGame, legend: dict[int, str], trace: SessionTrace, idx: int
+    game: MotiveGridGame, scenario, trace: SessionTrace, idx: int
 ) -> None:
     if not trace.cut_frames:
         return  # legacy trace without cut-frame storage — nothing to verify against
@@ -138,7 +135,10 @@ def _verify_cut(
             f"{len(trace.cut_frames)} cut frames but reconstruction expected more "
             "(truncated or version-skewed trace)."
         )
-    got = frame_to_ascii(game.current_grid(), legend)
+    # The trace stores frames via the scenario's render_frame hook, so verify
+    # against the same hook (not a hardcoded frame_to_ascii — scenarios such as
+    # template render a compact prose frame, not the full ASCII map).
+    got = scenario.render_frame(game)
     if got != trace.cut_frames[idx]:
         raise TraceReconstructionError(
             f"Cut frame {idx} mismatch: reconstruction diverged from the trace "

tests/cli/test_cli.py

@@ -2,18 +2,18 @@ from proteus.cli import main
 from proteus.game.runtime import read_traces
 
 
-def test_list_scenarios_prints_predator_evade(capsys):
+def test_list_scenarios_prints_template(capsys):
     rc = main(["list-scenarios"])
     out = capsys.readouterr().out
     assert rc == 0
-    assert "predator_evade" in out
+    assert "template" in out
 
 
 def test_run_with_fake_provider_writes_reloadable_trace(tmp_path, capsys):
     out = tmp_path / "runs" / "smoke.jsonl"
     rc = main([
         "run",
-        "--scenario", "predator_evade",
+        "--scenario", "template",
         "--model", "fake:cli-test",
         "--seed", "42",
         "--play-turns", "5",
@@ -24,29 +24,29 @@ def test_run_with_fake_provider_writes_reloadable_trace(tmp_path, capsys):
     assert out.exists()
     traces = read_traces(out)
     assert len(traces) == 1
-    assert traces[0].scenario == "predator_evade"
+    assert traces[0].scenario == "template"
     assert traces[0].model == "cli-test"
     # The run line summarizes the outcome.
-    assert "predator_evade" in capsys.readouterr().out
+    assert "template" in capsys.readouterr().out
 
 
 def test_replay_prints_turns_and_outcome(tmp_path, capsys):
     out = tmp_path / "r.jsonl"
     main([
-        "run", "--scenario", "predator_evade", "--model", "fake:x",
+        "run", "--scenario", "template", "--model", "fake:x",
         "--seed", "42", "--play-turns", "5", "--no-probe", "--out", str(out),
     ])
     capsys.readouterr()  # drain
     rc = main(["replay", str(out)])
     text = capsys.readouterr().out
     assert rc == 0
-    assert "predator_evade" in text
+    assert "template" in text
     assert "turn 1" in text
 
 
 def test_run_unknown_provider_returns_nonzero(tmp_path, capsys):
     rc = main([
-        "run", "--scenario", "predator_evade", "--model", "bogus:x",
+        "run", "--scenario", "template", "--model", "bogus:x",
         "--seed", "1", "--out", str(tmp_path / "x.jsonl"),
     ])
     assert rc == 2
@@ -77,7 +77,7 @@ def test_play_human_writes_comparable_trace(tmp_path, monkeypatch, capsys):
     out = tmp_path / "runs" / "human.jsonl"
     rc = main([
         "play",
-        "--scenario", "predator_evade",
+        "--scenario", "template",
         "--seed", "42",
         "--play-turns", "5",
         "--out", str(out),
@@ -86,9 +86,9 @@ def test_play_human_writes_comparable_trace(tmp_path, monkeypatch, capsys):
     traces = read_traces(out)
     assert len(traces) == 1
     assert traces[0].model == "human"
-    assert traces[0].scenario == "predator_evade"
+    assert traces[0].scenario == "template"
     # The run summary names the scenario.
-    assert "predator_evade" in capsys.readouterr().out
+    assert "template" in capsys.readouterr().out
 
 
 def test_play_unknown_scenario_errors(capsys):
@@ -100,7 +100,7 @@ def test_play_unknown_scenario_errors(capsys):
 def _write_fake_trace(tmp_path):
     out = tmp_path / "r.jsonl"
     main([
-        "run", "--scenario", "predator_evade", "--model", "fake:x",
+        "run", "--scenario", "template", "--model", "fake:x",
         "--seed", "42", "--play-turns", "4", "--no-probe", "--out", str(out),
     ])
     return out
@@ -145,7 +145,7 @@ def test_play_handles_stdin_eof(monkeypatch, capsys):
 
     monkeypatch.setattr("builtins.input", _eof)
     rc = main([
-        "play", "--scenario", "predator_evade", "--seed", "42", "--play-turns", "5",
+        "play", "--scenario", "template", "--seed", "42", "--play-turns", "5",
     ])
     assert rc == 2
     assert "stdin" in capsys.readouterr().err.lower()
@@ -156,7 +156,7 @@ def test_compare_aggregates_traces(tmp_path, capsys):
     # Two fake-model traces at the same difficulty (model id "demo").
     for seed in (1, 2):
         main([
-            "run", "--scenario", "predator_evade", "--model", "fake:demo",
+            "run", "--scenario", "template", "--model", "fake:demo",
             "--seed", str(seed), "--play-turns", "4", "--no-probe", "--out", str(out),
         ])
     capsys.readouterr()  # drain
@@ -173,7 +173,7 @@ def test_compare_writes_summary_json(tmp_path):
 
     out = tmp_path / "runs.jsonl"
     main([
-        "run", "--scenario", "predator_evade", "--model", "fake:demo",
+        "run", "--scenario", "template", "--model", "fake:demo",
         "--seed", "1", "--play-turns", "4", "--no-probe", "--out", str(out),
     ])
     summary = tmp_path / "summary.json"

tests/cli/test_cli_gif.py

@@ -4,7 +4,7 @@ from proteus.cli import main
 def test_run_auto_writes_gif_next_to_out(tmp_path):
     out = tmp_path / "t.jsonl"
     rc = main([
-        "run", "--scenario", "predator_evade", "--model", "fake:demo",
+        "run", "--scenario", "template", "--model", "fake:demo",
         "--difficulty", "easy", "--seed", "42", "--play-turns", "3",
         "--no-probe", "--out", str(out),
     ])
@@ -15,7 +15,7 @@ def test_run_auto_writes_gif_next_to_out(tmp_path):
 def test_run_no_gif_suppresses(tmp_path):
     out = tmp_path / "t.jsonl"
     rc = main([
-        "run", "--scenario", "predator_evade", "--model", "fake:demo",
+        "run", "--scenario", "template", "--model", "fake:demo",
         "--difficulty", "easy", "--seed", "42", "--play-turns", "3",
         "--no-probe", "--no-gif", "--out", str(out),
     ])

tests/cli/test_cli_memory.py

@@ -5,20 +5,20 @@ from proteus.game.runtime.memory import load_checkpoint
 def test_memory_subcommand_writes_loadable_checkpoint(tmp_path):
     out = tmp_path / "ck.json"
     rc = main([
-        "memory", "--scenario", "predator_evade", "--model", "fake:demo",
+        "memory", "--scenario", "template", "--model", "fake:demo",
         "--difficulty", "easy", "--seed", "42", "--memory-turns", "4",
         "--out", str(out),
     ])
     assert rc == 0
     ck = load_checkpoint(out)
     assert ck.model == "demo"
-    assert ck.scenario == "predator_evade"
+    assert ck.scenario == "template"
     assert 1 <= len(ck.memory_turns) <= 4
 
 
 def test_memory_subcommand_unknown_model_exits_2(tmp_path, capsys):
     rc = main([
-        "memory", "--scenario", "predator_evade", "--model", "bogusprovider:x",
+        "memory", "--scenario", "template", "--model", "bogusprovider:x",
         "--difficulty", "easy", "--seed", "42", "--out", str(tmp_path / "c.json"),
     ])
     assert rc == 2
@@ -31,7 +31,7 @@ from proteus.game.runtime import read_traces
 def test_run_memory_generate_sets_memory_ref(tmp_path):
     out = tmp_path / "t.jsonl"
     rc = main([
-        "run", "--scenario", "predator_evade", "--model", "fake:demo",
+        "run", "--scenario", "template", "--model", "fake:demo",
         "--difficulty", "easy", "--seed", "42", "--play-turns", "3",
         "--no-probe", "--memory", "generate", "--memory-turns", "4",
         "--memory-root", str(tmp_path / "mem"), "--out", str(out),
@@ -46,7 +46,7 @@ def test_run_memory_generate_sets_memory_ref(tmp_path):
 def test_run_memory_latest_missing_exits_2(tmp_path, capsys):
     out = tmp_path / "t.jsonl"
     rc = main([
-        "run", "--scenario", "predator_evade", "--model", "fake:demo",
+        "run", "--scenario", "template", "--model", "fake:demo",
         "--difficulty", "easy", "--seed", "42", "--play-turns", "3",
         "--no-probe", "--memory", "latest",
         "--memory-root", str(tmp_path / "mem"), "--out", str(out),
@@ -58,7 +58,7 @@ def test_run_memory_latest_missing_exits_2(tmp_path, capsys):
 def test_run_memory_none_is_default(tmp_path):
     out = tmp_path / "t.jsonl"
     rc = main([
-        "run", "--scenario", "predator_evade", "--model", "fake:demo",
+        "run", "--scenario", "template", "--model", "fake:demo",
         "--difficulty", "easy", "--seed", "42", "--play-turns", "3",
         "--no-probe", "--out", str(out),
     ])

tests/cli/test_cli_persona.py

@@ -5,7 +5,7 @@ from proteus.game.runtime import read_traces
 def test_run_with_persona_records_id_and_metrics(tmp_path):
     out = tmp_path / "p.jsonl"
     rc = main([
-        "run", "--scenario", "predator_evade", "--model", "fake:demo",
+        "run", "--scenario", "template", "--model", "fake:demo",
         "--difficulty", "easy", "--seed", "42", "--play-turns", "3",
         "--no-probe", "--no-gif", "--persona", "risk_averse", "--out", str(out),
     ])
@@ -20,7 +20,7 @@ def test_run_with_persona_records_id_and_metrics(tmp_path):
 def test_run_without_persona_has_no_persona_metrics(tmp_path):
     out = tmp_path / "np.jsonl"
     rc = main([
-        "run", "--scenario", "predator_evade", "--model", "fake:demo",
+        "run", "--scenario", "template", "--model", "fake:demo",
         "--difficulty", "easy", "--seed", "42", "--play-turns", "3",
         "--no-probe", "--no-gif", "--out", str(out),
     ])
@@ -33,7 +33,7 @@ def test_run_without_persona_has_no_persona_metrics(tmp_path):
 def test_run_unknown_persona_errors(tmp_path):
     out = tmp_path / "bad.jsonl"
     rc = main([
-        "run", "--scenario", "predator_evade", "--model", "fake:demo",
+        "run", "--scenario", "template", "--model", "fake:demo",
         "--difficulty", "easy", "--seed", "42", "--play-turns", "3",
         "--no-probe", "--no-gif", "--persona", "nope", "--out", str(out),
     ])
@@ -44,7 +44,7 @@ def test_memory_with_persona_tags_checkpoint(tmp_path):
     from proteus.game.runtime.memory import load_checkpoint
     out = tmp_path / "mem.json"
     rc = main([
-        "memory", "--scenario", "predator_evade", "--model", "fake:demo",
+        "memory", "--scenario", "template", "--model", "fake:demo",
         "--difficulty", "easy", "--seed", "42", "--memory-turns", "5",
         "--persona", "risk_averse", "--out", str(out),
     ])
@@ -57,7 +57,7 @@ def test_memory_with_persona_tags_checkpoint(tmp_path):
 def test_memory_unknown_persona_errors(tmp_path):
     out = tmp_path / "bad.json"
     rc = main([
-        "memory", "--scenario", "predator_evade", "--model", "fake:demo",
+        "memory", "--scenario", "template", "--model", "fake:demo",
         "--difficulty", "easy", "--seed", "42", "--memory-turns", "5",
         "--persona", "nope", "--out", str(out),
     ])
@@ -69,7 +69,7 @@ def test_persona_memory_then_scored_run(tmp_path):
     # measures whether the model continues that persona (same hidden weights).
     mem = tmp_path / "demo.json"
     rc = main([
-        "memory", "--scenario", "predator_evade", "--model", "fake:demo",
+        "memory", "--scenario", "template", "--model", "fake:demo",
         "--difficulty", "easy", "--seed", "42", "--memory-turns", "5",
         "--persona", "risk_averse", "--out", str(mem),
     ])
@@ -77,7 +77,7 @@ def test_persona_memory_then_scored_run(tmp_path):
 
     out = tmp_path / "scored.jsonl"
     rc = main([
-        "run", "--scenario", "predator_evade", "--model", "fake:demo",
+        "run", "--scenario", "template", "--model", "fake:demo",
         "--difficulty", "easy", "--seed", "42", "--play-turns", "3",
         "--no-probe", "--no-gif", "--memory", str(mem),
         "--persona", "risk_averse", "--out", str(out),

tests/engine/test_turn_order.py

@@ -9,7 +9,7 @@ import proteus.game.scenarios  # noqa: F401  (register scenarios)
 
 
 def _focal_cell_seen_by_threat(turn_order: str, action: str = "up"):
-    scen = get_scenario("predator_evade")()
+    scen = get_scenario("template")()
     scen.turn_order = turn_order  # instance override
     game = MotiveGridGame(scen, random.Random(0), Difficulty.EASY, max_steps=10)
     seen = {}

tests/grid/test_difficulty_layouts.py

@@ -1,96 +0,0 @@
-import random
-
-import numpy as np
-
-from proteus.game.engine.difficulty import Difficulty
-from proteus.game.engine.grid import MotiveGridGame
-from proteus.game.scenarios.base import Scenario, get_scenario
-
-
-def _scenario():
-    return get_scenario("predator_evade")()
-
-
-def test_build_level_accepts_difficulty():
-    s = _scenario()
-    level = s.build_level(random.Random(42), Difficulty.EASY)
-    names = {sp.name for sp in level.get_sprites()}
-    assert "focal" in names and "predator" in names
-
-
-def test_record_focal_move_default_is_noop_on_base():
-    # hasattr proves the no-op default is now inherited from the Scenario ABC
-    # (so non-tracking scenarios never AttributeError). PredatorEvade overrides
-    # it to track the live trajectory, which habit_action reads back.
-    assert hasattr(Scenario, "record_focal_move")
-    # PredatorEvade still tracks it (used by habit_action).
-    s = _scenario()
-    s.record_focal_move("up")
-    assert s.habit_action(None) == "up"
-
-
-_BANDS = [Difficulty.EASY, Difficulty.MEDIUM, Difficulty.HARD, Difficulty.EXPERT]
-
-
-def _game(difficulty, seed=42):
-    s = _scenario()
-    return MotiveGridGame(s, random.Random(seed), difficulty, max_steps=20), s
-
-
-def test_easy_layout_unchanged():
-    # EASY remains the 8x8 single-wall world: focal (5,3), predator (7,3).
-    game, _ = _game(Difficulty.EASY)
-    assert game.current_grid().shape == (8, 8)
-    assert (game.focal_sprite.x, game.focal_sprite.y) == (5, 3)
-    assert (game.predator_sprite.x, game.predator_sprite.y) == (7, 3)
-
-
-def test_bands_have_distinct_grid_sizes_or_starts():
-    seen = set()
-    for d in _BANDS:
-        game, _ = _game(d)
-        h, w = game.current_grid().shape
-        fx, fy = game.focal_sprite.x, game.focal_sprite.y
-        px, py = game.predator_sprite.x, game.predator_sprite.y
-        seen.add((h, w, fx, fy, px, py))
-    # All four bands must be pairwise distinct: each band's (size, focal, predator) tuple unique.
-    assert len(seen) == 4
-
-
-def test_each_band_is_deterministic():
-    for d in _BANDS:
-        g1, _ = _game(d, seed=7)
-        g2, _ = _game(d, seed=7)
-        assert np.array_equal(g1.current_grid(), g2.current_grid())
-
-
-def _drive_to_handover(difficulty, seed=42):
-    """Replay the Cut pre-roll (scripted 'left') to the handover state."""
-    s = _scenario()
-    game = MotiveGridGame(s, random.Random(seed), difficulty, max_steps=40)
-    for _ in range(s.cut_length(difficulty)):
-        action = s.cut_focal_policy(game)
-        game.apply_motive_action(action)
-        s.record_focal_move(action)
-    return game, s
-
-
-def test_invariant_optimal_differs_from_habit_each_band():
-    # The whole discrimination metric depends on optimal != habit at the Cut
-    # handover, for EVERY difficulty band.
-    for d in _BANDS:
-        game, s = _drive_to_handover(d)
-        optimal = s.optimal_action(game)
-        habit = s.habit_action(game)
-        assert optimal != habit, f"{d}: optimal {optimal} == habit {habit}"
-        # Habit ('left', the pre-roll direction) must be trapped: moving left
-        # is blocked (a wall) so it does not increase distance.
-        assert habit == "left"
-
-
-def test_handover_is_deterministic_each_band():
-    for d in _BANDS:
-        g1, s1 = _drive_to_handover(d, seed=11)
-        g2, s2 = _drive_to_handover(d, seed=11)
-        assert (g1.focal_sprite.x, g1.focal_sprite.y) == (g2.focal_sprite.x, g2.focal_sprite.y)
-        assert (g1.predator_sprite.x, g1.predator_sprite.y) == (g2.predator_sprite.x, g2.predator_sprite.y)

tests/grid/test_distance_helpers.py

@@ -6,7 +6,7 @@ from proteus.game.scenarios.base import Scenario, get_scenario
 
 
 def _game():
-    s = get_scenario("predator_evade")()
+    s = get_scenario("template")()
     g = MotiveGridGame(s, random.Random(42), Difficulty.EASY, max_steps=10)
     return s, g
 
@@ -24,11 +24,11 @@ def test_max_bfs_distance_positive_on_easy():
 
 def test_agent_distance_delta_positive_when_moving_away():
     s, g = _game()
-    focal = g.focal_sprite           # EASY: (5,3)
-    pred = g.predator_sprite         # EASY: (7,3)
+    focal = g.focal_sprite           # template spawns west of the predator
+    pred = g.predator_sprite
     before_focal = (focal.x, focal.y)
     before_pred = (pred.x, pred.y)
-    # move focal up to (5,2) -> farther from (7,3)
+    # move focal up -> opens distance from the (far-east) predator
     g.apply_motive_action("up")
     delta = s.agent_distance_delta(g, before_focal, before_pred)
     assert delta is not None and delta > 0

tests/grid/test_footprint_bounds.py

@@ -1,5 +1,4 @@
-"""The multi-cell focal must keep its full footprint on the grid; a 1x1 sprite
-(predator_evade) behaves exactly as before (regression guard)."""
+"""The multi-cell focal must keep its full footprint on the grid."""
 from __future__ import annotations
 
 import random
@@ -22,13 +21,3 @@ def test_3x3_focal_cannot_leave_grid():
     # A legal move still works.
     game.apply_motive_action("right")
     assert game.focal_sprite.x == 1
-
-
-def test_1x1_focal_regression():
-    scenario = get_scenario("predator_evade")()
-    game = MotiveGridGame(scenario, random.Random(42), Difficulty.EASY, max_steps=99)
-    focal = game.focal_sprite
-    x0 = focal.x
-    game.apply_motive_action("up")  # legal in the 8x8 layout
-    assert game.focal_sprite.y == focal.y  # moved or not, no crash; 1x1 path unchanged
-    assert isinstance(x0, int)

tests/grid/test_predator_evade_behavior.py

@@ -1,46 +0,0 @@
-import random
-
-from proteus.game.engine.difficulty import Difficulty
-from proteus.game.engine.grid import MotiveGridGame
-from proteus.game.scenarios.base import get_scenario
-
-
-def _build_at_handover():
-    """Build predator_evade and replay the EASY Cut pre-roll to the handover."""
-    scenario = get_scenario("predator_evade")()
-    rng = random.Random(42)
-    cut = scenario.cut_length(Difficulty.EASY)
-    game = MotiveGridGame(scenario, rng, Difficulty.EASY, max_steps=cut + 15)
-    for _ in range(cut):
-        action = scenario.cut_focal_policy(game)
-        game.apply_motive_action(action)
-        scenario.record_focal_move(action)
-    return scenario, game, cut
-
-
-def test_cut_handover_positions_are_deterministic():
-    _, game, _ = _build_at_handover()
-    # EASY layout: focal walks west from (5,3) for 2 steps -> (3,3);
-    # predator chases from (7,3) -> (5,3).
-    assert (game.focal_sprite.x, game.focal_sprite.y) == (3, 3)
-    assert (game.predator_sprite.x, game.predator_sprite.y) == (5, 3)
-
-
-def test_diagnostic_invariant_optimal_differs_from_habit_at_handover():
-    scenario, game, cut = _build_at_handover()
-    # Pin the pre-roll length: habit_action reads _last_focal_move, which
-    # defaults to "left" in __init__, so habit=="left" could pass vacuously
-    # if the Cut never ran. Asserting cut makes "the pre-roll ran" explicit.
-    assert cut == 2, "EASY pre-roll length changed — re-verify layout"
-    optimal = scenario.optimal_action(game)
-    habit = scenario.habit_action(game)
-    assert habit == "left"          # the inertia: keep walking west into the dead-end
-    assert optimal == "up"          # escape that maximizes BFS distance
-    assert optimal != habit         # THE measured divergence
-
-
-def test_full_replay_is_reproducible_across_two_builds():
-    _, g1, _ = _build_at_handover()
-    _, g2, _ = _build_at_handover()
-    assert (g1.focal_sprite.x, g1.focal_sprite.y) == (g2.focal_sprite.x, g2.focal_sprite.y)
-    assert (g1.predator_sprite.x, g1.predator_sprite.y) == (g2.predator_sprite.x, g2.predator_sprite.y)

tests/grid/test_predator_evade_registered.py

@@ -1,8 +0,0 @@
-def test_importing_proteus_grid_registers_predator_evade():
-    import proteus.game.scenarios  # noqa: F401  (side-effect: registers scenarios)
-    from proteus.game.scenarios.base import get_scenario, list_scenarios
-    assert "predator_evade" in list_scenarios()
-    cls = get_scenario("predator_evade")
-    inst = cls()
-    assert inst.task_name == "predator_evade"
-    assert inst.grid_size == (8, 8)

tests/grid/test_step_reward.py

@@ -5,29 +5,26 @@ from proteus.game.engine.grid import MotiveGridGame
 from proteus.game.scenarios.base import get_scenario
 
 
-def _handover():
-    s = get_scenario("predator_evade")()
+def _start():
+    s = get_scenario("template")()
     game = MotiveGridGame(s, random.Random(42), Difficulty.EASY, max_steps=20)
-    for _ in range(s.cut_length(Difficulty.EASY)):
-        a = s.cut_focal_policy(game)
-        game.apply_motive_action(a)
-        s.record_focal_move(a)
     return game, s
 
 
 def test_step_reward_positive_when_moving_away():
-    game, s = _handover()
+    game, s = _start()
     focal_before = (game.focal_sprite.x, game.focal_sprite.y)
     predator_before = (game.predator_sprite.x, game.predator_sprite.y)
-    # 'up' is the optimal escape at the EASY handover -> moves away.
-    game.apply_motive_action("up")
-    r = s.step_reward(game, "up", blocked=False,
+    # The focal spawns west of the predator; moving further from it earns reward.
+    away = s.optimal_action(game)
+    game.apply_motive_action(away)
+    r = s.step_reward(game, away, blocked=False,
                       focal_before=focal_before, predator_before=predator_before)
     assert r > 0
 
 
 def test_step_reward_negative_when_moving_toward():
-    game, s = _handover()
+    game, s = _start()
     focal_before = (game.focal_sprite.x, game.focal_sprite.y)
     predator_before = (game.predator_sprite.x, game.predator_sprite.y)
     # 'right' moves toward the predator (east).
@@ -37,21 +34,7 @@ def test_step_reward_negative_when_moving_toward():
     assert r < 0
 
 
-def test_step_reward_negative_on_wall_hit():
-    game, s = _handover()
-    focal_before = (game.focal_sprite.x, game.focal_sprite.y)
-    predator_before = (game.predator_sprite.x, game.predator_sprite.y)
-    # 'left' is blocked by the dead-end wall at the EASY handover.
-    game.apply_motive_action("left")
-    # The dead-end wall makes 'left' a no-op; confirm the engine blocked it
-    # so blocked=True faithfully reflects what _apply would have computed.
-    assert (game.focal_sprite.x, game.focal_sprite.y) == focal_before
-    r = s.step_reward(game, "left", blocked=True,
-                      focal_before=focal_before, predator_before=predator_before)
-    assert r < 0
-
-
-def test_safety_distance_is_bfs_focal_to_predator():
-    game, s = _handover()
+def test_safety_distance_is_distance_focal_to_predator():
+    game, s = _start()
     d = s.safety_distance(game)
     assert isinstance(d, int) and d >= 0

tests/grid/test_template_observation.py

@@ -1,22 +1,14 @@
-"""template emits a compact coordinate frame; predator_evade keeps its exact
-ASCII frame (so its existing observation/cut-frame tests stay green)."""
+"""template emits a compact coordinate frame (not a full ASCII map)."""
 from __future__ import annotations
 
 import random
 
 import proteus.game.scenarios  # noqa: F401
-from proteus.game.engine.ascii_view import frame_to_ascii
 from proteus.game.engine.difficulty import Difficulty
 from proteus.game.engine.grid import MotiveGridGame
 from proteus.game.scenarios.base import get_scenario
 
 
-def test_predator_evade_render_frame_is_unchanged_ascii():
-    scenario = get_scenario("predator_evade")()
-    game = MotiveGridGame(scenario, random.Random(42), Difficulty.EASY, max_steps=10)
-    assert scenario.render_frame(game) == frame_to_ascii(game.current_grid(), scenario.legend())
-
-
 def test_template_render_frame_is_compact():
     scenario = get_scenario("template")()
     game = MotiveGridGame(scenario, random.Random(42), Difficulty.EASY, max_steps=10)

tests/runtime/test_aggregate.py

@@ -7,7 +7,7 @@ from proteus.game.runtime.session import SessionRunner
 def _trace(seed):
     agent = VanillaAgent(FakeProvider(["ACTION: up"]))
     return SessionRunner(
-        "predator_evade", agent, seed=seed, play_turns=4, use_probe=False,
+        "template", agent, seed=seed, play_turns=4, use_probe=False,
     ).run()
 
 

tests/runtime/test_human_comparability.py

@@ -14,12 +14,12 @@ def test_human_and_llm_traces_share_schema_and_answer_keys():
     # differs. This is the human-baseline comparability foundation (spec §10).
     human = HumanAgent(input_fn=_scripted(["up"] * 20), output_fn=lambda s: None)
     h = SessionRunner(
-        "predator_evade", human, seed=42, play_turns=5, use_probe=False,
+        "template", human, seed=42, play_turns=5, use_probe=False,
     ).run()
 
     llm = VanillaAgent(FakeProvider(["ACTION: up"]))
     v = SessionRunner(
-        "predator_evade", llm, seed=42, play_turns=5, use_probe=False,
+        "template", llm, seed=42, play_turns=5, use_probe=False,
     ).run()
 
     assert h.cut_frames == v.cut_frames

tests/runtime/test_integration_golden.py

@@ -4,11 +4,16 @@ from proteus.game.runtime import SessionRunner, SessionTrace
 from proteus.providers import FakeProvider
 from proteus.game.agents import VanillaAgent
 
+# Self-captured deterministic snapshot for template (seed=42, EASY, 8 turns,
+# the agent always answers "up"). template has no ToM divergence, so the model's
+# "up" matches the optimal escape and motive-reading accuracy is perfect.
+EXPECTED_MRA = 100.0
+
 
 def test_full_session_serializes_to_jsonl_and_reloads():
     agent = VanillaAgent(FakeProvider(responses=["ACTION: up"], model_name="fake-1"))
     trace = SessionRunner(
-        "predator_evade", agent, seed=42, play_turns=8, use_probe=True,
+        "template", agent, seed=42, play_turns=8, use_probe=True,
     ).run()
 
     # Serialize the whole session as one JSON line, reload, and verify.
@@ -17,10 +22,11 @@ def test_full_session_serializes_to_jsonl_and_reloads():
     # Full round-trip fidelity: every field survives serialization unchanged.
     assert reloaded.model_dump() == trace.model_dump()
     assert reloaded.model == "fake-1"
-    # seed=42 EASY handover: optimal is "up", habit is "left" (diagnostic turn).
+    # Deterministic self-captured snapshot (regression guard): the agent always
+    # answers "up", so the first committed action is "up".
     assert reloaded.turns[0].motive_action == "up"
     # Concrete metric anchor (regression guard, not a vacuous >= 0 check).
-    assert reloaded.metrics["motive_reading_accuracy"] == 60.0
+    assert reloaded.metrics["motive_reading_accuracy"] == EXPECTED_MRA
 
     # Per-turn JSONL is also valid line-by-line.
     for t in trace.turns:

tests/runtime/test_interactive_equivalence.py

@@ -26,14 +26,14 @@ def _scripted_human():
 
 def test_interactive_matches_session_runner():
     runner = SessionRunner(
-        "predator_evade", _scripted_human(),
+        "template", _scripted_human(),
         difficulty=Difficulty.EASY, seed=42,
         play_turns=len(ACTIONS), use_probe=False,
     )
     cli_trace = runner.run()
 
     sess = InteractiveSession(
-        "predator_evade", difficulty=Difficulty.EASY, seed=42,
+        "template", difficulty=Difficulty.EASY, seed=42,
         play_turns=len(ACTIONS), use_probe=False,
     )
     for a in ACTIONS:

tests/runtime/test_interactive_session.py

@@ -11,7 +11,7 @@ from proteus.game.runtime.interactive import InteractiveSession
 
 def _new(play_turns=10):
     return InteractiveSession(
-        "predator_evade", difficulty=Difficulty.EASY, seed=42,
+        "template", difficulty=Difficulty.EASY, seed=42,
         play_turns=play_turns, use_probe=False,
     )
 
@@ -60,7 +60,7 @@ def test_play_to_budget_then_review_and_finish():
     assert "metrics" in st["review"] and "turns" in st["review"]
     trace = s.finish()
     assert trace.model == "human"
-    assert trace.scenario == "predator_evade"
+    assert trace.scenario == "template"
     # finish() is memoized: repeated calls return the same trace object.
     assert s.finish() is trace
 

tests/runtime/test_io.py

@@ -6,7 +6,7 @@ from proteus.game.runtime import SessionRunner, append_trace, read_traces
 def _trace(seed):
     agent = VanillaAgent(FakeProvider(responses=["ACTION: up"], model_name="fake-1"))
     return SessionRunner(
-        "predator_evade", agent, seed=seed, play_turns=4, use_probe=False,
+        "template", agent, seed=seed, play_turns=4, use_probe=False,
     ).run()
 
 
@@ -16,7 +16,7 @@ def test_append_then_read_roundtrips_one_trace(tmp_path):
     assert written.exists()
     traces = read_traces(path)
     assert len(traces) == 1
-    assert traces[0].scenario == "predator_evade"
+    assert traces[0].scenario == "template"
     assert traces[0].model == "fake-1"
 
 

tests/runtime/test_memory.py

@@ -4,7 +4,7 @@ from proteus.game.runtime.memory import MemoryCheckpoint, MemoryTurn
 def _checkpoint() -> MemoryCheckpoint:
     return MemoryCheckpoint(
         model="demo",
-        scenario="predator_evade",
+        scenario="template",
         difficulty="easy",
         seed=42,
         created_at="2026-06-02T10-40-56Z",

tests/runtime/test_memory_gen.py

@@ -1,4 +1,4 @@
-import proteus.game.scenarios  # noqa: F401  (registers predator_evade)
+import proteus.game.scenarios  # noqa: F401  (registers scenarios)
 from proteus.game.scenarios.base import Scenario, get_scenario
 
 
@@ -6,15 +6,6 @@ def test_scenario_base_memory_brief_default_empty():
     assert Scenario.memory_brief == ""
 
 
-def test_predator_evade_memory_brief_is_transparent():
-    scenario = get_scenario("predator_evade")()
-    brief = scenario.memory_brief
-    assert brief  # non-empty
-    low = brief.lower()
-    assert "predator" in low
-    assert "shortest" in low or "bfs" in low  # discloses the chase rule
-
-
 from proteus.game.agents import VanillaAgent
 from proteus.game.engine.difficulty import Difficulty
 from proteus.providers import FakeProvider
@@ -28,12 +19,12 @@ def test_generate_memory_is_deterministic_and_records_episode():
     from proteus.game.runtime.memory_gen import generate_memory
 
     ck = generate_memory(
-        "predator_evade", _agent(), difficulty=Difficulty.EASY, seed=42,
+        "template", _agent(), difficulty=Difficulty.EASY, seed=42,
         memory_turns=5, model_name="demo", clock=lambda: "FIXED",
     )
     assert ck.created_at == "FIXED"
     assert ck.model == "demo"
-    assert ck.scenario == "predator_evade"
+    assert ck.scenario == "template"
     assert ck.difficulty == "easy"
     assert 1 <= len(ck.memory_turns) <= 5
     assert ck.memory_turns[0].action == "down"
@@ -41,7 +32,7 @@ def test_generate_memory_is_deterministic_and_records_episode():
     assert ck.outcome in ("survived", "eliminated")
 
     ck2 = generate_memory(
-        "predator_evade", _agent(), difficulty=Difficulty.EASY, seed=42,
+        "template", _agent(), difficulty=Difficulty.EASY, seed=42,
         memory_turns=5, model_name="demo", clock=lambda: "FIXED",
     )
     assert ck.model_dump() == ck2.model_dump()
@@ -52,7 +43,7 @@ def test_generate_memory_uses_memory_brief_as_prompt():
 
     agent = _agent()
     generate_memory(
-        "predator_evade", agent, difficulty=Difficulty.EASY, seed=42,
+        "template", agent, difficulty=Difficulty.EASY, seed=42,
         memory_turns=2, model_name="demo", clock=lambda: "FIXED",
     )
     # The provider saw the transparent brief as the system message.

tests/runtime/test_memory_persona.py

@@ -6,12 +6,12 @@ from proteus.game.metrics.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,
+        "template", 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")
+    # risk-averse demo never moves toward the (far-east) predator on the first turn
+    assert ck.memory_turns[0].action in ("up", "down", "left", "stay")
     # weights are NOT in the participant-visible checkpoint text
     assert "risk_cost" not in ck.model_dump_json()

tests/runtime/test_persona.py

@@ -7,13 +7,10 @@ from proteus.game.metrics.persona import PersonaWeights, reference_actions, pres
 
 
 def _sg():
-    s = get_scenario("predator_evade")()
+    s = get_scenario("template")()
     g = MotiveGridGame(s, random.Random(42), Difficulty.EASY, max_steps=10)
-    # Reproduce the EASY handover: the focal walks west through the 2-turn Cut
-    # into the dead-end, so `left` becomes a wall (matching the real session
-    # state the persona reference is scored against).
-    g.apply_motive_action("left")
-    g.apply_motive_action("left")
+    # template spawns the focal far west of the predator; the risk-averse
+    # reference prefers moves that keep/open distance from the (far-east) threat.
     return s, g
 
 
@@ -21,8 +18,8 @@ def test_risk_averse_reference_increases_distance():
     s, g = _sg()
     w = PersonaWeights(persona_weight_id="risk_averse", risk_cost=5.0)
     acts = reference_actions(w, s, g)
-    # EASY handover analog: moving away (up/down) is preferred over into-wall left
-    assert "left" not in acts
+    # Moving toward the predator (east, 'right') is never a risk-averse reference.
+    assert "right" not in acts
     assert acts  # non-empty
 
 
@@ -39,7 +36,7 @@ def _runner(action, persona_id="risk_averse", play_turns=1):
     from proteus.game.metrics.persona import get_persona
     prov = FakeProvider([f"ACTION: {action}"] * 10, model_name="demo")
     return SessionRunner(
-        "predator_evade", VanillaAgent(prov), difficulty=Difficulty.EASY,
+        "template", VanillaAgent(prov), difficulty=Difficulty.EASY,
         seed=42, play_turns=play_turns, use_probe=False,
         persona=get_persona(persona_id),
     ).run()
@@ -55,15 +52,15 @@ def test_persona_run_records_id_and_fields():
 
 
 def test_reference_action_yields_full_agreement_zero_regret():
-    # 'up' is a reference action at the EASY handover -> perfect maintenance.
+    # 'up' opens distance from the far-east predator -> a reference action.
     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
+def test_toward_predator_lowers_agreement_and_positive_regret():
+    # 'right' heads east toward the predator: not a reference action, worse reward.
+    m = _runner("right").metrics
     assert m["action_agreement"] == 0.0
     assert m["reward_regret"] > 0.0
 
@@ -74,7 +71,7 @@ def test_persona_metrics_absent_without_persona():
     from proteus.game.runtime import SessionRunner
     prov = FakeProvider(["ACTION: up"] * 10, model_name="demo")
     m = SessionRunner(
-        "predator_evade", VanillaAgent(prov), difficulty=Difficulty.EASY,
+        "template", VanillaAgent(prov), difficulty=Difficulty.EASY,
         seed=42, play_turns=2, use_probe=False,
     ).run().metrics
     assert "action_agreement" not in m

tests/runtime/test_rollout.py

@@ -3,21 +3,30 @@ from proteus.game.metrics.rollout import RolloutResult, optimal_rollout
 
 
 def test_optimal_rollout_is_deterministic():
-    a = optimal_rollout("predator_evade", seed=42, difficulty=Difficulty.EASY, n_turns=5)
-    b = optimal_rollout("predator_evade", seed=42, difficulty=Difficulty.EASY, n_turns=5)
+    a = optimal_rollout("template", seed=42, difficulty=Difficulty.EASY, n_turns=5)
+    b = optimal_rollout("template", seed=42, difficulty=Difficulty.EASY, n_turns=5)
     assert isinstance(a, RolloutResult)
     assert a.focal_positions == b.focal_positions
     assert a.final_safety_distance == b.final_safety_distance
 
 
 def test_optimal_rollout_length_capped_by_n_turns():
-    r = optimal_rollout("predator_evade", seed=42, difficulty=Difficulty.EASY, n_turns=3)
+    r = optimal_rollout("template", seed=42, difficulty=Difficulty.EASY, n_turns=3)
     assert len(r.focal_positions) <= 3
     # Each recorded position is the PRE-move focal cell for that optimal turn.
     assert all(isinstance(p, tuple) and len(p) == 2 for p in r.focal_positions)
 
 
 def test_optimal_rollout_first_position_is_handover():
-    # The first optimal pre-move position equals the focal's handover cell.
-    r = optimal_rollout("predator_evade", seed=42, difficulty=Difficulty.EASY, n_turns=5)
-    assert r.focal_positions[0] == (3, 3)  # EASY handover
+    # The first optimal pre-move position equals the focal's spawn cell (template
+    # has no Cut pre-roll, so the handover IS the spawn). Self-derived, not hardcoded.
+    import random
+    from proteus.game.engine.grid import MotiveGridGame
+    from proteus.game.scenarios.base import get_scenario
+
+    scenario = get_scenario("template")()
+    game = MotiveGridGame(scenario, random.Random(42), Difficulty.EASY, max_steps=10)
+    spawn = (game.focal_sprite.x, game.focal_sprite.y)
+
+    r = optimal_rollout("template", seed=42, difficulty=Difficulty.EASY, n_turns=5)
+    assert r.focal_positions[0] == spawn

tests/runtime/test_session.py

@@ -9,46 +9,29 @@ def _agent(responses):
 
 
 def test_optimal_player_survives_and_scores_full_motive_reading():
-    # At the EASY handover the motive-congruent action is "up". An agent that
-    # always plays "up"... will move up the open column away from the predator.
-    # Whatever the realized states, the runner scores each turn against the
-    # live optimal answer key. Here we script an agent that always says "up".
+    # At the start the motive-congruent escape is "up" (open column away from
+    # the far-east predator). An agent that always plays "up" stays congruent;
+    # the runner scores each turn against the live optimal answer key.
     agent = _agent(["ACTION: up"])  # FakeProvider repeats the last response
     runner = SessionRunner(
-        "predator_evade", agent, seed=42, play_turns=10, use_probe=False,
+        "template", agent, seed=42, play_turns=10, use_probe=False,
     )
     trace = runner.run()
     assert isinstance(trace, SessionTrace)
-    assert trace.scenario == "predator_evade"
+    assert trace.scenario == "template"
     assert trace.cut_frames  # Cut history captured
     assert len(trace.turns) >= 1
-    # First played turn: the handover, where motive=up, habit=left (diagnostic).
     first = trace.turns[0]
-    assert first.is_diagnostic is True
     assert first.motive_action == "up"
-    assert first.habit_action == "left"
     assert first.action == "up"
     assert first.was_congruent is True
     assert "motive_reading_accuracy" in trace.metrics
 
 
-def test_habit_player_diverges_on_first_diagnostic_turn():
-    # An agent that always plays "left" follows inertia into the dead-end.
-    agent = _agent(["ACTION: left"])
-    runner = SessionRunner(
-        "predator_evade", agent, seed=42, play_turns=10, use_probe=False,
-    )
-    trace = runner.run()
-    first = trace.turns[0]
-    assert first.action == "left"
-    assert first.was_congruent is False
-    assert trace.metrics["first_divergence_turn"] == 1.0
-
-
 def test_probe_recorded_when_enabled():
     agent = _agent(["the predator is to my east; I should go up\nACTION: up"])
     runner = SessionRunner(
-        "predator_evade", agent, seed=42, play_turns=3, use_probe=True,
+        "template", agent, seed=42, play_turns=3, use_probe=True,
     )
     trace = runner.run()
     assert trace.turns[0].probe_q  # a question was asked
@@ -56,9 +39,9 @@ def test_probe_recorded_when_enabled():
 
 
 def test_session_is_deterministic_for_same_inputs():
-    t1 = SessionRunner("predator_evade", _agent(["ACTION: up"]), seed=42,
+    t1 = SessionRunner("template", _agent(["ACTION: up"]), seed=42,
                        play_turns=5, use_probe=False).run()
-    t2 = SessionRunner("predator_evade", _agent(["ACTION: up"]), seed=42,
+    t2 = SessionRunner("template", _agent(["ACTION: up"]), seed=42,
                        play_turns=5, use_probe=False).run()
     # Same scripted agent + same seed -> identical realized trajectory.
     assert [t.focal_pos for t in t1.turns] == [t.focal_pos for t in t2.turns]
@@ -70,27 +53,20 @@ def test_short_budget_yields_survived_outcome():
     # after the played turns, so the engine fires `survived`.
     agent = _agent(["ACTION: up"])
     trace = SessionRunner(
-        "predator_evade", agent, seed=42, play_turns=1, use_probe=False,
+        "template", agent, seed=42, play_turns=1, use_probe=False,
     ).run()
     assert trace.outcome == "survived"
     assert trace.turns[-1].reward == 50.0  # _REWARD_SURVIVED
 
 
-def test_eliminated_outcome_is_explicit_and_terminal():
-    # The habit player ("left") walks into the dead-end and is caught.
-    agent = _agent(["ACTION: left"])
-    trace = SessionRunner(
-        "predator_evade", agent, seed=42, play_turns=15, use_probe=False,
-    ).run()
-    assert trace.outcome == "eliminated"
-    assert len(trace.turns) <= 15           # stopped at/under budget
-    assert trace.turns[-1].reward == -50.0  # _REWARD_CAPTURED
-
-
 def test_cut_frames_count_matches_cut_length_plus_one():
+    from proteus.game.engine.difficulty import Difficulty
+    from proteus.game.scenarios.base import get_scenario
+
     agent = _agent(["ACTION: up"])
     trace = SessionRunner(
-        "predator_evade", agent, seed=42, play_turns=5, use_probe=False,
+        "template", agent, seed=42, play_turns=5, use_probe=False,
     ).run()
-    # EASY cut_length is 2 -> initial frame + 2 step frames = 3.
-    assert len(trace.cut_frames) == 3
+    # initial frame + one frame per Cut pre-roll step (self-derived, not hardcoded).
+    expected = get_scenario("template")().cut_length(Difficulty.EASY) + 1
+    assert len(trace.cut_frames) == expected

tests/runtime/test_session_core.py

@@ -4,14 +4,14 @@ from __future__ import annotations
 
 import pytest
 
-import proteus.game.scenarios  # noqa: F401  (registers predator_evade)
+import proteus.game.scenarios  # noqa: F401  (registers template)
 from proteus.game.engine.difficulty import Difficulty
 from proteus.game.runtime import _session_core as core
 
 
 def test_build_session_is_deterministic_and_non_terminal():
-    a = core.build_session("predator_evade", 42, Difficulty.EASY, 10)
-    b = core.build_session("predator_evade", 42, Difficulty.EASY, 10)
+    a = core.build_session("template", 42, Difficulty.EASY, 10)
+    b = core.build_session("template", 42, Difficulty.EASY, 10)
     # Same seed -> identical cut frames in both representations.
     assert a.cut_frames == b.cut_frames
     assert a.cut_grids == b.cut_grids
@@ -23,7 +23,7 @@ def test_build_session_is_deterministic_and_non_terminal():
 
 
 def test_make_turn_trace_records_premove_keys_and_reward():
-    built = core.build_session("predator_evade", 42, Difficulty.EASY, 10)
+    built = core.build_session("template", 42, Difficulty.EASY, 10)
     obs = core.build_observation(built.scenario, built.game, built.cut_frames, 1)
     turn = core.make_turn_trace(
         built.scenario, built.game, turn_idx=1, observation=obs,
@@ -38,7 +38,7 @@ def test_make_turn_trace_records_premove_keys_and_reward():
 
 
 def test_finalize_produces_scored_trace():
-    built = core.build_session("predator_evade", 42, Difficulty.EASY, 3)
+    built = core.build_session("template", 42, Difficulty.EASY, 3)
     turns = []
     for i in range(1, 4):
         obs = core.build_observation(built.scenario, built.game, built.cut_frames, i)
@@ -49,12 +49,12 @@ def test_finalize_produces_scored_trace():
         if built.game.eliminated or built.game.survived:
             break
     trace = core.finalize(
-        "predator_evade", built.scenario, built.game,
+        "template", built.scenario, built.game,
         seed=42, difficulty=Difficulty.EASY, play_turns=3,
         turns=turns, cut_frames=built.cut_frames,
         motive_category="survival", model="human",
     )
-    assert trace.scenario == "predator_evade"
+    assert trace.scenario == "template"
     assert trace.model == "human"
     assert trace.outcome in ("survived", "eliminated")
     assert set(trace.metrics) >= {
@@ -66,11 +66,11 @@ def test_finalize_produces_scored_trace():
 def test_finalize_before_terminal_or_budget_raises():
     # The sole intentional divergence from the original SessionRunner: a
     # non-terminal, under-budget finalize raises (vs the old bare assert).
-    built = core.build_session("predator_evade", 42, Difficulty.EASY, 5)
+    built = core.build_session("template", 42, Difficulty.EASY, 5)
     assert not (built.game.eliminated or built.game.survived)
     with pytest.raises(core.SessionNotFinishedError):
         core.finalize(
-            "predator_evade", built.scenario, built.game,
+            "template", built.scenario, built.game,
             seed=42, difficulty=Difficulty.EASY, play_turns=5,
             turns=[], cut_frames=built.cut_frames,
             motive_category="survival", model="human",

tests/runtime/test_session_distance.py

@@ -8,7 +8,7 @@ from proteus.game.runtime import SessionRunner
 def test_each_turn_records_pre_and_post_bfs_distance():
     prov = FakeProvider(["ACTION: up"] * 10, model_name="demo")
     trace = SessionRunner(
-        "predator_evade", VanillaAgent(prov), difficulty=Difficulty.EASY,
+        "template", VanillaAgent(prov), difficulty=Difficulty.EASY,
         seed=42, play_turns=4, use_probe=False,
     ).run()
     for t in trace.turns:
@@ -23,7 +23,7 @@ def test_each_turn_records_pre_and_post_bfs_distance():
 def test_episode_records_turn_order_capture_rule_horizon():
     prov = FakeProvider(["ACTION: up"] * 10, model_name="demo")
     trace = SessionRunner(
-        "predator_evade", VanillaAgent(prov), difficulty=Difficulty.EASY,
+        "template", VanillaAgent(prov), difficulty=Difficulty.EASY,
         seed=42, play_turns=4, use_probe=False,
     ).run()
     assert trace.turn_order == "focal_then_predator"

tests/runtime/test_session_memory.py

@@ -3,7 +3,7 @@ from proteus.game.runtime.trace import SessionTrace
 
 def test_session_trace_memory_ref_defaults_none_and_round_trips():
     t = SessionTrace(
-        scenario="predator_evade", motive_category="survival", seed=42,
+        scenario="template", motive_category="survival", seed=42,
         difficulty="easy", model="demo", outcome="survived",
     )
     assert t.memory_ref is None
@@ -11,7 +11,7 @@ def test_session_trace_memory_ref_defaults_none_and_round_trips():
     assert t2.memory_ref is None
 
     t3 = SessionTrace(
-        scenario="predator_evade", motive_category="survival", seed=42,
+        scenario="template", motive_category="survival", seed=42,
         difficulty="easy", model="demo", outcome="survived",
         memory_ref="demo@FIXED",
     )
@@ -27,7 +27,7 @@ from proteus.game.runtime.memory import MemoryCheckpoint, MemoryTurn
 
 def _memory() -> MemoryCheckpoint:
     return MemoryCheckpoint(
-        model="demo", scenario="predator_evade", difficulty="easy", seed=42,
+        model="demo", scenario="template", difficulty="easy", seed=42,
         created_at="FIXED",
         memory_turns=[
             MemoryTurn(turn_idx=1, frame_ascii="MEMFRAME-1", action="up",
@@ -42,22 +42,26 @@ def _memory() -> MemoryCheckpoint:
 def _runner(memory=None, memory_ref=None) -> SessionRunner:
     prov = FakeProvider(["ACTION: stay"] * 20, model_name="demo")
     return SessionRunner(
-        "predator_evade", VanillaAgent(prov), difficulty=Difficulty.EASY,
+        "template", VanillaAgent(prov), difficulty=Difficulty.EASY,
         seed=42, play_turns=3, use_probe=False,
         memory=memory, memory_ref=memory_ref,
     )
 
 
-def test_memory_injection_lengthens_turn1_and_preserves_measurement():
+def test_memory_injection_shows_explicit_memory_and_preserves_measurement():
+    # NOTE: template provides a default (persona) memory, so the no-explicit-memory
+    # baseline already carries a MEMORY block. The contrast here is therefore
+    # "explicit fixture memory" vs "default memory", not "memory" vs "no memory".
     base = _runner().run()
     withmem = _runner(memory=_memory(), memory_ref="demo@FIXED").run()
 
     obs1 = withmem.turns[0].observation
-    # the memory block is present and turn-1 grew
+    # the explicit memory block is present at turn 1
     assert "MEMORY" in obs1
     assert "MEMFRAME-1" in obs1 and "MEMFRAME-2" in obs1
     assert "you chose: up" in obs1
-    assert len(obs1) > len(base.turns[0].observation)
+    # the explicit memory overrides the scenario default, so the observation differs
+    assert obs1 != base.turns[0].observation
 
     # the scored game is identical: same answer keys, diagnostic, metrics
     assert [t.motive_action for t in withmem.turns] == [t.motive_action for t in base.turns]
@@ -65,18 +69,14 @@ def test_memory_injection_lengthens_turn1_and_preserves_measurement():
     assert [t.is_diagnostic for t in withmem.turns] == [t.is_diagnostic for t in base.turns]
     assert withmem.metrics == base.metrics
 
-    # memory_ref recorded with memory, None without
+    # memory_ref recorded with explicit memory, None when falling back to default
     assert withmem.memory_ref == "demo@FIXED"
     assert base.memory_ref is None
 
 
 def test_memory_is_shown_every_turn_for_auto_regressive_play():
-    base = _runner().run()
     withmem = _runner(memory=_memory(), memory_ref="x").run()
-    # 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
+    # Auto-regressive play: the handover memory is carried on turn 2+ as well
+    # (not only turn 1), so a stateless agent never loses it mid-episode.
+    assert "MEMFRAME-1" in withmem.turns[0].observation
+    assert "MEMFRAME-1" in withmem.turns[1].observation

tests/runtime/test_spectate.py

@@ -17,7 +17,7 @@ def _agent(n=10):
 
 def _new(play_turns=5):
     return SpectateSession(
-        "predator_evade", agent=_agent(), model_name="fake:demo",
+        "template", agent=_agent(), model_name="fake:demo",
         difficulty=Difficulty.EASY, seed=42, play_turns=play_turns, use_probe=False,
     )
 
@@ -49,7 +49,7 @@ def test_advance_to_budget_then_done_and_finish():
     st = s.state()
     assert st["phase"] == "done" and st["outcome"] in ("survived", "eliminated")
     trace = s.finish()
-    assert trace.model == "fake:demo" and trace.scenario == "predator_evade"
+    assert trace.model == "fake:demo" and trace.scenario == "template"
 
 
 def test_advance_after_done_raises():

tests/runtime/test_spectate_equivalence.py

@@ -20,13 +20,13 @@ def _agent():
 
 def test_spectate_matches_session_runner():
     runner = SessionRunner(
-        "predator_evade", _agent(), difficulty=Difficulty.EASY, seed=42,
+        "template", _agent(), difficulty=Difficulty.EASY, seed=42,
         play_turns=len(RESPONSES), use_probe=False,
     )
     batch_trace = runner.run()
 
     sess = SpectateSession(
-        "predator_evade", agent=_agent(), model_name="demo",
+        "template", agent=_agent(), model_name="demo",
         difficulty=Difficulty.EASY, seed=42, play_turns=len(RESPONSES), use_probe=False,
     )
     while sess.state()["outcome"] is None:

tests/runtime/test_trace.py

@@ -39,7 +39,7 @@ def test_sessiontrace_defaults_and_nesting():
         predator_pos=(5, 3),
     )
     s = SessionTrace(
-        scenario="predator_evade",
+        scenario="template",
         motive_category="survival",
         seed=42,
         difficulty="easy",

tests/runtime/test_trace_accounting.py

@@ -6,7 +6,7 @@ from proteus.game.runtime import SessionRunner, SessionTrace
 def _run(response):
     agent = VanillaAgent(FakeProvider(responses=[response], model_name="fake-1"))
     return SessionRunner(
-        "predator_evade", agent, seed=42, play_turns=3, use_probe=False,
+        "template", agent, seed=42, play_turns=3, use_probe=False,
     ).run()
 
 
@@ -43,7 +43,7 @@ def test_probe_accounting_persisted_when_enabled():
         model_name="fake-1",
     ))
     trace = SessionRunner(
-        "predator_evade", agent, seed=42, play_turns=3, use_probe=True,
+        "template", agent, seed=42, play_turns=3, use_probe=True,
     ).run()
     t0 = trace.turns[0]
     assert t0.probe_a                               # answer recorded

tests/viz/test_gif.py

@@ -9,7 +9,7 @@ from proteus.game.viz import reconstruct, write_gif
 def _trace():
     prov = FakeProvider(["ACTION: up"] * 10, model_name="demo")
     return SessionRunner(
-        "predator_evade", VanillaAgent(prov), difficulty=Difficulty.EASY,
+        "template", VanillaAgent(prov), difficulty=Difficulty.EASY,
         seed=42, play_turns=4, use_probe=False,
     ).run()
 

tests/viz/test_png.py

@@ -11,7 +11,7 @@ from proteus.game.viz import reconstruct, write_pngs
 def _steps():
     agent = VanillaAgent(FakeProvider(["ACTION: up"]))
     trace = SessionRunner(
-        "predator_evade", agent, seed=42, play_turns=4, use_probe=False,
+        "template", agent, seed=42, play_turns=4, use_probe=False,
     ).run()
     return reconstruct(trace)
 

tests/viz/test_reconstruct.py

@@ -12,14 +12,14 @@ from proteus.game.viz import FrameStep, TraceReconstructionError, reconstruct
 def _make_trace(seed=42, turns=5, action="ACTION: up"):
     agent = VanillaAgent(FakeProvider([action]))
     return SessionRunner(
-        "predator_evade", agent, seed=seed, play_turns=turns, use_probe=False,
+        "template", agent, seed=seed, play_turns=turns, use_probe=False,
     ).run()
 
 
 def test_reconstruct_frame_count_matches_cut_plus_play():
     trace = _make_trace()
     steps = reconstruct(trace)
-    cut_len = get_scenario("predator_evade")().cut_length(Difficulty.EASY)
+    cut_len = get_scenario("template")().cut_length(Difficulty.EASY)
     # initial Cut frame + cut_len Cut steps + one frame per played turn.
     assert len(steps) == (cut_len + 1) + len(trace.turns)
     assert all(isinstance(s, FrameStep) for s in steps)

tests/viz/test_terminal.py

@@ -7,7 +7,7 @@ from proteus.game.viz import reconstruct, render_terminal
 def _steps():
     agent = VanillaAgent(FakeProvider(["ACTION: up"]))
     trace = SessionRunner(
-        "predator_evade", agent, seed=42, play_turns=4, use_probe=False,
+        "template", agent, seed=42, play_turns=4, use_probe=False,
     ).run()
     return reconstruct(trace), trace
 

tests/web/test_memory_modes.py

@@ -12,14 +12,14 @@ def _reg():
 
 def test_default_play_quota_is_100():
     _, payload, _ = server.handle_request(
-        "POST", "/session", {"scenario": "predator_evade"}, _reg())
+        "POST", "/session", {"scenario": "template"}, _reg())
     assert payload["state"]["play_turns"] == 100
 
 
 def test_persona_memory_attached_to_human_session():
     _, payload, _ = server.handle_request(
         "POST", "/session",
-        {"scenario": "predator_evade", "seed": 42, "play_turns": 3,
+        {"scenario": "template", "seed": 42, "play_turns": 3,
          "memory": "persona:risk_averse"}, _reg())
     assert payload["memory"]["attached"] is True
     assert payload["memory"]["persona"] == "risk_averse"
@@ -41,14 +41,14 @@ def test_none_forces_no_memory_even_when_scenario_has_a_default():
 def test_unknown_persona_is_400():
     status, payload, _ = server.handle_request(
         "POST", "/session",
-        {"scenario": "predator_evade", "memory": "persona:bogus"}, _reg())
+        {"scenario": "template", "memory": "persona:bogus"}, _reg())
     assert status == 400 and "error" in payload
 
 
 def test_generate_memory_via_fake_model_on_spectate(tmp_path):
     status, payload, _ = server.handle_request(
         "POST", "/spectate",
-        {"scenario": "predator_evade", "seed": 42, "play_turns": 2,
+        {"scenario": "template", "seed": 42, "play_turns": 2,
          "model": "fake:demo", "memory": "generate",
          "memory_root": str(tmp_path)}, _reg())
     assert status == 200
@@ -57,7 +57,7 @@ def test_generate_memory_via_fake_model_on_spectate(tmp_path):
     # generate saved a checkpoint under the (tmp) root -> latest can find it.
     status, latest, _ = server.handle_request(
         "POST", "/spectate",
-        {"scenario": "predator_evade", "seed": 42, "play_turns": 2,
+        {"scenario": "template", "seed": 42, "play_turns": 2,
          "model": "fake:demo", "memory": "latest",
          "memory_root": str(tmp_path)}, _reg())
     assert status == 200 and latest["memory"]["attached"] is True
@@ -66,7 +66,7 @@ def test_generate_memory_via_fake_model_on_spectate(tmp_path):
 def test_generate_without_model_on_human_is_400():
     status, payload, _ = server.handle_request(
         "POST", "/session",
-        {"scenario": "predator_evade", "memory": "generate"}, _reg())
+        {"scenario": "template", "memory": "generate"}, _reg())
     assert status == 400 and "needs a model" in payload["error"]
 
 
@@ -75,12 +75,12 @@ def test_response_carries_rendered_memory_block_for_display():
     # the rendered block the model is given.
     _, payload, _ = server.handle_request(
         "POST", "/session",
-        {"scenario": "predator_evade", "seed": 42, "play_turns": 3,
+        {"scenario": "template", "seed": 42, "play_turns": 3,
          "memory": "persona:risk_averse"}, _reg())
     assert payload["memory"]["block"] and "MEMORY" in payload["memory"]["block"]
     # 'none' carries no block.
     _, none, _ = server.handle_request(
-        "POST", "/session", {"scenario": "predator_evade", "memory": "none"}, _reg())
+        "POST", "/session", {"scenario": "template", "memory": "none"}, _reg())
     assert none["memory"]["block"] is None
 
 

tests/web/test_server.py

@@ -15,7 +15,7 @@ def test_config_lists_scenarios_difficulties_and_color_map():
     reg = _registry()
     status, payload, ctype = server.handle_request("GET", "/config", None, reg)
     assert status == 200 and ctype == "application/json"
-    assert "predator_evade" in payload["scenarios"]
+    assert "template" in payload["scenarios"]
     assert payload["difficulties"] == ["easy", "medium", "hard", "expert"]
     # color_map keys are stringified ints -> hex.
     assert payload["color_map"]["0"].startswith("#")
@@ -30,7 +30,7 @@ def test_root_serves_html_bytes():
 
 def test_create_session_returns_id_and_fair_state():
     reg = _registry()
-    body = {"scenario": "predator_evade", "difficulty": "easy", "seed": 42,
+    body = {"scenario": "template", "difficulty": "easy", "seed": 42,
             "play_turns": 5, "probe": False}
     status, payload, _ = server.handle_request("POST", "/session", body, reg)
     assert status == 200
@@ -48,7 +48,7 @@ def test_act_advances_and_unknown_action_is_400():
     reg = _registry()
     _, created, _ = server.handle_request(
         "POST", "/session",
-        {"scenario": "predator_evade", "difficulty": "easy", "seed": 42,
+        {"scenario": "template", "difficulty": "easy", "seed": 42,
          "play_turns": 5, "probe": False}, reg)
     sid = created["session_id"]
 
@@ -79,7 +79,7 @@ def test_non_numeric_seed_is_400_not_500():
     # A malformed seed must be a structured 400, never an unhandled 500.
     status, payload, _ = server.handle_request(
         "POST", "/session",
-        {"scenario": "predator_evade", "difficulty": "easy", "seed": "abc",
+        {"scenario": "template", "difficulty": "easy", "seed": "abc",
          "play_turns": 5, "probe": False}, _registry())
     assert status == 400 and "error" in payload
 
@@ -88,7 +88,7 @@ def test_query_string_is_ignored_in_routing():
     # /config with a query string must still route to config, not fall to 404.
     status, payload, ctype = server.handle_request(
         "GET", "/config?cachebust=1", None, _registry())
-    assert status == 200 and "predator_evade" in payload["scenarios"]
+    assert status == 200 and "template" in payload["scenarios"]
 
 
 def test_get_poll_state_is_fair_mid_game():
@@ -96,7 +96,7 @@ def test_get_poll_state_is_fair_mid_game():
     reg = _registry()
     _, created, _ = server.handle_request(
         "POST", "/session",
-        {"scenario": "predator_evade", "difficulty": "easy", "seed": 42,
+        {"scenario": "template", "difficulty": "easy", "seed": 42,
          "play_turns": 5, "probe": False}, reg)
     sid = created["session_id"]
     server.handle_request("POST", f"/session/{sid}/act", {"action": "up"}, reg)
@@ -113,7 +113,7 @@ def test_finish_appends_trace_and_returns_metrics(tmp_path):
     reg = _registry()
     _, created, _ = server.handle_request(
         "POST", "/session",
-        {"scenario": "predator_evade", "difficulty": "easy", "seed": 42,
+        {"scenario": "template", "difficulty": "easy", "seed": 42,
          "play_turns": 3, "probe": False}, reg)
     sid = created["session_id"]
     # Exhaust the budget.

tests/web/test_spectate_routes.py

@@ -19,7 +19,7 @@ def test_spectate_create_next_finish(tmp_path):
     reg = _reg()
     status, created, _ = server.handle_request(
         "POST", "/spectate",
-        {"scenario": "predator_evade", "difficulty": "easy", "seed": 42,
+        {"scenario": "template", "difficulty": "easy", "seed": 42,
          "play_turns": 3, "model": "fake:demo", "probe": False}, reg)
     assert status == 200
     sid = created["session_id"]
@@ -46,7 +46,7 @@ def test_spectate_create_next_finish(tmp_path):
 def test_unknown_model_is_400():
     status, payload, _ = server.handle_request(
         "POST", "/spectate",
-        {"scenario": "predator_evade", "difficulty": "easy", "seed": 1,
+        {"scenario": "template", "difficulty": "easy", "seed": 1,
          "play_turns": 3, "model": "nope:x", "probe": False}, _reg())
     assert status == 400 and "error" in payload
 
@@ -55,7 +55,7 @@ def test_next_after_done_is_409():
     reg = _reg()
     _, created, _ = server.handle_request(
         "POST", "/spectate",
-        {"scenario": "predator_evade", "difficulty": "easy", "seed": 42,
+        {"scenario": "template", "difficulty": "easy", "seed": 42,
          "play_turns": 1, "model": "fake:demo", "probe": False}, reg)
     sid = created["session_id"]
     server.handle_request("POST", f"/spectate/{sid}/next", None, reg)  # exhausts budget