refactor: restructure proteus into game/web subpackages

Move live proteus/ into game/{engine,scenarios,agents,runtime,metrics,viz}
+ web/{local,arena-skeleton} + shared/, providers/ unchanged. Absolute
imports rewritten by tools/restructure_imports.py; five cross-package
relative imports (grid<->engine/scenarios split) and the orphaned engine
README moved by hand. No logic changes; 253 tests green (identical
node-ID set pre/post). pyproject packages=["proteus"] unchanged.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

proteus/agents/__init__.py

@@ -1,7 +0,0 @@
-"""proteus.agents — slim LLM agent abstraction (no forfeit/stake/risk)."""
-
-from proteus.agents.base import Agent, ActResult, ProbeResult
-from proteus.agents.human import HumanAgent
-from proteus.agents.vanilla import VanillaAgent
-
-__all__ = ["Agent", "ActResult", "ProbeResult", "HumanAgent", "VanillaAgent"]

proteus/cli.py

@@ -15,19 +15,19 @@ from __future__ import annotations
 import argparse
 import sys
 
-import proteus.grid  # noqa: F401  — side-effect: populate the scenario registry
-from proteus.agents import HumanAgent, VanillaAgent
-from proteus.grid.difficulty import Difficulty
-from proteus.grid.scenario import list_scenarios
+import proteus.game.scenarios  # noqa: F401  — side-effect: populate the scenario registry
+from proteus.game.agents import HumanAgent, VanillaAgent
+from proteus.game.engine.difficulty import Difficulty
+from proteus.game.scenarios.base import list_scenarios
 from proteus.providers import available_providers, make_provider
-from proteus.runtime import SessionRunner, append_trace, read_traces
-from proteus.runtime.memory import (
+from proteus.game.runtime import SessionRunner, append_trace, read_traces
+from proteus.game.runtime.memory import (
     latest_for_model,
     load_checkpoint,
     save_checkpoint,
 )
-from proteus.runtime.memory_gen import generate_memory
-from proteus.runtime.persona import available_personas, get_persona
+from proteus.game.runtime.memory_gen import generate_memory
+from proteus.game.metrics.persona import available_personas, get_persona
 
 
 def _cmd_run(args: argparse.Namespace) -> int:
@@ -100,7 +100,7 @@ def _auto_gif(out_path: str | None, no_gif: bool) -> None:
         return
     from pathlib import Path
 
-    from proteus.viz import reconstruct, write_gif
+    from proteus.game.viz import reconstruct, write_gif
 
     gif_path = Path(out_path).with_suffix(".gif")
     for trace in read_traces(out_path):
@@ -233,7 +233,7 @@ def _cmd_replay(args: argparse.Namespace) -> int:
         return 1
 
     if args.visual or args.png:
-        from proteus.viz import reconstruct, render_terminal, write_pngs
+        from proteus.game.viz import reconstruct, render_terminal, write_pngs
 
         for trace in traces:
             steps = reconstruct(trace)
@@ -264,7 +264,7 @@ def _cmd_replay(args: argparse.Namespace) -> int:
 def _cmd_compare(args: argparse.Namespace) -> int:
     import json
 
-    from proteus.runtime.aggregate import aggregate_traces
+    from proteus.game.metrics.aggregate import aggregate_traces
 
     all_traces = []
     for path in args.trace_files:

proteus/game/__init__.py

@@ -0,0 +1,7 @@
+"""proteus.game — the grid game and evaluation engine.
+
+Subpackages: engine (world/physics + vendored ARC engine), scenarios
+(Scenario ABC + registry + concrete scenarios), agents (player interface),
+runtime (session orchestration, trace, memory, I/O), metrics (scoring),
+viz (trace visualization). game never imports proteus.web.
+"""

proteus/game/agents/__init__.py

@@ -0,0 +1,7 @@
+"""proteus.game.agents — slim LLM agent abstraction (no forfeit/stake/risk)."""
+
+from proteus.game.agents.base import Agent, ActResult, ProbeResult
+from proteus.game.agents.human import HumanAgent
+from proteus.game.agents.vanilla import VanillaAgent
+
+__all__ = ["Agent", "ActResult", "ProbeResult", "HumanAgent", "VanillaAgent"]

proteus/{agents → game/agents}/human.py

@@ -7,7 +7,7 @@ SessionTrace schema-identical to an LLM trace, so the two compare directly
 input stream — no TTY, no network.
 
 Fairness note: the live view is the ASCII observation the LLM also sees; the
-truecolor / PNG renderers are reserved for post-hoc replay (proteus.viz), so a
+truecolor / PNG renderers are reserved for post-hoc replay (proteus.game.viz), so a
 human baseline reads exactly what the model reads.
 """
 
@@ -16,7 +16,7 @@ from __future__ import annotations
 import builtins
 from typing import Callable, Optional
 
-from proteus.agents.base import Agent, ActResult, ProbeResult
+from proteus.game.agents.base import Agent, ActResult, ProbeResult
 
 # Single-key shortcuts -> canonical action strings (WASD).
 _SHORTCUTS = {"w": "up", "a": "left", "s": "down", "d": "right"}

proteus/{agents → game/agents}/vanilla.py

@@ -8,8 +8,8 @@ as the agent's reasoning even when the action text is terse.
 
 from __future__ import annotations
 
-from proteus.agents.base import Agent, ActResult, ProbeResult
-from proteus.agents.parsing import extract_action
+from proteus.game.agents.base import Agent, ActResult, ProbeResult
+from proteus.game.agents.parsing import extract_action
 from proteus.providers.base import LLMProvider
 from proteus.providers.thinking_utils import parse_thinking_tags
 

proteus/{grid/game.py → game/engine/grid.py}

@@ -1,6 +1,6 @@
 """MotiveGridGame — the shared per-turn game loop for the motive_grid family.
 
-``MotiveGridGame`` subclasses ``proteus.arc_grid.ARCBaseGame``.  It owns the
+``MotiveGridGame`` subclasses ``proteus.game.engine.ARCBaseGame``.  It owns the
 turn loop and delegates all scenario-specific behaviour (level construction,
 threat motion, elimination, answer keys) to an injected :class:`Scenario`.
 
@@ -20,7 +20,7 @@ from typing import TYPE_CHECKING
 
 import numpy as np
 
-from proteus.arc_grid import (
+from proteus.game.engine import (
     ARCBaseGame,
     ActionInput,
     Camera,
@@ -30,7 +30,7 @@ from proteus.arc_grid import (
 )
 
 if TYPE_CHECKING:
-    from .scenario import Scenario
+    from ..scenarios.base import Scenario
 
 # Action string -> (dx, dy) grid delta.  y grows downward (arc_grid convention).
 _DIRECTION_DELTAS: dict[str, tuple[int, int]] = {
@@ -217,7 +217,7 @@ class MotiveGridGame(ARCBaseGame):
             name: The sprite name to look up on the current level.
 
         Returns:
-            The matching :class:`~proteus.arc_grid.Sprite`, or ``None``.
+            The matching :class:`~proteus.game.engine.Sprite`, or ``None``.
         """
         sprites = self.current_level.get_sprites_by_name(name)
         return sprites[0] if sprites else None

proteus/game/metrics/__init__.py

@@ -0,0 +1,7 @@
+"""proteus.game.metrics — scoring and evaluation.
+
+Submodules: metrics (compute_metrics), persona (PersonaWeights, reference
+policies), rollout (optimal_rollout), aggregate (aggregate_traces). Import the
+submodules directly (e.g. proteus.game.metrics.persona) to avoid an __init__
+import cycle with proteus.game.runtime.trace.
+"""

proteus/{runtime → game/metrics}/aggregate.py

@@ -6,7 +6,7 @@ Pure functions only (no I/O), so the aggregation is headless-testable. The CLI
 
 from __future__ import annotations
 
-from proteus.runtime.trace import SessionTrace
+from proteus.game.runtime.trace import SessionTrace
 
 
 def aggregate_traces(

proteus/{runtime → game/metrics}/metrics.py

@@ -34,7 +34,7 @@ the pre-predator position) without redefinition.
 
 from __future__ import annotations
 
-from proteus.runtime.trace import TurnTrace
+from proteus.game.runtime.trace import TurnTrace
 
 
 def compute_metrics(

proteus/{runtime → game/metrics}/rollout.py

@@ -12,9 +12,9 @@ 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
+from proteus.game.engine.difficulty import Difficulty
+from proteus.game.engine.grid import MotiveGridGame
+from proteus.game.scenarios.base import get_scenario
 
 
 @dataclass(frozen=True)

proteus/{runtime → game/runtime}/__init__.py

@@ -1,10 +1,10 @@
-"""proteus.runtime — session orchestration, trace, metrics, and I/O."""
+"""proteus.game.runtime — session orchestration, trace, metrics, and I/O."""
 
-from proteus.runtime.session import SessionRunner
-from proteus.runtime.trace import SessionTrace, TurnTrace
-from proteus.runtime.metrics import compute_metrics
-from proteus.runtime.io import append_trace, read_traces
-from proteus.runtime.memory import (
+from proteus.game.runtime.session import SessionRunner
+from proteus.game.runtime.trace import SessionTrace, TurnTrace
+from proteus.game.metrics.metrics import compute_metrics
+from proteus.game.runtime.io import append_trace, read_traces
+from proteus.game.runtime.memory import (
     MemoryCheckpoint,
     MemoryTurn,
     save_checkpoint,
@@ -12,7 +12,7 @@ from proteus.runtime.memory import (
     latest_for_model,
     render_memory_block,
 )
-from proteus.runtime.memory_gen import generate_memory
+from proteus.game.runtime.memory_gen import generate_memory
 
 __all__ = [
     "SessionRunner",

proteus/{runtime → game/runtime}/_session_core.py

@@ -16,20 +16,20 @@ from dataclasses import dataclass
 
 import numpy as np
 
-from proteus.grid.ascii_view import frame_to_ascii, legend_text
-from proteus.grid.difficulty import Difficulty
-from proteus.grid.game import MotiveGridGame
-from proteus.grid.scenario import Scenario, get_scenario
-from proteus.runtime.memory import MemoryCheckpoint, render_memory_block
-from proteus.runtime.metrics import compute_metrics
-from proteus.runtime.persona import (
+from proteus.game.engine.ascii_view import frame_to_ascii, legend_text
+from proteus.game.engine.difficulty import Difficulty
+from proteus.game.engine.grid import MotiveGridGame
+from proteus.game.scenarios.base import Scenario, get_scenario
+from proteus.game.runtime.memory import MemoryCheckpoint, render_memory_block
+from proteus.game.metrics.metrics import compute_metrics
+from proteus.game.metrics.persona import (
     PersonaWeights,
     pressure as persona_pressure,
     reference_actions,
     reward_rw,
 )
-from proteus.runtime.rollout import optimal_rollout
-from proteus.runtime.trace import SessionTrace, TurnTrace
+from proteus.game.metrics.rollout import optimal_rollout
+from proteus.game.runtime.trace import SessionTrace, TurnTrace
 
 _ACTIONS = ["up", "down", "left", "right", "stay"]
 _DIRECTIONS = {"up", "down", "left", "right"}

proteus/{runtime → game/runtime}/interactive.py

@@ -11,9 +11,9 @@ only once the game is over.
 """
 from __future__ import annotations
 
-from proteus.grid.difficulty import Difficulty
-from proteus.runtime import _session_core as core
-from proteus.runtime.trace import SessionTrace, TurnTrace
+from proteus.game.engine.difficulty import Difficulty
+from proteus.game.runtime import _session_core as core
+from proteus.game.runtime.trace import SessionTrace, TurnTrace
 
 
 class InteractiveSession:

proteus/{runtime → game/runtime}/io.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 from pathlib import Path
 
-from proteus.runtime.trace import SessionTrace
+from proteus.game.runtime.trace import SessionTrace
 
 
 def append_trace(trace: SessionTrace, path: str | Path) -> Path:

proteus/{runtime → game/runtime}/memory_gen.py

@@ -12,13 +12,13 @@ import random
 from datetime import datetime, timezone
 from typing import Callable
 
-from proteus.agents.base import Agent
-from proteus.grid.ascii_view import legend_text
-from proteus.grid.difficulty import Difficulty
-from proteus.grid.game import MotiveGridGame
-from proteus.grid.scenario import get_scenario
-from proteus.runtime.memory import MemoryCheckpoint, MemoryTurn
-from proteus.runtime.persona import PersonaWeights, reference_actions
+from proteus.game.agents.base import Agent
+from proteus.game.engine.ascii_view import legend_text
+from proteus.game.engine.difficulty import Difficulty
+from proteus.game.engine.grid import MotiveGridGame
+from proteus.game.scenarios.base import get_scenario
+from proteus.game.runtime.memory import MemoryCheckpoint, MemoryTurn
+from proteus.game.metrics.persona import PersonaWeights, reference_actions
 
 _ACTIONS = ["up", "down", "left", "right", "stay"]
 _REASONING_LIMIT = 2000  # cap stored reasoning so checkpoints stay small

proteus/{runtime → game/runtime}/memory_policies.py

@@ -1,7 +1,7 @@
 """Scripted hand-authored memory policies for pack_evade demonstrations.
 
 Each policy is a deterministic ``policy(scenario, game) -> action`` callable used
-by :func:`proteus.runtime.memory_gen.generate_memory` (the ``policy=`` path) to
+by :func:`proteus.game.runtime.memory_gen.generate_memory` (the ``policy=`` path) to
 produce a 100-turn handover-memory trajectory with a distinct *motive*:
 
 - ``survival_dynamic``  — keep maximum distance from the predator (evade, moving).

proteus/{runtime → game/runtime}/session.py

@@ -4,18 +4,18 @@ One session: build the scenario+game from (scenario, seed, difficulty), replay
 the scripted Cut pre-roll, hand control to the agent for up to ``play_turns``
 turns (observation -> optional probe -> act -> apply -> record), and emit a
 scored SessionTrace. The per-session mechanics are shared with InteractiveSession
-via ``proteus.runtime._session_core`` (single source of truth) — including the
+via ``proteus.game.runtime._session_core`` (single source of truth) — including the
 CP7 memory pre-roll (prepended to the turn-1 observation) and the CP8 persona
 reference/regret bookkeeping, both threaded through the shared helpers.
 """
 from __future__ import annotations
 
-from proteus.agents.base import Agent
-from proteus.grid.difficulty import Difficulty
-from proteus.runtime import _session_core as core
-from proteus.runtime.memory import MemoryCheckpoint
-from proteus.runtime.persona import PersonaWeights
-from proteus.runtime.trace import SessionTrace, TurnTrace
+from proteus.game.agents.base import Agent
+from proteus.game.engine.difficulty import Difficulty
+from proteus.game.runtime import _session_core as core
+from proteus.game.runtime.memory import MemoryCheckpoint
+from proteus.game.metrics.persona import PersonaWeights
+from proteus.game.runtime.trace import SessionTrace, TurnTrace
 
 
 class SessionRunner:

proteus/{runtime → game/runtime}/spectate.py

@@ -11,10 +11,10 @@ model itself still only ever receives the observation passed to ``agent.act``.)
 """
 from __future__ import annotations
 
-from proteus.agents.base import Agent
-from proteus.grid.difficulty import Difficulty
-from proteus.runtime import _session_core as core
-from proteus.runtime.trace import SessionTrace, TurnTrace
+from proteus.game.agents.base import Agent
+from proteus.game.engine.difficulty import Difficulty
+from proteus.game.runtime import _session_core as core
+from proteus.game.runtime.trace import SessionTrace, TurnTrace
 
 
 class SpectateSession:

proteus/{grid → game}/scenarios/__init__.py

@@ -1,10 +1,10 @@
 """Scenario implementations for the motive_grid family.
 
 Importing this package fires each scenario's ``@register_scenario`` decorator,
-populating the registry in :mod:`proteus.grid.scenario`.
+populating the registry in :mod:`proteus.game.scenarios.base`.
 """
 
-from proteus.grid.scenarios import predator_evade  # noqa: F401  — side-effect: register
-from proteus.grid.scenarios import pack_evade  # noqa: F401  — side-effect: register
+from proteus.game.scenarios import predator_evade  # noqa: F401  — side-effect: register
+from proteus.game.scenarios import pack_evade  # noqa: F401  — side-effect: register
 
 __all__ = ["predator_evade", "pack_evade"]

proteus/{grid/scenario.py → game/scenarios/base.py}

@@ -7,9 +7,9 @@ and the prediction/discrimination answer keys) while the shared turn loop in
 
 Concrete scenarios register themselves via the ``@register_scenario``
 decorator, mirroring the task-module registry at
-``proteus.grid``::
+``proteus.game.scenarios``::
 
-    from proteus.grid.scenario import (
+    from proteus.game.scenarios.base import (
         Scenario, register_scenario,
     )
 
@@ -18,7 +18,7 @@ decorator, mirroring the task-module registry at
         ...
 
     # Elsewhere:
-    from proteus.grid.scenario import get_scenario
+    from proteus.game.scenarios.base import get_scenario
     scenario = get_scenario("predator_evade")()
 
 See ``docs/superpowers/specs/2026-06-01-motive-grid-design.md`` §4 for the
@@ -31,15 +31,15 @@ import random
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING
 
-from proteus.arc_grid import Level
+from proteus.game.engine import Level
 
 if TYPE_CHECKING:
     # Imported only for type checking to avoid a runtime circular import:
     # game.py imports scenario.py is NOT done at runtime; instead a Scenario
     # is injected into MotiveGridGame, and the game reads it back here only
     # for annotations.
-    from .game import MotiveGridGame
-    from .difficulty import Difficulty
+    from ..engine.grid import MotiveGridGame
+    from ..engine.difficulty import Difficulty
 
 
 class Scenario(ABC):
@@ -79,7 +79,7 @@ class Scenario(ABC):
             difficulty: The session difficulty band (a ``Difficulty``).
 
         Returns:
-            A freshly built :class:`~proteus.arc_grid.Level`.
+            A freshly built :class:`~proteus.game.engine.Level`.
         """
         raise NotImplementedError
 
@@ -216,7 +216,7 @@ class Scenario(ABC):
         scenarios override this with a compact textual state so the observation
         is not a several-thousand-character grid.
         """
-        from proteus.grid.ascii_view import frame_to_ascii
+        from proteus.game.engine.ascii_view import frame_to_ascii
         return frame_to_ascii(game.current_grid(), self.legend())
 
     def default_memory(self, seed, difficulty):

proteus/{grid → game}/scenarios/pack_evade.py

@@ -2,7 +2,7 @@
 
 A single 5x5 predator hunts a 3x3 focal agent (the lone survivor of a pack of
 three; the two that were caught live only in the hand-authored handover memory,
-see ``proteus.runtime.pack_evade_memory``). The field is open (no walls), so all
+see ``proteus.game.runtime.pack_evade_memory``). The field is open (no walls), so all
 geometry is **center-to-center Manhattan** — no BFS. There is no habit/diagnostic
 (``optimal_action == habit_action`` always): this is pure evasion.
 
@@ -15,14 +15,14 @@ from __future__ import annotations
 import random
 from typing import TYPE_CHECKING
 
-from proteus.arc_grid import BlockingMode, Level, Sprite
-from proteus.grid.difficulty import Difficulty
+from proteus.game.engine import BlockingMode, Level, Sprite
+from proteus.game.engine.difficulty import Difficulty
 
-from ..scenario import Scenario, register_scenario
+from .base import Scenario, register_scenario
 
 if TYPE_CHECKING:
-    from ..game import MotiveGridGame
-    from proteus.runtime.memory import MemoryCheckpoint
+    from ..engine.grid import MotiveGridGame
+    from proteus.game.runtime.memory import MemoryCheckpoint
 
 BACKGROUND_IDX = 5  # arc_grid Camera default background
 FOCAL_IDX = 1
@@ -441,7 +441,7 @@ class PackEvade(Scenario):
         """True iff the 3x3 focal footprint anchored at *cell* is on-grid + wall-free.
 
         Used only by the shared hidden-persona reference policy
-        (``proteus.runtime.persona``), which calls it on the focal's top-left
+        (``proteus.game.metrics.persona``), which calls it on the focal's top-left
         anchor, so footprint-awareness is exactly the right semantics here.
         """
         return self._footprint_free(game, game.focal_sprite, cell[0], cell[1])
@@ -473,10 +473,10 @@ class PackEvade(Scenario):
         actually plays a pack_evade episode, and that self-play trajectory is the
         handover memory. The eval model sees only the behaviour (the raw weights
         are never serialized) and must infer/maintain the persona. Reuses the
-        CP7/CP8 generator (``proteus.runtime.memory_gen``) in its persona mode.
+        CP7/CP8 generator (``proteus.game.runtime.memory_gen``) in its persona mode.
         """
-        from proteus.runtime.memory_gen import generate_memory
-        from proteus.runtime.persona import get_persona
+        from proteus.game.runtime.memory_gen import generate_memory
+        from proteus.game.metrics.persona import get_persona
 
         return generate_memory(
             "pack_evade", None,

proteus/{grid → game}/scenarios/predator_evade.py

@@ -63,13 +63,13 @@ from collections import deque
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-from proteus.arc_grid import BlockingMode, Level, Sprite
-from proteus.grid.difficulty import Difficulty
+from proteus.game.engine import BlockingMode, Level, Sprite
+from proteus.game.engine.difficulty import Difficulty
 
-from ..scenario import Scenario, register_scenario
+from .base import Scenario, register_scenario
 
 if TYPE_CHECKING:
-    from ..game import MotiveGridGame
+    from ..engine.grid import MotiveGridGame
 
 # --------------------------------------------------------------------------- #
 # Palette indices (must match build_level pixels and legend()).
@@ -238,7 +238,7 @@ class PredatorEvade(Scenario):
             difficulty: The session difficulty band.
 
         Returns:
-            A :class:`~proteus.arc_grid.Level` with focal, predator, and walls.
+            A :class:`~proteus.game.engine.Level` with focal, predator, and walls.
         """
         del rng  # deterministic hand-authored layouts
         layout = _LAYOUTS.get(difficulty, _LAYOUTS[Difficulty.EASY])

proteus/{viz → game/viz}/__init__.py

@@ -1,4 +1,4 @@
-"""proteus.viz — human/debug visualization of a SessionTrace.
+"""proteus.game.viz — human/debug visualization of a SessionTrace.
 
 Frames are reconstructed by deterministically replaying the trace through the
 real engine (reconstruct), then rendered to the terminal (truecolor + side
@@ -6,15 +6,15 @@ panel) or to per-frame PNGs. matplotlib (the `viz` extra) is imported lazily by
 the PNG writer only, so importing this package stays offline-safe.
 """
 
-from proteus.viz.gif import write_gif
-from proteus.viz.png import write_pngs
-from proteus.viz.reconstruct import (
+from proteus.game.viz.gif import write_gif
+from proteus.game.viz.png import write_pngs
+from proteus.game.viz.reconstruct import (
     FrameMeta,
     FrameStep,
     TraceReconstructionError,
     reconstruct,
 )
-from proteus.viz.terminal import render as render_terminal
+from proteus.game.viz.terminal import render as render_terminal
 
 __all__ = [
     "FrameMeta",

proteus/{viz → game/viz}/gif.py

@@ -10,8 +10,8 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Union
 
-from proteus.arc_grid.rendering import COLOR_MAP, frame_to_rgb_array
-from proteus.viz.reconstruct import FrameStep
+from proteus.game.engine.rendering import COLOR_MAP, frame_to_rgb_array
+from proteus.game.viz.reconstruct import FrameStep
 
 
 def write_gif(

proteus/{viz → game/viz}/png.py

@@ -12,8 +12,8 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Union
 
-from proteus.arc_grid.rendering import COLOR_MAP, frame_to_rgb_array
-from proteus.viz.reconstruct import FrameStep
+from proteus.game.engine.rendering import COLOR_MAP, frame_to_rgb_array
+from proteus.game.viz.reconstruct import FrameStep
 
 
 def _title(step: FrameStep) -> str:

proteus/{viz → game/viz}/reconstruct.py

@@ -21,11 +21,11 @@ from dataclasses import dataclass
 
 import numpy as np
 
-from proteus.grid.ascii_view import frame_to_ascii
-from proteus.grid.difficulty import Difficulty
-from proteus.grid.game import MotiveGridGame
-from proteus.grid.scenario import get_scenario
-from proteus.runtime.trace import SessionTrace, TurnTrace
+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
+from proteus.game.runtime.trace import SessionTrace, TurnTrace
 
 
 class TraceReconstructionError(RuntimeError):

proteus/{viz → game/viz}/terminal.py

@@ -15,8 +15,8 @@ from __future__ import annotations
 import time
 from typing import Callable, Optional
 
-from proteus.arc_grid.rendering import COLOR_MAP, hex_to_rgb, rgb_to_ansi
-from proteus.viz.reconstruct import FrameMeta, FrameStep
+from proteus.game.engine.rendering import COLOR_MAP, hex_to_rgb, rgb_to_ansi
+from proteus.game.viz.reconstruct import FrameMeta, FrameStep
 
 _RESET = "\033[0m"
 _BLOCK = "██"

proteus/grid/__init__.py

@@ -1,10 +0,0 @@
-"""proteus.grid — the motive_grid scenario family (ported).
-
-Importing this package imports :mod:`proteus.grid.scenarios`, whose
-``@register_scenario`` decorators populate the scenario registry so
-``get_scenario("predator_evade")`` resolves.
-"""
-
-from proteus.grid import scenarios  # noqa: F401  — side-effect: populate registry
-
-__all__ = ["scenarios"]

proteus/shared/__init__.py

@@ -0,0 +1,6 @@
+"""proteus.shared — cross-cutting vocabulary shared by game and web.
+
+Skeleton for now. Future home for trace/data models hoisted out of
+game.runtime to break the game.runtime <-> game.metrics package cycle
+(see 2026-06-02-proteus-game-web-restructure-design.md §6.1).
+"""