docs(cp6): implementation plan — 9 TDD tasks (layouts + category eval + compare)

docs/superpowers/plans/2026-06-02-proteus-cp6-difficulty-eval-baseline.md

@@ -0,0 +1,1165 @@
+# PROTEUS CP6 — Difficulty Layouts + Category-Specific Eval + Human-Baseline Harness Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make `Difficulty` produce four genuinely distinct hand-authored predator_evade layouts, move per-turn evaluation into the scenario as a category-specific `step_reward` (survival = reward for moving away from the predator), add a deterministic optimal-rollout trajectory metric, and ship a `proteus compare` CLI that aggregates human/LLM traces.
+
+**Architecture:** Three task groups over the existing engine. (A) The `Scenario` ABC gains a `difficulty` parameter on `build_level`; predator_evade selects a per-difficulty layout table; golden tests pin each band's `optimal≠habit` handover invariant. (B) Reward ownership moves from `SessionRunner._reward` into `Scenario.step_reward`; predator_evade scores survival by BFS-distance gain from the predator's pre-move position; a new `runtime/rollout.py` simulates the optimal trajectory; `metrics.py` adds `away_move_fraction`, `mean_step_reward`, `trajectory_agreement`, `final_distance_gap`. (C) `runtime/aggregate.py` + a `compare` CLI subcommand group traces by `(model, difficulty)`.
+
+**Tech Stack:** Python 3.12, pydantic v2, numpy, argparse, pytest. Run tests with `.venv/bin/python -m pytest` (NOTE: bare `python` is NOT on PATH). Baseline before CP6: **103 passed**.
+
+**Spec:** `docs/superpowers/specs/2026-06-02-proteus-cp6-difficulty-eval-baseline-design.md` under parent SSOT `docs/superpowers/specs/2026-06-01-proteus-arena-slice-design.md`.
+
+---
+
+## File Structure
+
+| File | Responsibility | Task |
+|------|----------------|------|
+| `proteus/grid/scenario.py` | ABC: `build_level(+difficulty)`, `step_reward` (new abstract), `safety_distance`/`record_focal_move` (concrete defaults) | 1, 4 |
+| `proteus/grid/game.py` | pass `self.difficulty` into `build_level` | 1 |
+| `proteus/grid/scenarios/predator_evade.py` | per-difficulty layout table + dispatch; survival `step_reward`; `safety_distance` | 2, 3, 4 |
+| `proteus/runtime/session.py` | delegate reward to `scenario.step_reward`; pass rollout + safety distances to metrics | 4, 6 |
+| `proteus/runtime/rollout.py` (new) | deterministic optimal-trajectory simulator | 5 |
+| `proteus/runtime/metrics.py` | add 4 metric keys | 6 |
+| `proteus/runtime/aggregate.py` (new) | pure `aggregate_traces` | 7 |
+| `proteus/cli.py` | `compare` subcommand | 8 |
+| `tests/grid/test_difficulty_layouts.py` (new) | per-difficulty golden invariants | 2, 3 |
+| `tests/grid/test_step_reward.py` (new) | survival reward property | 4 |
+| `tests/runtime/test_rollout.py` (new) | optimal rollout determinism | 5 |
+| `tests/runtime/test_metrics.py` (modify) | new metric keys | 6 |
+| `tests/runtime/test_aggregate.py` (new) | aggregation | 7 |
+| `tests/cli/test_cli.py` (modify) | `compare` | 8 |
+
+**Dependency direction (parent spec §3, invariant):** `runtime` depends on `grid`; `grid`/`arc_grid` never import `runtime`. `rollout.py` mirrors `viz.reconstruct`'s engine-replay pattern (imports `grid`, not `runtime.session`).
+
+**Layout-task note (read before Tasks 2–3):** The four layouts are *hand-authored*. The golden test is the **oracle**: it asserts (a) determinism, (b) the exact handover positions, and (c) `optimal_action != habit_action` with `habit` blocked. This plan gives concrete candidate coordinates; if a candidate fails the invariant, **tune the coordinates** (move the wall / predator start by one cell, following the EASY skeleton: the pre-roll direction must dead-end into a wall while a perpendicular move increases BFS distance) and re-run until green. Tuning fixed coordinates to satisfy the test is the authoring loop, not a placeholder.
+
+---
+
+## Task 1: Scenario ABC — `build_level(+difficulty)` + concrete defaults
+
+**Files:**
+- Modify: `proteus/grid/scenario.py`
+- Modify: `proteus/grid/game.py:103`
+- Modify: `proteus/grid/scenarios/predator_evade.py` (build_level signature only)
+- Test: `tests/grid/test_difficulty_layouts.py` (create)
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/grid/test_difficulty_layouts.py`:
+```python
+import random
+
+from proteus.grid.difficulty import Difficulty
+from proteus.grid.scenario 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.sprites}
+    assert "focal" in names and "predator" in names
+
+
+def test_record_focal_move_default_is_noop_on_base():
+    # A bare Scenario subclass that does not override record_focal_move
+    # inherits a no-op default (promoted from PredatorEvade).
+    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"
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/grid/test_difficulty_layouts.py -q`
+Expected: FAIL — `build_level()` takes 2 positional args (the difficulty arg is rejected).
+
+- [ ] **Step 3: Write minimal implementation**
+
+In `proteus/grid/scenario.py`, change the abstract `build_level` signature and add two concrete defaults at the end of the `Scenario` class body (after `legend`):
+```python
+    @abstractmethod
+    def build_level(self, rng: random.Random, difficulty) -> Level:
+        """Build the arc_grid level for *difficulty*: walls + initial sprites.
+
+        All randomness must flow from *rng* so that a given
+        ``(scenario, seed, difficulty)`` is fully deterministic.
+
+        Args:
+            rng: Seeded RNG owned by the game/module.
+            difficulty: The session difficulty band (a ``Difficulty``).
+
+        Returns:
+            A freshly built :class:`~proteus.arc_grid.Level`.
+        """
+        raise NotImplementedError
+```
+And add these concrete (non-abstract) methods to `Scenario` (so subclasses inherit safe defaults):
+```python
+    def record_focal_move(self, action: str) -> None:
+        """Record the focal's last committed move (no-op by default).
+
+        Scenarios whose ``habit_action`` tracks the live trajectory override
+        this; others (and future scenarios) inherit a safe no-op so callers
+        like ``SessionRunner`` and ``viz.reconstruct`` never hit AttributeError.
+        """
+        return None
+
+    def safety_distance(self, game) -> int | None:
+        """Return the focal's 'safety' distance for this motive (None by default).
+
+        Survival-style scenarios return the BFS distance from the focal to the
+        threat (larger = safer). Non-survival scenarios leave it ``None`` so the
+        trajectory final-distance metric is simply skipped for them.
+        """
+        return None
+```
+
+In `proteus/grid/game.py:103`, change:
+```python
+        level = scenario.build_level(rng)
+```
+to:
+```python
+        level = scenario.build_level(rng, difficulty)
+```
+(`difficulty` is the constructor parameter, already in scope at that point.)
+
+In `proteus/grid/scenarios/predator_evade.py`, change the `build_level` signature to accept (and currently ignore) difficulty — EASY behaviour unchanged:
+```python
+    def build_level(self, rng: random.Random, difficulty) -> Level:
+```
+and update its docstring's first line to mention difficulty; leave the EASY body unchanged for now (Task 2 adds per-difficulty dispatch). Add `del difficulty` after `del rng` so the unused-arg intent is explicit:
+```python
+        del rng  # deterministic layout; rng reserved for tie-breaks
+        del difficulty  # per-difficulty dispatch added in Task 2
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `.venv/bin/python -m pytest tests/grid/test_difficulty_layouts.py -q`
+Expected: PASS (2 tests). Then full suite: `.venv/bin/python -m pytest -q` → **105 passed** (103 + 2).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add proteus/grid/scenario.py proteus/grid/game.py proteus/grid/scenarios/predator_evade.py tests/grid/test_difficulty_layouts.py
+git commit -m "feat(cp6): Scenario.build_level takes difficulty + record_focal_move/safety_distance defaults"
+```
+
+---
+
+## Task 2: Per-difficulty layout table + dispatch (EASY unchanged + MEDIUM/HARD/EXPERT)
+
+**Files:**
+- Modify: `proteus/grid/scenarios/predator_evade.py`
+- Test: `tests/grid/test_difficulty_layouts.py` (extend)
+
+- [ ] **Step 1: Write the failing test**
+
+Append to `tests/grid/test_difficulty_layouts.py`:
+```python
+import numpy as np
+
+from proteus.grid.game import MotiveGridGame
+
+
+_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 differ from EASY in at least one of size/positions.
+    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())
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/grid/test_difficulty_layouts.py -q`
+Expected: FAIL — `test_bands_have_distinct_grid_sizes_or_starts` fails because every band currently builds the EASY 8x8 layout (only one distinct tuple).
+
+- [ ] **Step 3: Write minimal implementation**
+
+In `proteus/grid/scenarios/predator_evade.py`, introduce a per-difficulty layout table. Add near the top (after the EASY constants block), a frozen layout description and a table:
+```python
+from dataclasses import dataclass
+
+
+@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),
+        # Longer vertical dead-end west of the focal's path.
+        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),
+        # L-shaped corner trap: vertical x=3 rows 3..8 + horizontal y=8 x=3..6.
+        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),
+        # Forked corridor: vertical x=3 rows 2..9 + a stub at y=3 x=4..5 that
+        # makes the upward escape less safe, pushing the optimal move downward.
+        wall_cells=(
+            tuple((3, y) for y in range(2, 10))
+            + ((4, 3), (5, 3))
+        ),
+    ),
+}
+```
+Note: `_LAYOUTS[Difficulty.EASY]` must reproduce the existing EASY constants exactly. Keep the module-level `_GRID_SIZE`, `_FOCAL_START`, `_PREDATOR_START`, `_WALL_CELLS` as-is (other code/docstrings reference them) but have EASY's `_Layout` mirror them.
+
+Update `grid_size` to be EASY's default for the class attribute (the camera sizes per built level, so the class attribute is only a hint); keep `grid_size: tuple[int, int] = _GRID_SIZE`.
+
+Rewrite `build_level` to dispatch on difficulty:
+```python
+    def build_level(self, rng: random.Random, 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.arc_grid.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)
+        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)
+```
+
+If `grid_size` (the class attribute) is read by the game's camera to size the grid, confirm the game sizes the camera from the built level's sprites/size rather than the class attribute; if it reads `scenario.grid_size`, set `self.grid_size = layout.grid_size` inside `build_level` so the camera matches the band. (Check `game.py.__init__` camera construction; adjust so each band renders at its own grid size — the `test_*_grid_size` assertions depend on `current_grid().shape` matching the band.)
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `.venv/bin/python -m pytest tests/grid/test_difficulty_layouts.py -q`
+Expected: PASS. EASY unchanged; the four bands produce distinct, deterministic grids. Then full suite: `.venv/bin/python -m pytest -q` → all pass (EASY-dependent tests unaffected).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add proteus/grid/scenarios/predator_evade.py tests/grid/test_difficulty_layouts.py
+git commit -m "feat(cp6): per-difficulty hand-authored predator_evade layouts (EASY unchanged)"
+```
+
+---
+
+## Task 3: Per-difficulty diagnostic invariant (optimal≠habit) golden tests
+
+**Files:**
+- Test: `tests/grid/test_difficulty_layouts.py` (extend)
+- Possibly modify: `proteus/grid/scenarios/predator_evade.py` (tune layout coords until invariant holds)
+
+- [ ] **Step 1: Write the failing test**
+
+Append to `tests/grid/test_difficulty_layouts.py`:
+```python
+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)
+```
+
+- [ ] **Step 2: Run test to verify it fails (or surfaces a layout to tune)**
+
+Run: `.venv/bin/python -m pytest tests/grid/test_difficulty_layouts.py::test_invariant_optimal_differs_from_habit_each_band -q`
+Expected: FAIL for any band whose candidate coordinates do not yet satisfy `optimal != habit`. The failure message names the band and the colliding actions.
+
+- [ ] **Step 3: Tune the failing band(s) until the invariant holds**
+
+For each failing band, adjust that band's `_Layout` in `_LAYOUTS` so that at the handover (focal having walked `left` for `cut_length` steps):
+1. The cell directly west of the focal is a wall (so `habit_action == "left"` is blocked → does not increase BFS distance).
+2. At least one perpendicular move (`up`/`down`) is legal and lands on a cell with strictly greater BFS distance to the predator's handover position (so `optimal_action` is that perpendicular move).
+
+Concretely, per the EASY skeleton: if a band fails, (a) confirm the focal's handover x equals `wall_x + 1` (focal sits just east of the wall column), and (b) ensure the wall column covers the focal's handover row. Move `focal_start.x` so that `focal_start.x - cut_length == wall_x + 1`, and/or extend `wall_cells` to include `(wall_x, focal_handover_y)`. For HARD/EXPERT, also verify the predator handover position leaves `up` (or `down`) as the unique BFS-max so the tie-break yields a perpendicular move, not `left`. Re-run after each adjustment.
+
+Use this REPL helper to inspect a band while tuning:
+```bash
+.venv/bin/python -c "
+import random
+from proteus.grid.difficulty import Difficulty
+from proteus.grid.game import MotiveGridGame
+from proteus.grid.scenario import get_scenario
+from proteus.grid.ascii_view import frame_to_ascii
+s = get_scenario('predator_evade')()
+d = Difficulty.HARD
+g = MotiveGridGame(s, random.Random(42), d, max_steps=40)
+for _ in range(s.cut_length(d)):
+    a = s.cut_focal_policy(g); g.apply_motive_action(a); s.record_focal_move(a)
+print(frame_to_ascii(g.current_grid(), s.legend()))
+print('focal', (g.focal_sprite.x, g.focal_sprite.y), 'pred', (g.predator_sprite.x, g.predator_sprite.y))
+print('optimal', s.optimal_action(g), 'habit', s.habit_action(g))
+"
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `.venv/bin/python -m pytest tests/grid/test_difficulty_layouts.py -q`
+Expected: PASS (all layout tests including the invariant for all four bands). Then full suite: `.venv/bin/python -m pytest -q` → all pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add proteus/grid/scenarios/predator_evade.py tests/grid/test_difficulty_layouts.py
+git commit -m "test(cp6): lock optimal!=habit handover invariant for all difficulty bands"
+```
+
+---
+
+## Task 4: Scenario-owned `step_reward` (survival) + `safety_distance` + SessionRunner delegation
+
+**Files:**
+- Modify: `proteus/grid/scenario.py` (add abstract `step_reward`)
+- Modify: `proteus/grid/scenarios/predator_evade.py` (`step_reward`, `safety_distance`, reward constants)
+- Modify: `proteus/runtime/session.py` (delegate; remove `_reward`; pass pre-move positions)
+- Test: `tests/grid/test_step_reward.py` (create)
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/grid/test_step_reward.py`:
+```python
+import random
+
+from proteus.grid.difficulty import Difficulty
+from proteus.grid.game import MotiveGridGame
+from proteus.grid.scenario import get_scenario
+
+
+def _handover():
+    s = get_scenario("predator_evade")()
+    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()
+    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,
+                      focal_before=focal_before, predator_before=predator_before)
+    assert r > 0
+
+
+def test_step_reward_negative_when_moving_toward():
+    game, s = _handover()
+    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).
+    game.apply_motive_action("right")
+    r = s.step_reward(game, "right", blocked=False,
+                      focal_before=focal_before, predator_before=predator_before)
+    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")
+    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()
+    d = s.safety_distance(game)
+    assert isinstance(d, int) and d >= 0
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/grid/test_step_reward.py -q`
+Expected: FAIL — `PredatorEvade` has no `step_reward`.
+
+- [ ] **Step 3: Write minimal implementation**
+
+In `proteus/grid/scenario.py`, add an abstract method (after `habit_action`):
+```python
+    @abstractmethod
+    def step_reward(
+        self,
+        game: MotiveGridGame,
+        action: str,
+        blocked: bool,
+        focal_before: tuple[int, int],
+        predator_before: tuple[int, int],
+    ) -> float:
+        """Return the per-turn reward for *action* under this scenario's motive.
+
+        Called AFTER the turn is fully applied (focal moved, threat advanced,
+        terminal flags set), so ``game`` holds the post-move state. The pre-move
+        focal and predator positions are passed in so distance-delta rewards can
+        isolate the agent's own move from the threat's response.
+        """
+        raise NotImplementedError
+```
+
+In `proteus/grid/scenarios/predator_evade.py`, add the reward constants near the top:
+```python
+# Survival-category reward constants (moved from SessionRunner; see CP6 spec §5).
+_REWARD_CAPTURED = -50.0
+_REWARD_SURVIVED = 50.0
+_REWARD_WALL_HIT = -3.0
+```
+And implement the two methods (after `record_focal_move`):
+```python
+    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.
+        """
+        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))
+```
+
+In `proteus/runtime/session.py`: remove the `_REWARD_*` module constants and the `_reward` method; change the turn loop to capture pre-move positions (already captured as `focal_pos`/`predator_pos`) and delegate. Replace:
+```python
+            blocked = self._apply(result.action)
+            reward = self._reward(result.action, optimal, blocked)
+```
+with:
+```python
+            blocked = self._apply(result.action)
+            reward = self._scenario.step_reward(
+                self._game, result.action, blocked,
+                focal_before=focal_pos, predator_before=predator_pos,
+            )
+```
+Delete the now-unused `_reward` method and the five `_REWARD_*` constants. (`focal_pos`/`predator_pos` are the pre-move tuples already computed just above `result = self._agent.act(...)`.)
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `.venv/bin/python -m pytest tests/grid/test_step_reward.py -q`
+Expected: PASS (4 tests).
+Then full suite: `.venv/bin/python -m pytest -q`. NOTE: `tests/runtime/test_integration_golden.py` / `test_session.py` may assert exact per-turn `reward` values from the old schedule — update those expected reward values to the new distance-based numbers (run the test, read the actual reward in the failure, confirm it matches the away/toward/terminal semantics, and update the expected value). Do NOT weaken the assertions; update them to the correct new values.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add proteus/grid/scenario.py proteus/grid/scenarios/predator_evade.py proteus/runtime/session.py tests/grid/test_step_reward.py tests/runtime/test_integration_golden.py tests/runtime/test_session.py
+git commit -m "feat(cp6): scenario-owned survival step_reward (away-from-predator) + safety_distance"
+```
+
+---
+
+## Task 5: `runtime/rollout.py` — deterministic optimal-trajectory simulator
+
+**Files:**
+- Create: `proteus/runtime/rollout.py`
+- Test: `tests/runtime/test_rollout.py` (create)
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/runtime/test_rollout.py`:
+```python
+from proteus.grid.difficulty import Difficulty
+from proteus.runtime.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)
+    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)
+    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
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/runtime/test_rollout.py -q`
+Expected: FAIL — `ModuleNotFoundError: No module named 'proteus.runtime.rollout'`.
+
+- [ ] **Step 3: Write minimal implementation**
+
+Create `proteus/runtime/rollout.py`:
+```python
+"""Deterministic optimal-trajectory rollout for the trajectory metric.
+
+Mirrors viz.reconstruct's engine-replay pattern: rebuild the game from
+(scenario, seed, difficulty), replay the scripted Cut pre-roll, then play
+OPTIMALLY (scenario.optimal_action each turn) for up to n_turns, capturing the
+pre-move focal position per turn and the final safety distance. This is the
+"ideal motive-reader" reference path the realized trajectory is scored against.
+"""
+
+from __future__ import annotations
+
+import random
+from dataclasses import dataclass
+
+from proteus.grid.difficulty import Difficulty
+from proteus.grid.game import MotiveGridGame
+from proteus.grid.scenario import get_scenario
+
+
+@dataclass(frozen=True)
+class RolloutResult:
+    """The optimal player's trajectory for one session."""
+
+    focal_positions: list[tuple[int, int]]  # pre-move focal cell per optimal turn
+    final_safety_distance: int | None       # BFS focal->predator at rollout end
+
+
+def optimal_rollout(
+    scenario_name: str,
+    seed: int | None,
+    difficulty: Difficulty,
+    n_turns: int,
+) -> RolloutResult:
+    """Simulate the optimal trajectory and return its positions + final safety.
+
+    Args:
+        scenario_name: Registered scenario key.
+        seed: Session seed (same world as the real run).
+        difficulty: Session difficulty band.
+        n_turns: Cap on optimal play turns (use the realized play length so the
+            two trajectories align index-for-index).
+    """
+    scenario = get_scenario(scenario_name)()
+    rng = random.Random(seed)
+    cut_length = scenario.cut_length(difficulty)
+    game = MotiveGridGame(scenario, rng, difficulty, max_steps=cut_length + n_turns)
+
+    # Cut pre-roll (scripted policy), identical to SessionRunner.
+    for _ in range(cut_length):
+        action = scenario.cut_focal_policy(game)
+        game.apply_motive_action(action)
+        scenario.record_focal_move(action)
+
+    focal_positions: list[tuple[int, int]] = []
+    for _ in range(n_turns):
+        focal = game.focal_sprite
+        if focal is None:
+            break
+        focal_positions.append((focal.x, focal.y))  # pre-move
+        action = scenario.optimal_action(game)
+        game.apply_motive_action(action)
+        scenario.record_focal_move(action)
+        if game.eliminated or game.survived:
+            break
+
+    return RolloutResult(
+        focal_positions=focal_positions,
+        final_safety_distance=scenario.safety_distance(game),
+    )
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `.venv/bin/python -m pytest tests/runtime/test_rollout.py -q`
+Expected: PASS (3 tests). Then full suite: `.venv/bin/python -m pytest -q` → all pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add proteus/runtime/rollout.py tests/runtime/test_rollout.py
+git commit -m "feat(cp6): runtime.rollout — deterministic optimal-trajectory simulator"
+```
+
+---
+
+## Task 6: Metrics — `away_move_fraction`, `mean_step_reward`, `trajectory_agreement`, `final_distance_gap`
+
+**Files:**
+- Modify: `proteus/runtime/metrics.py`
+- Modify: `proteus/runtime/session.py` (wire rollout + safety distances into compute_metrics)
+- Test: `tests/runtime/test_metrics.py` (extend)
+
+- [ ] **Step 1: Write the failing test**
+
+Append to `tests/runtime/test_metrics.py` (import `compute_metrics` and `TurnTrace` are already imported there; add if missing):
+```python
+def _turn(idx, action, motive, reward, focal_pos):
+    return TurnTrace(
+        turn_idx=idx, observation="", probe_q="", probe_a="",
+        reasoning="", raw_text="", action=action, motive_action=motive,
+        habit_action="left", is_diagnostic=(motive != "left"),
+        was_congruent=(action == motive), reward=reward,
+        focal_pos=focal_pos, predator_pos=(0, 0),
+    )
+
+
+def test_away_move_fraction_and_mean_reward():
+    turns = [
+        _turn(1, "up", "up", 1.0, (3, 3)),     # away (reward > 0)
+        _turn(2, "right", "up", -1.0, (3, 2)), # toward (reward < 0)
+        _turn(3, "up", "up", 2.0, (4, 2)),     # away
+    ]
+    m = compute_metrics(turns, played_turns=3, play_turns=5, outcome="eliminated")
+    assert m["away_move_fraction"] == 2 / 3 * 100.0
+    assert m["mean_step_reward"] == (1.0 - 1.0 + 2.0) / 3
+
+
+def test_trajectory_agreement_and_final_gap():
+    turns = [
+        _turn(1, "up", "up", 1.0, (3, 3)),
+        _turn(2, "up", "up", 1.0, (3, 2)),
+    ]
+    # Optimal pre-move positions: turn1 matches (3,3), turn2 differs (4,2) vs (3,2).
+    m = compute_metrics(
+        turns, played_turns=2, play_turns=5, outcome="eliminated",
+        optimal_focal_positions=[(3, 3), (4, 2)],
+        realized_final_safety=2, optimal_final_safety=4,
+    )
+    assert m["trajectory_agreement"] == 1 / 2 * 100.0
+    assert m["final_distance_gap"] == 2.0
+
+
+def test_new_metric_keys_default_zero_without_rollout():
+    turns = [_turn(1, "up", "up", 1.0, (3, 3))]
+    m = compute_metrics(turns, played_turns=1, play_turns=5, outcome="survived")
+    # Trajectory keys default to 0.0 when no rollout data is supplied.
+    assert m["trajectory_agreement"] == 0.0
+    assert m["final_distance_gap"] == 0.0
+    assert set(m) >= {
+        "motive_reading_accuracy", "reactivity_index", "survival_fraction",
+        "first_divergence_turn", "away_move_fraction", "mean_step_reward",
+        "trajectory_agreement", "final_distance_gap",
+    }
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/runtime/test_metrics.py -q`
+Expected: FAIL — `compute_metrics` does not accept `optimal_focal_positions` / lacks the new keys.
+
+- [ ] **Step 3: Write minimal implementation**
+
+In `proteus/runtime/metrics.py`, extend `compute_metrics`:
+```python
+def compute_metrics(
+    turns: list[TurnTrace],
+    *,
+    played_turns: int,
+    play_turns: int,
+    outcome: str,
+    optimal_focal_positions: list[tuple[int, int]] | None = None,
+    realized_final_safety: int | None = None,
+    optimal_final_safety: int | None = None,
+) -> dict[str, float]:
+```
+Update the early `n == 0` return dict to include the four new keys (all `0.0`):
+```python
+    if n == 0:
+        return {
+            "motive_reading_accuracy": 0.0,
+            "reactivity_index": 0.0,
+            "survival_fraction": 0.0,
+            "first_divergence_turn": 0.0,
+            "away_move_fraction": 0.0,
+            "mean_step_reward": 0.0,
+            "trajectory_agreement": 0.0,
+            "final_distance_gap": 0.0,
+        }
+```
+After computing the existing metrics, add:
+```python
+    away_moves = sum(1 for t in turns if t.reward > 0)
+    away_move_fraction = away_moves / n * 100.0
+    mean_step_reward = sum(t.reward for t in turns) / n
+
+    trajectory_agreement = 0.0
+    if optimal_focal_positions:
+        realized = [tuple(t.focal_pos) for t in turns]
+        optimal = [tuple(p) for p in optimal_focal_positions]
+        compared = min(len(realized), len(optimal))
+        agree = sum(1 for i in range(compared) if realized[i] == optimal[i])
+        trajectory_agreement = agree / n * 100.0
+
+    final_distance_gap = 0.0
+    if realized_final_safety is not None and optimal_final_safety is not None:
+        final_distance_gap = float(abs(realized_final_safety - optimal_final_safety))
+```
+and add the four keys to the returned dict.
+
+In `proteus/runtime/session.py`, import the rollout and `safety_distance`, and wire them into the `compute_metrics` call. At the top of `run()`'s metrics section (after the play loop, where `compute_metrics` is currently called):
+```python
+        from proteus.runtime.rollout import optimal_rollout
+
+        rollout = optimal_rollout(
+            self._scenario_name, self._seed, self._difficulty, len(turns),
+        )
+        realized_final_safety = self._scenario.safety_distance(self._game)
+        metrics = compute_metrics(
+            turns,
+            played_turns=len(turns),
+            play_turns=self._play_turns,
+            outcome=outcome,
+            optimal_focal_positions=rollout.focal_positions,
+            realized_final_safety=realized_final_safety,
+            optimal_final_safety=rollout.final_safety_distance,
+        )
+```
+(Use the existing `self._scenario_name` / `self._seed` / `self._difficulty` attributes — confirm their exact names in `__init__`; if the scenario name is stored differently, adapt. The import is local to avoid a top-level cycle, matching the codebase's lazy-import convention.)
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `.venv/bin/python -m pytest tests/runtime/test_metrics.py -q`
+Expected: PASS. Then full suite: `.venv/bin/python -m pytest -q`. The golden test `tests/runtime/test_integration_golden.py` likely pins the full metrics dict — update its expected dict to include the four new keys with their now-correct values (read them from the failure output; verify they are sane, e.g. an optimal-playing fake agent yields high `trajectory_agreement`). `test_human_comparability`'s `set(h.metrics) == set(v.metrics)` still holds (both gain the same keys).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add proteus/runtime/metrics.py proteus/runtime/session.py tests/runtime/test_metrics.py tests/runtime/test_integration_golden.py
+git commit -m "feat(cp6): trajectory + category-reward metrics (away_move_fraction, trajectory_agreement, ...)"
+```
+
+---
+
+## Task 7: `runtime/aggregate.py` — pure trace aggregation
+
+**Files:**
+- Create: `proteus/runtime/aggregate.py`
+- Test: `tests/runtime/test_aggregate.py` (create)
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/runtime/test_aggregate.py`:
+```python
+from proteus.agents import VanillaAgent
+from proteus.providers import FakeProvider
+from proteus.runtime.aggregate import aggregate_traces
+from proteus.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,
+    ).run()
+
+
+def test_aggregate_groups_by_model_and_difficulty():
+    traces = [_trace(1), _trace(2)]
+    groups = aggregate_traces(traces)
+    # One group: (model="fake", difficulty="easy").
+    assert ("fake", "easy") in groups
+    g = groups[("fake", "easy")]
+    assert g["n"] == 2
+    # Every metric key is aggregated to a mean (float).
+    assert "motive_reading_accuracy" in g["metrics"]
+    assert isinstance(g["metrics"]["motive_reading_accuracy"], float)
+
+
+def test_aggregate_means_are_correct():
+    traces = [_trace(1), _trace(2)]
+    groups = aggregate_traces(traces)
+    g = groups[("fake", "easy")]
+    expected = sum(t.metrics["mean_step_reward"] for t in traces) / 2
+    assert abs(g["metrics"]["mean_step_reward"] - expected) < 1e-9
+
+
+def test_aggregate_empty_returns_empty():
+    assert aggregate_traces([]) == {}
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/runtime/test_aggregate.py -q`
+Expected: FAIL — `ModuleNotFoundError: No module named 'proteus.runtime.aggregate'`.
+
+- [ ] **Step 3: Write minimal implementation**
+
+Create `proteus/runtime/aggregate.py`:
+```python
+"""Aggregate SessionTraces by (model, difficulty) for the human-baseline harness.
+
+Pure functions only (no I/O), so the aggregation is headless-testable. The CLI
+`compare` command reads JSONL traces and renders the result of aggregate_traces.
+"""
+
+from __future__ import annotations
+
+from proteus.runtime.trace import SessionTrace
+
+
+def aggregate_traces(
+    traces: list[SessionTrace],
+) -> dict[tuple[str, str], dict]:
+    """Group traces by (model, difficulty) and average each metric.
+
+    Args:
+        traces: SessionTraces to aggregate (mixed models/difficulties OK).
+
+    Returns:
+        ``{(model, difficulty): {"n": int, "metrics": {key: mean_float}}}``.
+        Empty input returns an empty dict.
+    """
+    groups: dict[tuple[str, str], list[SessionTrace]] = {}
+    for t in traces:
+        groups.setdefault((t.model, t.difficulty), []).append(t)
+
+    result: dict[tuple[str, str], dict] = {}
+    for key, group in groups.items():
+        metric_keys: set[str] = set()
+        for t in group:
+            metric_keys.update(t.metrics)
+        means = {
+            k: sum(t.metrics.get(k, 0.0) for t in group) / len(group)
+            for k in sorted(metric_keys)
+        }
+        result[key] = {"n": len(group), "metrics": means}
+    return result
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `.venv/bin/python -m pytest tests/runtime/test_aggregate.py -q`
+Expected: PASS (3 tests). Then full suite: `.venv/bin/python -m pytest -q` → all pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add proteus/runtime/aggregate.py tests/runtime/test_aggregate.py
+git commit -m "feat(cp6): runtime.aggregate — pure (model,difficulty) trace aggregation"
+```
+
+---
+
+## Task 8: CLI `compare` subcommand
+
+**Files:**
+- Modify: `proteus/cli.py`
+- Test: `tests/cli/test_cli.py` (extend)
+
+- [ ] **Step 1: Write the failing test**
+
+Append to `tests/cli/test_cli.py`:
+```python
+def test_compare_aggregates_traces(tmp_path, capsys):
+    out = tmp_path / "runs.jsonl"
+    # Two fake-model traces at the same difficulty.
+    for seed in (1, 2):
+        main([
+            "run", "--scenario", "predator_evade", "--model", "fake:x",
+            "--seed", str(seed), "--play-turns", "4", "--no-probe", "--out", str(out),
+        ])
+    capsys.readouterr()  # drain
+    rc = main(["compare", str(out)])
+    text = capsys.readouterr().out
+    assert rc == 0
+    assert "fake" in text and "easy" in text
+    assert "n=2" in text
+    assert "motive_reading_accuracy" in text
+
+
+def test_compare_writes_summary_json(tmp_path):
+    import json
+
+    out = tmp_path / "runs.jsonl"
+    main([
+        "run", "--scenario", "predator_evade", "--model", "fake:x",
+        "--seed", "1", "--play-turns", "4", "--no-probe", "--out", str(out),
+    ])
+    summary = tmp_path / "summary.json"
+    rc = main(["compare", str(out), "--out", str(summary)])
+    assert rc == 0
+    data = json.loads(summary.read_text())
+    assert data  # non-empty aggregate
+
+
+def test_compare_missing_file_errors(capsys):
+    rc = main(["compare", "/no/such/file.jsonl"])
+    assert rc == 2
+    assert "not found" in capsys.readouterr().err
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/bin/python -m pytest tests/cli/test_cli.py::test_compare_aggregates_traces -q`
+Expected: FAIL — argparse rejects the unknown `compare` subcommand.
+
+- [ ] **Step 3: Write minimal implementation**
+
+In `proteus/cli.py`, add the handler (after `_cmd_replay`):
+```python
+def _cmd_compare(args: argparse.Namespace) -> int:
+    import json
+
+    from proteus.runtime.aggregate import aggregate_traces
+
+    all_traces = []
+    for path in args.trace_files:
+        try:
+            all_traces.extend(read_traces(path))
+        except FileNotFoundError:
+            print(f"trace file not found: {path}", file=sys.stderr)
+            return 2
+    if not all_traces:
+        print("no traces to compare", file=sys.stderr)
+        return 1
+
+    groups = aggregate_traces(all_traces)
+    for (model, difficulty), info in sorted(groups.items()):
+        print(f"=== model={model} difficulty={difficulty} n={info['n']} ===")
+        for key, mean in info["metrics"].items():
+            print(f"  {key}: {mean:.2f}")
+
+    if args.out:
+        serializable = {
+            f"{model}|{difficulty}": info
+            for (model, difficulty), info in groups.items()
+        }
+        with open(args.out, "w") as fh:
+            json.dump(serializable, fh, indent=2)
+        print(f"summary written to {args.out}")
+    return 0
+```
+In `build_parser()`, register the subcommand (after the `replay` block):
+```python
+    compare = sub.add_parser(
+        "compare", help="aggregate traces by (model, difficulty) for baseline comparison"
+    )
+    compare.add_argument("trace_files", nargs="+", help="one or more .jsonl trace files")
+    compare.add_argument(
+        "--out", default=None, help="optional JSON file to write the aggregate summary to"
+    )
+    compare.set_defaults(func=_cmd_compare)
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `.venv/bin/python -m pytest tests/cli/test_cli.py -q`
+Expected: PASS (all CLI tests + the three new compare tests). Then full suite: `.venv/bin/python -m pytest -q` → all pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add proteus/cli.py tests/cli/test_cli.py
+git commit -m "feat(cp6): CLI compare — aggregate human/LLM traces by (model, difficulty)"
+```
+
+---
+
+## Task 9: Full-suite verification + per-difficulty demo + HANDOFF
+
+- [ ] **Step 1: Run the complete offline suite**
+
+Run: `.venv/bin/python -m pytest -q`
+Expected: ALL pass (103 baseline + all CP6 additions), no network, no display.
+
+- [ ] **Step 2: Per-difficulty smoke (deterministic, offline)**
+
+Run:
+```bash
+for d in easy medium hard expert; do
+  .venv/bin/python -m proteus run --scenario predator_evade --model fake:demo \
+    --difficulty $d --seed 42 --play-turns 6 --no-probe --out runs/cp6_$d.jsonl
+done
+.venv/bin/python -m proteus compare runs/cp6_easy.jsonl runs/cp6_medium.jsonl \
+  runs/cp6_hard.jsonl runs/cp6_expert.jsonl --out runs/cp6_summary.json
+```
+Expected: each `run` prints a summary line for its difficulty; `compare` prints four `model=demo difficulty=<band> n=1` groups with the new metric means (including `away_move_fraction`, `trajectory_agreement`, `final_distance_gap`) and writes `runs/cp6_summary.json`.
+
+- [ ] **Step 3: Verify the diagnostic invariant holds per band (acceptance)**
+
+Run:
+```bash
+.venv/bin/python -c "
+import random
+from proteus.grid.difficulty import Difficulty
+from proteus.grid.game import MotiveGridGame
+from proteus.grid.scenario import get_scenario
+for d in Difficulty:
+    s = get_scenario('predator_evade')()
+    g = MotiveGridGame(s, random.Random(42), d, max_steps=40)
+    for _ in range(s.cut_length(d)):
+        a = s.cut_focal_policy(g); g.apply_motive_action(a); s.record_focal_move(a)
+    o, h = s.optimal_action(g), s.habit_action(g)
+    assert o != h, f'{d}: optimal {o} == habit {h}'
+    print(f'{d.value}: optimal={o} habit={h} grid={g.current_grid().shape} OK')
+"
+```
+Expected: prints `OK` for all four bands (optimal != habit each).
+
+- [ ] **Step 4: Update HANDOFF.md (CP6 close)**
+
+Edit `HANDOFF.md`:
+- Update "Last updated" to today, "CP6 complete".
+- Add a "Done (CP6)" section: per-difficulty hand-authored layouts (EASY unchanged), scenario-owned `step_reward` (survival = away-from-predator reward) replacing the generic schedule, `runtime/rollout.py` optimal-trajectory simulator, four new metrics, `proteus compare` harness. Record the acceptance result from Steps 2–3 and the new full-suite count.
+- Move "Next" to CP7 (new motive categories/scenarios — the `step_reward` interface is now open; web UI still deferred).
+- Resolve the `record_focal_move`-on-ABC and (if addressed) the metric-key deferred items; carry forward the still-open `--png`-without-viz-extra and `first_divergence_turn` items.
+
+Then commit:
+```bash
+git add HANDOFF.md
+git commit -m "docs(cp6): handoff close — difficulty layouts + category eval + compare shipped; CP7 next"
+```
+
+---
+
+## Self-Review (completed by plan author)
+
+**Spec coverage:**
+- §4 (Section A difficulty layouts) → Tasks 1 (ABC + threading), 2 (layout table + dispatch), 3 (per-band invariant). `record_focal_move` ABC default → Task 1.
+- §5 (Section B category eval) → Task 4 (`step_reward` survival + `safety_distance`), Task 5 (optimal rollout), Task 6 (four metrics + wiring). Pre-move-position passing → Task 4 (uses the runner's already-captured `focal_pos`/`predator_pos`).
+- §6 (Section C harness) → Task 7 (`aggregate_traces`), Task 8 (`compare` CLI).
+- §7.4 completion criteria → Task 9 (full suite + per-difficulty demo + invariant acceptance).
+
+**Placeholder scan:** No TBD/TODO. The layout coordinates in Task 2 are concrete candidates; Task 3 makes the golden invariant the oracle with an explicit tuning procedure (not a placeholder — the test defines done). The reward-constant magnitudes are concrete; the property test pins the signs.
+
+**Type consistency:** `step_reward(game, action, blocked, focal_before, predator_before) -> float` is identical across the ABC (Task 4), predator_evade (Task 4), the SessionRunner call (Task 4), and the unit test (Task 4). `RolloutResult(focal_positions, final_safety_distance)` defined in Task 5 is consumed identically in Task 6's `compute_metrics` wiring. `compute_metrics(..., optimal_focal_positions, realized_final_safety, optimal_final_safety)` defined in Task 6 matches its test. `aggregate_traces(traces) -> {(model,difficulty): {"n", "metrics"}}` defined in Task 7 matches the CLI consumer (Task 8) and tests. `safety_distance(game) -> int|None` is consistent across the ABC default (Task 1), predator_evade (Task 4), rollout (Task 5), and session wiring (Task 6).
+
+**Known additive churn (flagged in-task):** `test_integration_golden.py` / `test_session.py` pin exact reward values (Task 4) and the metrics dict (Task 6); both tasks instruct updating the expected values to the new correct numbers without weakening assertions.