Deploy Myco from CI

game/engine.py

@@ -1,35 +1,5 @@
-"""Core Myco gameplay — LLM is the primary game engine.
-Architecture overview
-─────────────────────
-  _get_model_and_tokenizer()   Lazy singleton loader. Runs once on CPU with
-                               bfloat16; ZeroGPU migrates weights at call time.
-  _run_pipeline()               @spaces.GPU entry-point. Only this function
-                               touches the GPU — never call model.to("cuda")
-                               anywhere else.
-  _llm()                        Single-turn game-event call. Appends
-                               JSON_PROMPT_SUFFIX so structured action data
-                               comes back reliably.
-  _llm_with_history()           Multi-turn chat call. No JSON forcing — Myco
-                               speaks naturally and ends with MOOD/EMOTION tags.
-  _parse_llm_output()           Splits every LLM reply into
-                               (visible_text, scene_mood, myco_emotion).
-                               engine.py stamps these onto `current` so
-                               renders.py can change the forest visuals without
-                               any extra Gradio state.
-Scene signal contract
-─────────────────────
-  Every public action returns `current` with two extra keys:
-    current["scene_mood"]    — one of: normal danger legendary rare
-                               excited afraid wonder
-    current["myco_emotion"]  — one of: curious excited nervous afraid
-                               wonder proud sad
-  renders.py reads these to pick background gradients, Myco's CSS animation,
-  and drop-shadow filter. Fallbacks always supply safe defaults so the UI
-  never breaks when the model is unavailable.
-Fallback chain
-──────────────
-  LLM unavailable / exception → _fallback_*() returns (text, mood, emotion)
-  so the game stays fully playable on CPU-only / cold-start environments.
+"""
+Core Myco gameplay — LLM is the primary game engine.
 """
 
 import os
@@ -38,132 +8,126 @@ import threading
 import re
 import json
 import traceback
+
+from game.catalog import load_mushrooms
+from game.state import collection_contains, mushroom_from_state, welcome_history
+
+
+import os
 import torch
 import spaces
 from transformers import AutoModelForCausalLM, AutoTokenizer
-from game.catalog import load_mushrooms
-from game.state import collection_contains, mushroom_from_state, welcome_history
 
-# ── Model config ─────────────────────────────────────────────────────────────
 DEFAULT_MODEL_ID = "google/gemma-3-1b-it"
 
-# Global singletons — loaded once, reused across every GPU call.
-_model     = None
+# Global singletons
+_model = None
 _tokenizer = None
-_lock      = threading.Lock()
+_lock = threading.Lock() # Ensure this matches your existing lock variable name
 
 def _get_model_and_tokenizer():
-    """
-    Double-checked singleton loader.
-    Loads on CPU with bfloat16 and device_map=None so ZeroGPU can hook the
-    model safely before migrating weights to the GPU inside _run_pipeline().
-    """
     global _model, _tokenizer
     if _model is not None and _tokenizer is not None:
         return _model, _tokenizer
+
     with _lock:
-        # Second check inside the lock to avoid a race on first load.
         if _model is not None and _tokenizer is not None:
             return _model, _tokenizer
-        model_id = os.getenv("MYCO_MODEL_ID", DEFAULT_MODEL_ID)
-        token    = os.getenv("HF_BUILD_SMALL_HACKATHON_TOKEN")
+
+        model_id = os.getenv("MYCO_MODEL_ID", "google/gemma-3-1b-it")
+        token = os.getenv("HF_BUILD_SMALL_HACKATHON_TOKEN")
+
         try:
-            print(f"\n[Myco] Loading model and tokenizer: {model_id} …")
+            print(f"\n[Myco] Loading model and tokenizer for {model_id}...")
+            
+            # Load tokenizer
             _tokenizer = AutoTokenizer.from_pretrained(model_id, token=token)
-            _model     = AutoModelForCausalLM.from_pretrained(
+            
+            # Load model strictly on CPU with bfloat16 precision
+            _model = AutoModelForCausalLM.from_pretrained(
                 model_id,
                 token=token,
                 torch_dtype=torch.bfloat16,
-                device_map=None,          # CRITICAL — let ZeroGPU own placement
-                trust_remote_code=True,
+                device_map=None, # CRITICAL: Must be None so ZeroGPU can hook it safely
+                trust_remote_code=True
             )
-            print(f"[Myco] Loaded: {model_id}")
+            print(f"[Myco] Successfully loaded: {model_id}")
             return _model, _tokenizer
         except Exception as exc:
             print(f"[Myco] Load error: {exc}")
-            traceback.print_exc()
             return None, None
 
+# ---------------------------------------------------------------------------
+# Pipeline loader
+# ---------------------------------------------------------------------------
 def _get_pipeline():
+    """ Legacy compatibility wrapper so companion_status() and other 
+    startup hooks don't throw a NameError.
     """
-    Legacy-compatibility shim.
-    Returns the model object (truthy) when loaded, None when not.
-    Keeps companion_status() and any startup checks working without changes.
-    """
-    model, _ = _get_model_and_tokenizer()
-    return model  # None when loading failed
-
-# ── GPU runner ────────────────────────────────────────────────────────────────
+    model, tokenizer = _get_model_and_tokenizer()
+    if model is not None and tokenizer is not None:
+        # Return the model instance so 'if pipe is not None' checks pass successfully
+        return model
+    return None
+
+# ---------------------------------------------------------------------------
+# GPU runner — ONLY this function gets the @spaces.GPU decorator.
+# ---------------------------------------------------------------------------
 @spaces.GPU
 def _run_pipeline(pipe_ignored, messages):
-    """
-    The ONLY function that executes on the GPU.
-    ZeroGPU's @spaces.GPU decorator migrates model weights here automatically —
-    never call model.to("cuda") manually anywhere else in this file.
-    Returns the raw decoded string (new tokens only, special tokens stripped).
-    """
+    # 1. Fetch our raw model and tokenizer singletons
     model, tokenizer = _get_model_and_tokenizer()
     if model is None or tokenizer is None:
         return "The forest is silent. (Model loading failed)"
-        
-    # Build the chat template the model expects (adds BOS, role tokens, etc.)
+
+    # CRITICAL: Do NOT call model.to("cuda") manually here. 
+    # ZeroGPU's @spaces.GPU decorator handles the weight migration automatically.
+
+    # 2. Build the chat template structure natively
     formatted_prompt = tokenizer.apply_chat_template(
-        messages,
-        tokenize=False,
-        add_generation_prompt=True,
+        messages, 
+        tokenize=False, 
+        add_generation_prompt=True
     )
-    
-    # Map inputs to whatever device ZeroGPU assigned the model weights to.
+
+    # 3. Tokenize and dynamically map inputs to the exact device the model is currently using
     inputs = tokenizer(formatted_prompt, return_tensors="pt").to(model.device)
+
+    # 4. Generate clean text without any configuration conflicts
     with torch.no_grad():
         outputs = model.generate(
             **inputs,
             max_new_tokens=256,
             do_sample=True,
             temperature=0.7,
-            pad_token_id=tokenizer.eos_token_id,
+            pad_token_id=tokenizer.eos_token_id
         )
-        
-    # Slice off the prompt tokens — return new content only.
-    input_length     = inputs.input_ids.shape[1]
+
+    # 5. Extract only the newly generated text tokens
+    input_length = inputs.input_ids.shape[1]
     generated_tokens = outputs[0][input_length:]
+    
     return tokenizer.decode(generated_tokens, skip_special_tokens=True)
 
-# ── Prompt constants ──────────────────────────────────────────────────────────
-# Appended to every single-turn game-event prompt so structured JSON comes back
-# reliably even from small models that don't always follow instructions.
+
 JSON_PROMPT_SUFFIX = (
     "\n\nRespond with a single JSON object only. No prose before or after it. "
     'Example: {"action":"pick","target":"Ruby Knuckle","thought":"It seems safe."}'
 )
 
-# ── Game constants ────────────────────────────────────────────────────────────
 RARITY_WEIGHTS = {"Common": 64, "Rare": 24, "Legendary": 8}
 RARITY_SCORE   = {"Common": 10, "Rare": 35, "Legendary": 100}
 PLAYER_HEALTH  = 3
 POISON_PENALTY = -25
 POISONOUS      = {"Ghost Gill", "Pepper Pixie", "Ruby Knuckle", "Clockwork Chanterelle"}
 
-# ── System prompt ─────────────────────────────────────────────────────────────
 SYSTEM_PROMPT = """You are Myco, a tiny sentient mushroom companion and forest guide.
 You are curious, warm, slightly anxious about poisonous mushrooms, and deeply connected
 to the forest mystery. You speak in short, vivid sentences. You never break character.
 You react emotionally to discoveries — with awe for Legendary mushrooms, caution for
 poisonous ones, and gentle wonder for Common ones. You hint at the deeper mystery of
-the vanished forest and the MycoDex that seems to remember things it shouldn't.
-
-SCENE SIGNAL (required at the end of EVERY reply)
-On its own line, write exactly:
-  MOOD:<mood>  EMOTION:<emotion>
-
-<mood>    — one of: normal  danger  legendary  rare  excited  afraid  wonder
-<emotion> — one of: curious  excited  nervous  afraid  wonder  proud  sad
-
-This controls the forest visuals in real time. Never omit it.
-Example final line:
-  MOOD:danger EMOTION:afraid"""
+the vanished forest and the MycoDex that seems to remember things it shouldn't."""
 
-# ── World / narrative data ────────────────────────────────────────────────────
 FOREST_EVENTS = [
     {"title": "A Quiet Clearing",   "emoji": "🌿", "mood": "calm"},
     {"title": "Wind Between Trees", "emoji": "🕯️", "mood": "afraid"},
@@ -183,140 +147,55 @@ RARITY_CLUES = {
     "Legendary": "The whole clearing goes quiet — this mushroom hides part of the Elder Map.",
 }
 
-# ── Scene-signal keyword maps ─────────────────────────────────────────────────
-# Used by _parse_llm_output() as a fallback when the model forgets to write the
-# MOOD/EMOTION line.  Keyword order matters — first match wins.
-MOOD_KEYWORDS: dict[str, list[str]] = {
-    "danger":    ["poison", "danger", "deadly", "toxic", "warning", "flee",
-                  "lethal", "fatal", "poisonous", "run", "back away"],
-    "legendary": ["legendary", "elder", "ancient", "map fragment", "awe",
-                  "impossible", "crown", "sacred", "silence"],
-    "rare":      ["rare", "magic", "hum", "glow", "shimmer", "strange",
-                  "silver spore", "faint magic"],
-    "excited":   ["found", "picked", "collect", "safe", "score", "hooray",
-                  "wonderful", "great", "yes!"],
-    "afraid":    ["afraid", "scared", "nervous", "dark", "shadow",
-                  "uneasy", "tremble", "shiver"],
-    "wonder":    ["beautiful", "glowing", "dream", "soft", "gentle",
-                  "serene", "extraordinary", "sparkling"],
-}
-
-EMOTION_KEYWORDS: dict[str, list[str]] = {
-    "afraid":   ["poison", "danger", "run", "flee", "deadly", "back away"],
-    "wonder":   ["legendary", "awe", "impossible", "sacred", "ancient"],
-    "excited":  ["hooray", "great", "score", "picked", "safe", "wonderful"],
-    "nervous":  ["nervous", "uneasy", "tremble", "shiver", "not sure"],
-    "sad":      ["sorry", "sad", "lost", "game over", "collapse", "goodbye"],
-    "proud":    ["proud", "strong", "brave", "victory", "warrior"],
-}
 
-# ── LLM output parser ─────────────────────────────────────────────────────────
-def _parse_llm_output(raw: str) -> tuple[str, str, str]:
-    """
-    Split a raw LLM reply into (visible_text, scene_mood, myco_emotion).
-    Primary path  — model wrote 'MOOD:x EMOTION:y' on the last line.
-    Fallback path — scan the full text with MOOD_KEYWORDS / EMOTION_KEYWORDS.
-    Always returns safe defaults so renders.py never KeyErrors.
-    """
-    if not raw:
-        return "", "normal", "curious"
-        
-    mood    = "normal"
-    emotion = "curious"
-    lines   = raw.strip().splitlines()
-    last    = lines[-1].strip() if lines else ""
-    
-    if "MOOD:" in last and "EMOTION:" in last:
-        # Happy path — model followed instructions.
-        for part in last.split():
-            if part.startswith("MOOD:"):
-                mood    = part[5:].strip().lower()
-            elif part.startswith("EMOTION:"):
-                emotion = part[8:].strip().lower()
-        visible = "\n".join(lines[:-1]).strip()
-    else:
-        # Fallback — keyword scan on the full text.
-        visible = raw.strip()
-        lower   = visible.lower()
-        for m, keywords in MOOD_KEYWORDS.items():
-            if any(k in lower for k in keywords):
-                mood = m
-                break
-        for e, keywords in EMOTION_KEYWORDS.items():
-            if any(k in lower for k in keywords):
-                emotion = e
-                break
-                
-    # Clamp to valid values so CSS dicts in renders.py never KeyError.
-    valid_moods    = {"normal", "danger", "legendary", "rare", "excited", "afraid", "wonder"}
-    valid_emotions = {"curious", "excited", "nervous", "afraid", "wonder", "proud", "sad"}
-    
-    if mood not in valid_moods:
-        mood = "normal"
-    if emotion not in valid_emotions: 
-        emotion = "curious"
-        
-    return visible, mood, emotion
-
-def _apply_scene_signals(current: dict, mood: str | None, emotion: str | None) -> dict:
-    """
-    Stamp mood and emotion onto a copy of `current`.
-    renders.py reads current["scene_mood"] and current["myco_emotion"] directly
-    to drive backgrounds, animations, and filters — no extra Gradio state needed.
-    """
-    updated = dict(current)
-    if mood:
-        updated["scene_mood"]    = mood
-    if emotion:
-        updated["myco_emotion"]  = emotion
-    return updated
-
-# ── JSON extraction ───���───────────────────────────────────────────────────────
+# ---------------------------------------------------------------------------
+# Utility: extract JSON or return text
+# ---------------------------------------------------------------------------
 def _extract_json_or_text(generated_text: str) -> str | None:
-    """
-    Try to parse the first valid JSON object/array from the model output.
-    Falls back to returning the raw text if no JSON is found.
-    Used by _llm() for structured game-event calls.
-    """
     if not generated_text:
         return None
     text = str(generated_text).strip()
-    for candidate in reversed(re.findall(r"\{.*?\}|\[.*?\]", text, flags=re.DOTALL)):
-        try:
-            parsed = json.loads(candidate)
-            return json.dumps(parsed, separators=(",", ":"), ensure_ascii=False)
-        except Exception:
-            continue
+
+    simple_matches = re.findall(r"\{.*?\}|\[.*?\]", text, flags=re.DOTALL)
+    if simple_matches:
+        for candidate in reversed(simple_matches):
+            try:
+                parsed = json.loads(candidate)
+                return json.dumps(parsed, separators=(",", ":"), ensure_ascii=False)
+            except Exception:
+                continue
+
     return text or None
 
-# ── Status helpers ────────────────────────────────────────────────────────────
-def companion_model_id() -> str:
+
+# ---------------------------------------------------------------------------
+# Status
+# ---------------------------------------------------------------------------
+def companion_model_id():
     return os.getenv("MYCO_MODEL_ID", DEFAULT_MODEL_ID)
 
-def companion_status() -> str:
-    """Returns a human-readable string shown in the Gradio status bar."""
+
+def companion_status():
     pipe  = _get_pipeline()
     model = companion_model_id()
     if pipe:
         return f"🧠 Myco AI active ({model})"
     return f"⚠️ Myco AI fallback mode ({model} failed)"
 
-def hf_companion_status() -> str:
+
+def hf_companion_status():
     return companion_status()
 
-# ── LLM call — single-turn game event ────────────────────────────────────────
-def _llm(prompt: str, context: dict | None = None) -> tuple[str, str, str] | tuple[None, None, None]:
-    """
-    Single-turn call for game events (discover, pick, study, collect, whisper).
-    Appends JSON_PROMPT_SUFFIX to encourage structured output from small models.
-    Returns (reply_text, scene_mood, myco_emotion) on success,
-            (None, None, None) when the model is unavailable or errors.
-    """
+
+# ---------------------------------------------------------------------------
+# LLM call — single-turn
+# ---------------------------------------------------------------------------
+def _llm(prompt: str, context: dict | None = None) -> str | None:
     pipe = _get_pipeline()
     if not pipe:
-        return None, None, None
-        
-    ctx           = context or {}
+        return None
+
+    ctx = context or {}
     mushroom_line = ""
     if ctx.get("name"):
         poison_flag   = " ⚠️ POISONOUS" if ctx.get("name") in POISONOUS else ""
@@ -326,48 +205,51 @@ def _llm(prompt: str, context: dict | None = None) -> tuple[str, str, str] | tup
             f"Edible: {ctx.get('edible','Unknown')}. Magic: {ctx.get('magic','Unknown')}. "
             f"Danger: {ctx.get('danger','Unknown')}."
         )
-        
-    system = (
-        f"{SYSTEM_PROMPT}\n\n"
-        f"{mushroom_line}\n"
-        f"MycoDex entries: {ctx.get('collection_count', 0)}. "
-        f"Active mystery chapter: {ctx.get('mystery_title', 'The Wrong Memory')}. "
-        f"Player score: {ctx.get('score', 0)} spores. "
-        f"Health: {ctx.get('health', 3)}/3."
-    )
-    
+
+    collection_line = f"MycoDex entries: {ctx.get('collection_count', 0)}."
+    mystery_line    = f"Active mystery chapter: {ctx.get('mystery_title', 'The Wrong Memory')}."
+    score_line      = f"Player score: {ctx.get('score', 0)} spores. Health: {ctx.get('health', 3)}/3."
+
+    system = f"{SYSTEM_PROMPT}\n\n{mushroom_line}\n{collection_line}\n{mystery_line}\n{score_line}"
+
     messages = [
         {"role": "system", "content": system},
         {"role": "user",   "content": prompt + JSON_PROMPT_SUFFIX},
     ]
-    
+
     try:
-        raw = _run_pipeline(pipe, messages)
+        outputs = _run_pipeline(pipe, messages)
         print("========== MYCO OUTPUT ==========")
-        print(raw)
+        print(outputs)
         print("=================================")
-        text = _extract_json_or_text(str(raw))
-        return _parse_llm_output(text or "")
+
+        if isinstance(outputs, list) and outputs:
+            first     = outputs[0]
+            generated = first.get("generated_text", "") if isinstance(first, dict) else str(first)
+        else:
+            generated = str(outputs)
+
+        if isinstance(generated, list):
+            last = generated[-1]
+            text = last.get("content") if isinstance(last, dict) else str(last)
+        else:
+            text = str(generated)
+
+        return _extract_json_or_text(text)
     except Exception as exc:
         print(f"[Myco] Inference error: {exc}")
         traceback.print_exc()
-        return None, None, None
+        return None
 
-# ── LLM call — multi-turn chat ────────────────────────────────────────────────
-def _llm_with_history(
-    history: list, user_message: str, context: dict) -> tuple[str, str, str] | tuple[None, None, None]:
-    """
-    Multi-turn call for the Myco chat interface.
-    No JSON forcing here — Myco speaks naturally.  The model is instructed via
-    SYSTEM_PROMPT to end every reply with 'MOOD:x EMOTION:y' so renders.py
-    can react to the conversation in real time.
-    Keeps the last 6 turns to stay within small-model context limits.
-    Returns (reply_text, scene_mood, myco_emotion) or (None, None, None).
-    """
+
+# ---------------------------------------------------------------------------
+# LLM call — multi-turn chat
+# ---------------------------------------------------------------------------
+def _llm_with_history(history: list, user_message: str, context: dict) -> str | None:
     pipe = _get_pipeline()
     if not pipe:
-        return None, None, None
-        
+        return None
+
     ctx           = context or {}
     mushroom_line = ""
     if ctx.get("name"):
@@ -377,7 +259,7 @@ def _llm_with_history(
             f"Lore: {ctx.get('lore','?')}. "
             f"Edible: {ctx.get('edible','Unknown')}. Magic: {ctx.get('magic','Unknown')}."
         )
-        
+
     system = (
         f"{SYSTEM_PROMPT}\n\n"
         f"{mushroom_line}\n"
@@ -385,34 +267,35 @@ def _llm_with_history(
         f"Mystery: {ctx.get('mystery_title', 'The Wrong Memory')}. "
         f"Score: {ctx.get('score', 0)} spores. Health: {ctx.get('health', 3)}/3."
     )
-    
+
     messages = [{"role": "system", "content": system}]
     for entry in history[-6:]:
         role    = entry.get("role", "assistant")
         content = entry.get("content", "")
         if isinstance(content, str) and content.strip():
             messages.append({"role": role, "content": content})
-            
+    # Chat replies: no JSON forcing — Myco speaks naturally here.
     messages.append({"role": "user", "content": user_message})
-    
+
     try:
-        raw = _run_pipeline(pipe, messages)
+        reply = _run_pipeline(pipe, messages)
+    
         print("========== MYCO OUTPUT ==========")
-        print(raw)
+        print(reply)
         print("=================================")
-        return _parse_llm_output(str(raw))
+    
+        return reply
+    
     except Exception as exc:
         print(f"[Myco] Inference error: {exc}")
         traceback.print_exc()
-        return None, None, None
+        return None
 
-# ── Context builder ───────────────────────────────────────────────────────────
+
+# ---------------------------------------------------------------------------
+# Context builder
+# ---------------------------------------------------------------------------
 def _ctx(current: dict | None, collection: list) -> dict:
-    """
-    Assemble the per-call context snapshot passed to every LLM call.
-    Includes current mushroom details, MycoDex size, active mystery chapter,
-    score, and health — the model's complete view of the game state.
-    """
     count   = len(collection)
     chapter = MYSTERY_CHAPTERS[0]
     for c in MYSTERY_CHAPTERS:
@@ -420,7 +303,6 @@ def _ctx(current: dict | None, collection: list) -> dict:
             chapter = c
     score  = _score_collection(collection)
     health = _health(current, collection)
-    
     ctx: dict = {
         "collection_count": count,
         "mystery_title":    chapter["title"],
@@ -428,7 +310,6 @@ def _ctx(current: dict | None, collection: list) -> dict:
         "score":            score,
         "health":           health,
     }
-    
     if current:
         ctx.update({
             "name":    current.get("name", ""),
@@ -441,74 +322,65 @@ def _ctx(current: dict | None, collection: list) -> dict:
         })
     return ctx
 
-# ── Fallbacks ─────────────────────────────────────────────────────────────────
-def _fallback_discover(current: dict) -> tuple[str, str, str]:
+
+# ---------------------------------------------------------------------------
+# Fallbacks
+# ---------------------------------------------------------------------------
+def _fallback_discover(current: dict) -> str:
     name   = current.get("name", "something")
     rarity = current.get("rarity", "Common")
-    if current.get("name", "") in POISONOUS:
-        return (
-            f"Wait — {name}! I've seen this before... something feels very wrong. Don't touch it yet.",
-            "danger", "afraid",
-        )
+    poison = current.get("name", "") in POISONOUS
+    if poison:
+        return f"Wait — {name}! I've seen this before... something feels very wrong. Don't touch it yet."
     if rarity == "Legendary":
-        return (
-            f"Oh! Oh! A {name}! The whole clearing just went silent. This is from the Elder Map!",
-            "legendary", "wonder",
-        )
+        return f"Oh! Oh! A {name}! The whole clearing just went silent. This is from the Elder Map!"
     if rarity == "Rare":
-        return (
-            f"A {name}... I can feel it humming. Something rare is here — maybe magical.",
-            "rare", "wonder",
-        )
-    return (
-        f"A {name}! Found near {current.get('habitat','the forest')}. Let me sense it first.",
-        "normal", "curious",    )
+        return f"A {name}... I can feel it humming. Something rare is here — maybe magical."
+    return f"A {name}! Found near {current.get('habitat','the forest')}. Let me sense it first."
+
 
-def _fallback_pick(current: dict) -> tuple[str, str, str]:
+def _fallback_pick(current: dict) -> str:
     if _is_poisonous(current):
-        return "💀 That was poisonous! I tried to stop you... the forest goes dark.", "danger", "sad"
-    score = RARITY_SCORE.get(current.get("rarity", "Common"), 10)
-    return f"Got {current.get('name','it')}! +{score} spores!", "excited", "excited"
+        return "💀 That was poisonous! I tried to stop you... the forest goes dark."
+    return f"Got {current.get('name','it')}! +{RARITY_SCORE.get(current.get('rarity','Common'),10)} spores!"
 
-def _fallback_study(current: dict) -> tuple[str, str, str]:
-    clue = RARITY_CLUES.get(current.get("rarity", "Common"), "")
-    return f"I studied it carefully. {clue}", "normal", "curious"
 
-def _fallback_collect(current: dict) -> tuple[str, str, str]:
-    return f"Added {current.get('name','it')} to the MycoDex! The pages feel warmer.", "excited", "proud"
+def _fallback_study(current: dict) -> str:
+    return f"I studied it carefully. Magic field updated. The clue: {RARITY_CLUES.get(current.get('rarity','Common'), '')}"
+
+
+def _fallback_collect(current: dict) -> str:
+    return f"Added {current.get('name','it')} to the MycoDex! The pages feel warmer."
 
-def _fallback_whisper(current: dict) -> tuple[str, str, str]:
-    return (
-        "I followed the whisper... and remembered a path I've never walked. The mystery deepens.",
-        "wonder", "wonder",
-    )
 
-def _fallback_chat(current: dict | None) -> tuple[str, str, str]:
+def _fallback_whisper(current: dict) -> str:
+    return "I followed the whisper... and remembered a path I've never walked. The mystery deepens."
+
+
+def _fallback_chat(current: dict | None) -> str:
     if current:
-        return (
-            f"I feel something strange about {current.get('name','this')}... stay close to me.",
-            "normal", "nervous",
-        )
-    return (
-        "The forest is full of secrets. Move to a clearing and search — I'll watch for danger.",
-        "normal", "curious",
-    )
+        return f"I feel something strange about {current.get('name','this')}... stay close to me."
+    return "The forest is full of secrets. Move to a clearing and search — I'll watch for danger."
+
 
-# ── Mushroom helpers ──────────────────────────────────────────────────────────
+# ---------------------------------------------------------------------------
+# Mushroom helpers
+# ---------------------------------------------------------------------------
 def _choose_mushroom(catalog=None):
-    """Weighted random pick — Legendary 8 %, Rare 24 %, Common 64 %."""
     mushrooms = tuple(load_mushrooms() if catalog is None else catalog)
     weights   = [RARITY_WEIGHTS.get(m.rarity, 12) for m in mushrooms]
     return random.choices(mushrooms, weights=weights, k=1)[0]
 
+
 def _is_poisonous(current: dict) -> bool:
     return current.get("name", "") in POISONOUS or current.get("danger") == "Poisonous"
 
+
 def _score_value(current: dict) -> int:
     return RARITY_SCORE.get(current.get("rarity", "Common"), 10)
 
+
 def _score_collection(collection: list) -> int:
-    """Sum score_delta for all non-game-over entries."""
     total = 0
     for e in collection:
         if e.get("game_over") == "Yes":
@@ -516,19 +388,15 @@ def _score_collection(collection: list) -> int:
         total += int(e.get("score_delta") or _score_value(e))
     return max(0, total)
 
+
 def _health(current: dict | None, collection: list) -> int:
-    """One health lost per game-over entry; floor at 0."""
     if current and current.get("game_over") == "Yes":
         return 0
     deaths = sum(1 for e in collection if e.get("game_over") == "Yes")
     return max(0, PLAYER_HEALTH - deaths)
 
+
 def _mystery_state(count: int) -> dict:
-    """
-    Return the active mystery chapter and the next-chapter teaser line.
-    Both are stamped onto `current` so the HUD and story box always reflect
-    the player's narrative progress.
-    """
     chapter, next_ch = MYSTERY_CHAPTERS[0], None
     for c in MYSTERY_CHAPTERS:
         if count >= c["threshold"]:
@@ -545,16 +413,12 @@ def _mystery_state(count: int) -> dict:
         "mystery_next":  next_line,
     }
 
+
 def _story_event(count: int) -> dict:
-    """Cycle through FOREST_EVENTS by discovery count — simple deterministic variety."""
     return FOREST_EVENTS[count % len(FOREST_EVENTS)]
 
+
 def _build_current(mushroom, collection: list) -> dict:
-    """
-    Build the full `current` state dict for a freshly discovered mushroom.
-    Includes poison flag, score/health snapshot, rarity clue, forest event,
-    mystery chapter state, and default scene signals (overwritten by LLM below).
-    """
     count   = len(collection)
     current = mushroom.to_dict()
     current["poison"]      = "Yes" if mushroom.name in POISONOUS else "No"
@@ -562,44 +426,41 @@ def _build_current(mushroom, collection: list) -> dict:
     current["health"]      = str(_health(current, collection))
     current["score_delta"] = "0"
     current["clue"]        = RARITY_CLUES.get(mushroom.rarity, RARITY_CLUES["Common"])
-    
     if count == 0:
         current["clue"] = f"First clue: {mushroom.name} marks the beginning of the Spore Door trail."
-        
     event = _story_event(count)
     current.update({
-        "event_title":   event["title"],
-        "event_emoji":   event["emoji"],
-        "myco_mood":     event["mood"],
-        "reward_text":   "Discover, then pick or collect.",
-        # Default scene signals — overwritten after every LLM call.
-        "scene_mood":    "normal",
-        "myco_emotion":  "curious",
+        "event_title":  event["title"],
+        "event_emoji":  event["emoji"],
+        "myco_mood":    event["mood"],
+        "reward_text":  "Discover, then pick or collect.",
     })
     current.update(_mystery_state(count))
     return current
 
+
 def _append(history: list, role: str, content: str) -> list:
     return [*history, {"role": role, "content": content}]
 
+
 def _safe_history(h) -> list:
     return list(h or welcome_history())
 
+
 def _safe_collection(c) -> list:
     return list(c or [])
 
-# ── Public game actions ───────────────────────────────────────────────────────
+
+# ---------------------------------------------------------------------------
+# Public game actions
+# ---------------------------------------------------------------------------
 def discover_mushroom(collection=None, catalog=None):
-    """
-    Spawn a weighted-random mushroom and ask the LLM to narrate the moment.
-    The LLM's mood/emotion tags set the initial forest scene colour and
-    Myco's animation for this discovery.
-    """
+    """Discover a new mushroom. LLM narrates the moment."""
     coll     = _safe_collection(collection)
     mushroom = _choose_mushroom(catalog)
     current  = _build_current(mushroom, coll)
     ctx      = _ctx(current, coll)
-    
+
     prompt = (
         f"The player just discovered a {mushroom.rarity} mushroom called {mushroom.name} "
         f"near {mushroom.habitat}. "
@@ -610,55 +471,42 @@ def discover_mushroom(collection=None, catalog=None):
         f"Mystery chapter: {current['mystery_title']}. "
         "React in character. Hint at what to do next (Study, Pick, Follow Whisper, or Collect)."
     )
-    reply, mood, emotion = _llm(prompt, ctx)
-    if reply is None:
-        reply, mood, emotion = _fallback_discover(current)
-        
-    current = _apply_scene_signals(current, mood, emotion)
+    reply   = _llm(prompt, ctx) or _fallback_discover(current)
     history = _append(welcome_history(), "assistant", reply)
     return mushroom, current, history
 
+
 def myco_reply(message=None, history=None, current=None, collection=None, position=None):
-    """
-    Handle a player chat message.
-    The LLM reply updates scene_mood and myco_emotion on `current` so the
-    forest card reacts to the conversation without a separate Search action.
-    Returns ("", updated_history, updated_current) matching Gradio output slots.
-    """
+    """Player chats with Myco. LLM responds in character with full context."""
     print("MYCO_REPLY CALLED, message:", repr(message))
     hist  = _safe_history(history)
     coll  = _safe_collection(collection)
     clean = (message or "").strip()
     if not clean:
-        return "", hist, current
-        
+        return "", hist
+
     ctx   = _ctx(current, coll)
-    reply, mood, emotion = _llm_with_history(hist, clean, ctx)
-    if reply is None:
-        reply, mood, emotion = _fallback_chat(current)
-        
-    # Push mood/emotion back onto current so renders.py updates immediately.
-    if current is not None:
-        current = _apply_scene_signals(current, mood, emotion)
-        
-    new_history = _append(hist, "user", clean) + [{"role": "assistant", "content": reply}]
-    return "", new_history, current
+    reply = _llm_with_history(hist, clean, ctx)
+    if not reply:
+        reply = _fallback_chat(current)
+
+    return "", _append(hist, "user", clean) + [{"role": "assistant", "content": reply}]
+
 
 companion_reply = myco_reply
 
+
 def collect_current(current=None, collection=None, history=None):
-    """
-    Add the current mushroom to the MycoDex.
-    LLM celebrates the entry and may drop a mystery hint.
-    Duplicate entries are silently rejected.
-    """
+    """Collect mushroom into MycoDex. LLM narrates the entry."""
     coll = _safe_collection(collection)
     hist = _safe_history(history)
+
     if current is None:
-        return coll, current, _append(hist, "assistant", "We need to find a mushroom first!")
+        return coll, _append(hist, "assistant", "We need to find a mushroom first!")
+
     if collection_contains(coll, current["name"]):
-        return coll, current, _append(hist, "assistant", f"{current['name']} is already in the MycoDex!")
-        
+        return coll, _append(hist, "assistant", f"{current['name']} is already in the MycoDex!")
+
     score_delta  = _score_value(current)
     score_total  = _score_collection(coll) + score_delta
     collected    = {
@@ -670,33 +518,27 @@ def collect_current(current=None, collection=None, history=None):
     }
     updated_coll = [*coll, collected]
     ctx          = _ctx(current, coll)
-    
+
     prompt = (
         f"The player just added {current['name']} ({current.get('rarity','Common')}) to the MycoDex! "
         f"+{score_delta} spores. Total score: {score_total}. "
         f"MycoDex now has {len(updated_coll)} entries. "
         "Celebrate this moment. Add a small lore detail or mystery hint."
     )
-    reply, mood, emotion = _llm(prompt, ctx)
-    if reply is None:
-        reply, mood, emotion = _fallback_collect(current)
-        
-    collected = _apply_scene_signals(collected, mood, emotion)
-    return updated_coll, collected, _append(hist, "assistant", reply)
+    reply = _llm(prompt, ctx) or _fallback_collect(current)
+    return updated_coll, _append(hist, "assistant", reply)
+
 
 def pick_current(current=None, collection=None, history=None):
-    """
-    Pick the current mushroom.
-    Poisonous pick → game over, health 0, score penalty, dark scene.
-    Safe pick      → score awarded, mushroom flies off screen (CSS handled
-                     by state-picked class in renders.py).
-    """
+    """Pick mushroom as game item. Poison = game over. LLM narrates dramatically."""
     coll = _safe_collection(collection)
     hist = _safe_history(history)
+
     if current is None:
         return coll, None, _append(hist, "assistant", "Find a mushroom first before picking!")
-        
+
     ctx = _ctx(current, coll)
+
     if _is_poisonous(current):
         score_total = max(0, _score_collection(coll) + POISON_PENALTY)
         game_over   = {
@@ -707,21 +549,15 @@ def pick_current(current=None, collection=None, history=None):
             "score_delta": str(POISON_PENALTY),
             "score_total": str(score_total),
             "reward_text": f"Poison! {POISON_PENALTY} spores · Game Over",
-            "scene_mood":  "danger",
-            "myco_emotion":"sad",
         }
         prompt = (
             f"DRAMATIC MOMENT: The player picked {current['name']} which is POISONOUS! "
             f"Game Over! Score drops by 25 to {score_total}. Health → 0. "
             "React with shock, sadness, and a dramatic farewell. Make it memorable."
         )
-        reply, mood, emotion = _llm(prompt, ctx)
-        if reply is None:
-            reply, mood, emotion = _fallback_pick(current)
-        game_over = _apply_scene_signals(game_over, mood or "danger", emotion or "sad")
+        reply = _llm(prompt, ctx) or _fallback_pick(current)
         return coll, game_over, _append(hist, "assistant", f"💀 {reply}")
-        
-    # Safe pick
+
     score_delta  = _score_value(current)
     score_total  = _score_collection(coll) + score_delta
     picked       = {
@@ -733,47 +569,57 @@ def pick_current(current=None, collection=None, history=None):
         "health":      str(_health(current, coll)),
         "reward_text": f"+{score_delta} spores",
     }
-    
+
     if collection_contains(coll, picked["name"]):
         return coll, picked, _append(hist, "assistant", f"{picked['name']} already picked!")
-        
+
     updated_coll = [*coll, picked]
     prompt = (
         f"The player safely picked {current['name']} ({current.get('rarity','Common')})! "
         f"+{score_delta} spores. Total: {score_total}. "
         "Celebrate! Make it feel like a platformer power-up moment."
     )
-    reply, mood, emotion = _llm(prompt, ctx)
-    if reply is None:
-        reply, mood, emotion = _fallback_pick(current)
-    picked = _apply_scene_signals(picked, mood, emotion)
+    reply = _llm(prompt, ctx) or _fallback_pick(current)
     return updated_coll, picked, _append(hist, "assistant", f"🍄 {reply}")
 
+
 def follow_whisper(current=None, collection=None, history=None):
-    """
-    Follow the forest whisper.
-    If the current mushroom is poisonous, warning signs flare up.
-    Otherwise, the player uncovers details regarding the active mystery narrative chapter.
-    """
+    """Follow the forest whisper. LLM reveals mystery fragments."""
     coll = _safe_collection(collection)
     hist = _safe_history(history)
+
     if current is None:
-        return coll, None, _append(hist, "assistant", "Whispers only gather around a found mushroom.")
-        
+        return None, _append(hist, "assistant",
+            "Myco cups one ear. The forest only whispers near mushrooms — search a clearing first.")
+
     ctx = _ctx(current, coll)
-    prompt = (
-        f"The player decides to follow a faint whisper echoing from the {current.get('name', 'mushroom')}. "
-        f"Active mystery thread: {ctx.get('mystery_title')}. Clue context: {ctx.get('mystery_clue')}. "
-        "Describe Myco guiding them along a shifting, forgotten trail. Maintain a high degree of wonder "
-        "or underlying anxiety depending on the danger status of the location."
+
+    if _is_poisonous(current) and current.get("studied") != "Yes":
+        game_over = {
+            **current,
+            "danger":      "Poisonous",
+            "game_over":   "Yes",
+            "health":      "0",
+            "score_total": str(max(0, _score_collection(coll) + POISON_PENALTY)),
+        }
+        prompt = (
+            f"The player followed a whisper but it led to POISON from {current['name']}! Game Over! "
+            "React with horror and a haunting mystery revelation."
+        )
+        reply = _llm(prompt, ctx) or "💀 The whisper belonged to poison... Myco screams."
+        return game_over, _append(hist, "assistant", reply)
+
+    mystery = _mystery_state(len(coll) + 1)
+    prompt  = (
+        f"The player followed a forest whisper near {current.get('name','a mushroom')}. "
+        f"Mystery chapter revealed: {mystery['mystery_title']}. Clue: {mystery['mystery_clue']}. "
+        "Reveal this mystery fragment dramatically. "
+        "Make Myco gasp or tremble. Hint that the MycoDex is alive and regrowing the lost forest."
     )
-    
-    reply, mood, emotion = _llm(prompt, ctx)
-    if reply is None:
-        reply, mood, emotion = _fallback_whisper(current)
-        
-    current = _apply_scene_signals(current, mood, emotion)
-    return coll, current, _append(hist, "assistant", f"✨ {reply}")
+    reply    = _llm(prompt, ctx) or _fallback_whisper(current)
+    revealed = {**current, **mystery, "whisper_followed": "Yes"}
+    return revealed, _append(hist, "assistant", f"🌌 {reply}")
+
 
 def study_current(current=None, history=None):
     """Study mushroom. LLM gives a careful field observation."""
@@ -801,4 +647,3 @@ def eat_current(current=None, collection=None, history=None):
     )
     return collection, _append(hist, "assistant", reply)
     
-