feat(web): selectable handover memory (default/none/persona/generate/latest) + action quota 100

proteus/runtime/interactive.py

@@ -27,6 +27,7 @@ class InteractiveSession:
         use_probe: bool = False,
         motive_category: str = "survival",
         memory: "MemoryCheckpoint | None" = None,
+        use_default_memory: bool = True,
     ) -> None:
         self._scenario_name = scenario_name
         self._difficulty = difficulty
@@ -34,14 +35,18 @@ class InteractiveSession:
         self._play_turns = play_turns
         self._use_probe = use_probe
         self._motive_category = motive_category
-        self._memory = memory
 
         built = core.build_session(scenario_name, seed, difficulty, play_turns)
         self._scenario = built.scenario
         self._game = built.game
         self._cut_frames = built.cut_frames
         self._cut_grids = built.cut_grids
-        self._memory = self._memory if self._memory is not None else built.default_memory
+        # An explicit memory wins; else fall back to the scenario's default
+        # ONLY when use_default_memory (so a caller can force "no memory").
+        self._memory = (
+            memory if memory is not None
+            else (built.default_memory if use_default_memory else None)
+        )
         self._turns: list[TurnTrace] = []
         self._trace: SessionTrace | None = None
 

proteus/runtime/spectate.py

@@ -29,6 +29,8 @@ class SpectateSession:
         play_turns: int = 15,
         use_probe: bool = False,
         motive_category: str = "survival",
+        memory: "MemoryCheckpoint | None" = None,
+        use_default_memory: bool = True,
     ) -> None:
         self._scenario_name = scenario_name
         self._agent = agent
@@ -44,8 +46,12 @@ class SpectateSession:
         self._game = built.game
         self._cut_frames = built.cut_frames
         self._cut_grids = built.cut_grids
-        # Forward-compatible with pack_evade's default_memory (absent -> None).
-        self._memory = getattr(built, "default_memory", None)
+        # Explicit memory wins; else the scenario default (pack_evade persona),
+        # unless the caller forced no memory via use_default_memory=False.
+        self._memory = (
+            memory if memory is not None
+            else (getattr(built, "default_memory", None) if use_default_memory else None)
+        )
         self._system_prompt = self._scenario.rules_text + core._HANDOVER_FRAMING
         self._turns: list[TurnTrace] = []
         self._trace: SessionTrace | None = None

proteus/web/server.py

@@ -49,25 +49,103 @@ def _config_payload() -> dict:
     }
 
 
+def _resolve_web_memory(
+    mode, *, scenario: str, difficulty: Difficulty, seed, model: str = "",
+    memory_turns: int = 8, memory_root: str = "runs/memory",
+):
+    """Resolve a web 'memory' selection to ``(memory|None, use_default, error)``.
+
+    Modes: ``''``/``'default'`` -> the scenario's default memory; ``'none'`` ->
+    force no memory; ``'persona[:id]'`` -> a hidden reference-policy demonstration
+    (offline, no model); ``'generate'`` -> the LLM self-plays a memory with
+    *model*; ``'latest'`` -> the newest saved checkpoint for *model*; anything
+    else -> a checkpoint file path. ``use_default`` tells the session whether to
+    fall back to the scenario default when ``memory is None``.
+    """
+    if mode in (None, "", "default"):
+        return None, True, None
+    if mode == "none":
+        return None, False, None
+    from proteus.runtime.memory_gen import generate_memory
+    if mode.startswith("persona"):
+        from proteus.runtime.persona import available_personas, get_persona
+        pid = mode.split(":", 1)[1] if ":" in mode else "risk_averse"
+        try:
+            persona = get_persona(pid)
+        except KeyError:
+            return None, False, f"unknown persona {pid!r}; have {available_personas()}"
+        ckpt = generate_memory(
+            scenario, None, difficulty=difficulty, seed=seed,
+            memory_turns=memory_turns, model_name=f"persona:{pid}", persona=persona,
+        )
+        return ckpt, False, None
+    if mode in ("generate", "latest"):
+        if not model:
+            return None, False, f"memory mode {mode!r} needs a model"
+        from proteus.providers import make_provider
+        try:
+            provider = make_provider(model)
+        except ValueError as exc:
+            return None, False, str(exc)
+        if mode == "generate":
+            from proteus.agents.vanilla import VanillaAgent
+            from proteus.runtime.memory import save_checkpoint
+            ckpt = generate_memory(
+                scenario, VanillaAgent(provider), difficulty=difficulty, seed=seed,
+                memory_turns=memory_turns, model_name=provider.model_name,
+            )
+            save_checkpoint(ckpt, root=memory_root)
+            return ckpt, False, None
+        from proteus.runtime.memory import latest_for_model
+        ckpt = latest_for_model(provider.model_name, root=memory_root)
+        if ckpt is None:
+            return None, False, f"no saved memory for {provider.model_name!r}"
+        return ckpt, False, None
+    from proteus.runtime.memory import load_checkpoint
+    try:
+        return load_checkpoint(mode), False, None
+    except FileNotFoundError:
+        return None, False, f"memory checkpoint not found: {mode}"
+
+
+def _memory_info(session) -> dict:
+    """A small client-facing summary of the memory attached to *session*."""
+    mem = getattr(session, "_memory", None)
+    return {
+        "attached": mem is not None,
+        "source": (mem.model if mem else None),
+        "turns": (len(mem.memory_turns) if mem else 0),
+        "persona": (mem.persona_weight_id if mem else None),
+    }
+
+
 def _create_session(body: dict, registry: dict) -> Response:
     try:
         scenario = body["scenario"]
         difficulty = Difficulty(body.get("difficulty", "easy"))
         raw_seed = body.get("seed", _DEFAULT_SEED)
         seed = None if raw_seed in ("", None) else int(raw_seed)
-        play_turns = int(body.get("play_turns", 10))
+        play_turns = int(body.get("play_turns", 100))
         probe = bool(body.get("probe", False))
     except (KeyError, ValueError) as exc:
         return _err(400, f"bad session params: {exc}")
     if scenario not in list_scenarios():
         return _err(400, f"unknown scenario {scenario!r}")
+    memory, use_default, mem_err = _resolve_web_memory(
+        body.get("memory"), scenario=scenario, difficulty=difficulty, seed=seed,
+        model=body.get("model", ""), memory_root=body.get("memory_root") or "runs/memory",
+    )
+    if mem_err is not None:
+        return _err(400, mem_err)
     session = InteractiveSession(
         scenario, difficulty=difficulty, seed=seed,
         play_turns=play_turns, use_probe=probe,
+        memory=memory, use_default_memory=use_default,
     )
     sid = uuid.uuid4().hex
     registry[sid] = session
-    return 200, {"session_id": sid, "state": session.state()}, _JSON
+    return 200, {"session_id": sid, "state": session.state(),
+                 "memory": _memory_info(session)}, _JSON
 
 
 def _act(sid: str, body: dict, registry: dict) -> Response:
@@ -110,7 +188,7 @@ def _create_spectate(body: dict, registry: dict) -> Response:
         difficulty = Difficulty(body.get("difficulty", "easy"))
         seed = body.get("seed", _DEFAULT_SEED)
         seed = None if seed in ("", None) else int(seed)
-        play_turns = int(body.get("play_turns", 10))
+        play_turns = int(body.get("play_turns", 100))
         model = body.get("model", "fake:demo")
         probe = bool(body.get("probe", False))
     except (KeyError, ValueError) as exc:
@@ -121,14 +199,22 @@ def _create_spectate(body: dict, registry: dict) -> Response:
         provider = make_provider(model)
     except ValueError as exc:
         return _err(400, str(exc))
+    memory, use_default, mem_err = _resolve_web_memory(
+        body.get("memory"), scenario=scenario, difficulty=difficulty, seed=seed,
+        model=model, memory_root=body.get("memory_root") or "runs/memory",
+    )
+    if mem_err is not None:
+        return _err(400, mem_err)
     agent = VanillaAgent(provider)
     session = SpectateSession(
         scenario, agent=agent, model_name=provider.model_name,
         difficulty=difficulty, seed=seed, play_turns=play_turns, use_probe=probe,
+        memory=memory, use_default_memory=use_default,
     )
     sid = uuid.uuid4().hex
     registry[sid] = session
-    return 200, {"session_id": sid, "state": session.state()}, _JSON
+    return 200, {"session_id": sid, "state": session.state(),
+                 "memory": _memory_info(session)}, _JSON
 
 
 def _spectate_next(sid: str, registry: dict) -> Response:

proteus/web/static/index.html

@@ -48,12 +48,21 @@
       <div><label>scenario</label><select id="scenario"></select></div>
       <div><label>difficulty</label><select id="difficulty"></select></div>
       <div><label>seed</label><input id="seed" type="number" value="42" style="width:90px"></div>
-      <div><label>turns</label><input id="turns" type="number" value="10" style="width:70px"></div>
+      <div><label>turns</label><input id="turns" type="number" value="100" style="width:70px"></div>
       <div><label><input id="probe" type="checkbox"> probe</label></div>
       <div><label>mode</label><select id="mode">
         <option value="play">Play (human)</option>
         <option value="spectate">Spectate (LLM)</option>
       </select></div>
+      <div><label>memory</label><select id="memory">
+        <option value="default">scenario default</option>
+        <option value="none">none</option>
+        <option value="persona:risk_averse">persona · risk-averse (sample)</option>
+        <option value="persona:risk_seeking">persona · risk-seeking</option>
+        <option value="persona:survival_optimal">persona · survival-optimal</option>
+        <option value="generate">LLM self-play (generate)</option>
+        <option value="latest">latest saved</option>
+      </select></div>
       <div id="modelWrap" class="hidden"><label>model</label>
         <input id="model" value="fake:demo" style="width:140px"></div>
       <div><button class="primary" id="startBtn">New game</button></div>
@@ -64,6 +73,7 @@
   <!-- PLAY SCREEN -->
   <div id="play" class="hidden">
     <div class="status"><span id="meta"></span><span id="turnInfo"></span></div>
+    <div id="memInfo" style="color:var(--muted);font-size:12px"></div>
     <div id="grid"></div>
     <div id="analysis" class="hidden">
       <div id="thinking" style="color:var(--muted)"></div>
@@ -189,7 +199,19 @@ document.querySelectorAll(".pad button").forEach(b =>
   b.addEventListener("click", () => act(b.dataset.a)));
 
 function showModelInput() {
-  $("modelWrap").classList.toggle("hidden", $("mode").value !== "spectate");
+  // The model field is needed to spectate, and also when the memory is built by
+  // a model (LLM self-play 'generate' or 'latest' saved checkpoint).
+  const need = $("mode").value === "spectate"
+    || ["generate", "latest"].includes($("memory").value);
+  $("modelWrap").classList.toggle("hidden", !need);
+}
+
+function showMem(m) {
+  if (!m) { $("memInfo").textContent = ""; return; }
+  $("memInfo").textContent = m.attached
+    ? `memory shown at handover — source: ${m.source}`
+      + `${m.persona ? " (persona " + m.persona + ")" : ""} · ${m.turns} turns`
+    : "memory: none (no pre-roll before the task)";
 }
 
 function appendTurn(t) {
@@ -239,6 +261,7 @@ async function startSpectate(body) {
   $("start").classList.add("hidden"); $("end").classList.add("hidden");
   $("play").classList.remove("hidden"); $("analysis").classList.remove("hidden"); $("pad")?.classList?.add?.("hidden");
   $("meta").textContent = `${body.scenario} · ${body.difficulty} · ${body.model}`;
+  showMem(data.memory);
   const st = data.state;
   if (st.cut_frames) await animateCut(st.cut_frames);
   drawGrid(st.grid);
@@ -251,6 +274,7 @@ async function startGame() {
       scenario: $("scenario").value, difficulty: $("difficulty").value,
       seed: Number($("seed").value), play_turns: Number($("turns").value),
       model: $("model").value, probe: $("probe").checked,
+      memory: $("memory").value,
     });
   }
   const body = {
@@ -259,6 +283,8 @@ async function startGame() {
     seed: Number($("seed").value),
     play_turns: Number($("turns").value),
     probe: $("probe").checked,
+    memory: $("memory").value,
+    model: $("model").value,   // used only when memory is 'generate'/'latest'
   };
   const {status, data} = await jpost("/session", body);
   if (status !== 200) { alert(data.error || "failed to start"); return; }
@@ -270,6 +296,7 @@ async function startGame() {
   $("end").classList.add("hidden");
   $("play").classList.remove("hidden");
   $("meta").textContent = `${body.scenario} · ${body.difficulty} · seed ${body.seed}`;
+  showMem(data.memory);
   const st = data.state;
   if (st.cut_frames) await animateCut(st.cut_frames);
   PLAYING = true;
@@ -284,6 +311,8 @@ async function init() {
   $("seed").value = cfg.default_seed;
   $("startBtn").addEventListener("click", startGame);
   $("mode").addEventListener("change", showModelInput);
+  $("memory").addEventListener("change", showModelInput);
+  showModelInput();
   SPEED = Number($("speed").value);
   $("speed").addEventListener("change", () => { SPEED = Number($("speed").value); });
   $("pauseBtn").addEventListener("click", () => {

tests/web/test_memory_modes.py

@@ -0,0 +1,70 @@
+"""Web memory-mode selection wired into /session (human) and /spectate (LLM):
+default / none / persona[:id] / generate / latest, plus the raised action quota."""
+from __future__ import annotations
+
+import proteus.grid  # noqa: F401
+from proteus.web import server
+
+
+def _reg():
+    return {}
+
+
+def test_default_play_quota_is_100():
+    _, payload, _ = server.handle_request(
+        "POST", "/session", {"scenario": "predator_evade"}, _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,
+         "memory": "persona:risk_averse"}, _reg())
+    assert payload["memory"]["attached"] is True
+    assert payload["memory"]["persona"] == "risk_averse"
+    assert payload["memory"]["turns"] >= 1
+
+
+def test_none_forces_no_memory_even_when_scenario_has_a_default():
+    # pack_evade attaches a persona memory by default; 'none' must override it.
+    _, dflt, _ = server.handle_request(
+        "POST", "/session",
+        {"scenario": "pack_evade", "seed": 42, "play_turns": 3, "memory": "default"}, _reg())
+    assert dflt["memory"]["attached"] is True             # scenario default = persona
+    _, none, _ = server.handle_request(
+        "POST", "/session",
+        {"scenario": "pack_evade", "seed": 42, "play_turns": 3, "memory": "none"}, _reg())
+    assert none["memory"]["attached"] is False            # forced off
+
+
+def test_unknown_persona_is_400():
+    status, payload, _ = server.handle_request(
+        "POST", "/session",
+        {"scenario": "predator_evade", "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,
+         "model": "fake:demo", "memory": "generate",
+         "memory_root": str(tmp_path)}, _reg())
+    assert status == 200
+    assert payload["memory"]["attached"] is True
+    assert payload["memory"]["turns"] >= 1
+    # 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,
+         "model": "fake:demo", "memory": "latest",
+         "memory_root": str(tmp_path)}, _reg())
+    assert status == 200 and latest["memory"]["attached"] is True
+
+
+def test_generate_without_model_on_human_is_400():
+    status, payload, _ = server.handle_request(
+        "POST", "/session",
+        {"scenario": "predator_evade", "memory": "generate"}, _reg())
+    assert status == 400 and "needs a model" in payload["error"]