Deploy Myco from CI

game/engine.py

@@ -1,399 +1,698 @@
-"""Gradio game UI for Myco — LLM-powered forest adventure."""
+"""
+Core Myco gameplay — LLM is the primary game engine.
+"""
 
-import ast
-import json
-from typing import Any, cast
-import gradio as gr
+import os
+import random
+import threading
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# 1. REMOVED: Circular import "from game.engine import ..."
+# 2. Add local imports for dependencies
+from game.catalog import load_mushrooms
+from game.state import collection_contains, welcome_history
+
+# Global singletons
+DEFAULT_MODEL_ID = "google/gemma-3-1b-it"
+_model = None
+_tokenizer = None
+_lock = threading.Lock()
+
+# Detect device dynamically (Use CPU by default for reliability)
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+def _get_model_and_tokenizer():
+    global _model, _tokenizer
+    if _model is not None:
+        return _model, _tokenizer
+
+    with _lock:
+        if _model is not None:
+            return _model, _tokenizer
+
+        model_id = os.getenv("MYCO_MODEL_ID", DEFAULT_MODEL_ID)
+        token = os.getenv("HF_BUILD_SMALL_HACKATHON_TOKEN")
+
+        try:
+            print(f"[Myco] Loading model on: {DEVICE.upper()}...")
+            _tokenizer = AutoTokenizer.from_pretrained(model_id, token=token)
+            
+            # Load model explicitly
+            _model = AutoModelForCausalLM.from_pretrained(
+                model_id,
+                token=token,
+                torch_dtype=torch.float16 if DEVICE == "cuda" else torch.float32,
+                device_map=DEVICE, 
+                trust_remote_code=True
+            )
+            return _model, _tokenizer
+        except Exception as exc:
+            print(f"[Myco] Load error: {exc}")
+            return None, None
+
+def _run_pipeline(messages):
+    """Run inference without @spaces.GPU decorator."""
+    model, tokenizer = _get_model_and_tokenizer()
+    if model is None:
+        return "The forest is silent. (Model failed to load)"
+
+    formatted_prompt = tokenizer.apply_chat_template(
+        messages, tokenize=False, add_generation_prompt=True
+    )
 
-from game.engine import (
-    collect_current, discover_mushroom, eat_current,
-    follow_whisper, hf_companion_status, myco_reply,
-    pick_current, study_current,
-)
-from game.state import welcome_history
-from models.mushroom import Mushroom
-
-from ui.renderers import (
-    dex_markdown, forest_scene, game_intro_markdown,
-    game_status_markdown, hero_markdown, home_forest_markdown,
-    mushroom_card, play_hook_markdown, progress_markdown,
-    world_map_markdown,
+    # Ensure inputs are on the correct device
+    inputs = tokenizer(formatted_prompt, return_tensors="pt").to(DEVICE)
+
+    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
+        )
+
+    input_length = inputs.input_ids.shape[1]
+    generated_tokens = outputs[0][input_length:]
+    return tokenizer.decode(generated_tokens, skip_special_tokens=True)
+
+
+# ---------------------------------------------------------------------------
+# Template Helper (Fixes the Gemma TemplateError)
+# ---------------------------------------------------------------------------
+def _format_messages_for_template(system_prompt: str, user_prompt: str, history_turns: list = None) -> list:
+    """
+    Formats messages securely for models with strict chat templates (like Gemma).
+    - Starts the conversation with a 'user' turn containing the system prompt.
+    - Maps 'assistant' role tags directly to 'model'.
+    - Implements alternative processing to merge consecutive same-role text blocks.
+    """
+    # Gemma doesn't support the 'system' role, so we inject it as the first 'user' prompt
+    raw_turns = [{"role": "user", "content": system_prompt}]
+    
+    if history_turns:
+        for entry in history_turns:
+            role = entry.get("role", "assistant")
+            if role == "assistant":
+                role = "model"
+            elif role == "system":
+                continue # Strip extraneous system tags
+            
+            content = entry.get("content", "")
+            if isinstance(content, str) and content.strip():
+                raw_turns.append({"role": role, "content": content})
+                
+    # Add the current payload action
+    raw_turns.append({"role": "user", "content": user_prompt})
+    
+    # Deduplicate consecutive roles (guarantees perfect strict user/model rotation)
+    alternated_turns = []
+    for turn in raw_turns:
+        if alternated_turns and alternated_turns[-1]["role"] == turn["role"]:
+            alternated_turns[-1]["content"] += f"\n\n{turn['content']}"
+        else:
+            alternated_turns.append(turn)
+            
+    return alternated_turns
+
+# ---------------------------------------------------------------------------
+# Game Constants
+# ---------------------------------------------------------------------------
+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."}'
 )
 
-from ui.interface import render_shroom_tab
-
-EMPTY_COLLECTION = None
-START_POSITION   = (1, 1)
+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 = """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."""
+
+FOREST_EVENTS = [
+    {"title": "A Quiet Clearing",   "emoji": "🌿", "mood": "calm"},
+    {"title": "Wind Between Trees", "emoji": "🕯️", "mood": "afraid"},
+]
+
+MYSTERY_CHAPTERS = [
+    {"threshold": 0, "title": "The Wrong Memory",    "clue": "Myco recognises the path before you move."},
+    {"threshold": 1, "title": "The Traveler's Song", "clue": "A stranger's lullaby appears in the MycoDex margin."},
+    {"threshold": 2, "title": "The Door Under Roots","clue": "Rare spores point to a door nobody built."},
+    {"threshold": 3, "title": "The MycoDex Seed",    "clue": "The MycoDex grows warm like a living cap."},
+    {"threshold": 5, "title": "The Impossible Bloom","clue": "The Impossible Mushroom was never outside the book."},
+]
+
+RARITY_CLUES = {
+    "Common":    "The cap leans toward the path, like it wants to be remembered.",
+    "Rare":      "Silver spores circle it in a pattern only old forest stories describe.",
+    "Legendary": "The whole clearing goes quiet — this mushroom hides part of the Elder Map.",
+}
+
+
+# ---------------------------------------------------------------------------
+# Utility: extract JSON or return text
+# ---------------------------------------------------------------------------
+def _extract_json_or_text(generated_text: str) -> str | None:
+    if not generated_text:
+        return None
+    text = str(generated_text).strip()
+
+    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
+# ---------------------------------------------------------------------------
+def companion_model_id():
+    return os.getenv("MYCO_MODEL_ID", DEFAULT_MODEL_ID)
+
+
+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():
+    return companion_status()
+
+
+# ---------------------------------------------------------------------------
+# LLM call — single-turn
+# ---------------------------------------------------------------------------
+def _llm(prompt: str, context: dict | None = None) -> str | None:
+    pipe = _get_pipeline()
+    if not pipe:
+        return None
+
+    ctx = context or {}
+    mushroom_line = ""
+    if ctx.get("name"):
+        poison_flag   = " ⚠️ POISONOUS" if ctx.get("name") in POISONOUS else ""
+        mushroom_line = (
+            f"Current mushroom: {ctx['name']} ({ctx.get('rarity','?')} rarity){poison_flag}. "
+            f"Habitat: {ctx.get('habitat','?')}. Lore: {ctx.get('lore','?')}. "
+            f"Edible: {ctx.get('edible','Unknown')}. Magic: {ctx.get('magic','Unknown')}. "
+            f"Danger: {ctx.get('danger','Unknown')}."
+        )
+
+    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}"
+
+    # Safe layout handling for strict model templates
+    messages = _format_messages_for_template(system, prompt + JSON_PROMPT_SUFFIX)
 
-def force_parse_json_or_literal(s: str) -> Any:
-    s = s.strip()
-    if not (s.startswith("[") or s.startswith("{")):
-        return s
     try:
-        return json.loads(s)
-    except Exception:
-        pass
-    try:
-        return ast.literal_eval(s)
-    except Exception:
-        pass
+        outputs = _run_pipeline(pipe, messages)
+        print("========== MYCO OUTPUT ==========")
+        print(outputs)
+        print("=================================")
+
+        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
+
+
+# ---------------------------------------------------------------------------
+# 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
+
+    ctx           = context or {}
+    mushroom_line = ""
+    if ctx.get("name"):
+        poison_flag   = " ⚠️ POISONOUS" if ctx.get("name") in POISONOUS else ""
+        mushroom_line = (
+            f"Current mushroom: {ctx['name']} ({ctx.get('rarity','?')}){poison_flag}. "
+            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"
+        f"MycoDex entries: {ctx.get('collection_count', 0)}. "
+        f"Mystery: {ctx.get('mystery_title', 'The Wrong Memory')}. "
+        f"Score: {ctx.get('score', 0)} spores. Health: {ctx.get('health', 3)}/3."
+    )
+
+    # Safe structure formatting running history securely through template checks
+    messages = _format_messages_for_template(system, user_message, history[-6:])
+
     try:
-        s_json = s.replace("None", "null").replace("True", "true").replace("False", "false")
-        return json.loads(s_json)
-    except Exception:
-        pass
-    return s
-
-def extract_clean_text(val: Any) -> str:
-    if val is None:
-        return ""
-    if isinstance(val, str):
-        val_stripped = val.strip()
-        if (val_stripped.startswith("[") and val_stripped.endswith("]")) or (val_stripped.startswith("{") and val_stripped.endswith("}")):
-            parsed = force_parse_json_or_literal(val_stripped)
-            if isinstance(parsed, str):
-                return parsed
-            return extract_clean_text(parsed)
-        return val
-    if isinstance(val, dict):
-        if "text" in val:
-            return extract_clean_text(val["text"])
-        if "content" in val:
-            return extract_clean_text(val["content"])
-        return " ".join([extract_clean_text(v) for v in val.values() if v])
-    if isinstance(val, list):
-        segments = []
-        for item in val:
-            cleaned = extract_clean_text(item)
-            if cleaned:
-                segments.append(cleaned)
-        return "\n".join(segments)
-    return str(val)
-
-def _normalize_history(history):
-    if not history:
-        return []
-    if isinstance(history, str):
-        history = force_parse_json_or_literal(history)
-    if not isinstance(history, (list, tuple)):
-        history = [history]
-    raw_normalized = []
-    for item in history:
-        if item is None:
-            continue
-        if isinstance(item, str):
-            item = force_parse_json_or_literal(item)
-        role = "assistant"
-        content_val = item
-        if isinstance(item, dict):
-            role = item.get("role", "assistant")
-            content_val = item.get("content", item.get("text", item))
-        elif isinstance(item, (list, tuple)) and len(item) == 2:
-            user_side, bot_side = item
-            if user_side:
-                raw_normalized.append({"role": "user", "content": extract_clean_text(user_side)})
-            if bot_side:
-                raw_normalized.append({"role": "assistant", "content": extract_clean_text(bot_side)})
+        reply = _run_pipeline(pipe, messages)
+        
+        print("========== MYCO OUTPUT ==========")
+        print(reply)
+        print("=================================")
+        
+        return reply
+        
+    except Exception as exc:
+        print(f"[Myco] Inference error: {exc}")
+        traceback.print_exc()
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Context builder
+# ---------------------------------------------------------------------------
+def _ctx(current: dict | None, collection: list) -> dict:
+    count   = len(collection)
+    chapter = MYSTERY_CHAPTERS[0]
+    for c in MYSTERY_CHAPTERS:
+        if count >= c["threshold"]:
+            chapter = c
+    score  = _score_collection(collection)
+    health = _health(current, collection)
+    ctx: dict = {
+        "collection_count": count,
+        "mystery_title":    chapter["title"],
+        "mystery_clue":     chapter["clue"],
+        "score":            score,
+        "health":           health,
+    }
+    if current:
+        ctx.update({
+            "name":    current.get("name", ""),
+            "rarity":  current.get("rarity", "Common"),
+            "habitat": current.get("habitat", ""),
+            "lore":    current.get("lore", ""),
+            "edible":  current.get("edible", "Unknown"),
+            "magic":   current.get("magic", "Unknown"),
+            "danger":  current.get("danger", "Unknown"),
+        })
+    return ctx
+
+
+# ---------------------------------------------------------------------------
+# Fallbacks
+# ---------------------------------------------------------------------------
+def _fallback_discover(current: dict) -> str:
+    name   = current.get("name", "something")
+    rarity = current.get("rarity", "Common")
+    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!"
+    if rarity == "Rare":
+        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) -> str:
+    if _is_poisonous(current):
+        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) -> 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) -> 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."
+    return "The forest is full of secrets. Move to a clearing and search — I'll watch for danger."
+
+
+# ---------------------------------------------------------------------------
+# Mushroom helpers
+# ---------------------------------------------------------------------------
+def _choose_mushroom(catalog=None):
+    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:
+    total = 0
+    for e in collection:
+        if e.get("game_over") == "Yes":
             continue
-        clean_text = extract_clean_text(content_val)
-        if clean_text:
-            if isinstance(clean_text, str) and (clean_text.strip().startswith("[") or clean_text.strip().startswith("{")):
-                nested_parsed = force_parse_json_or_literal(clean_text)
-                if isinstance(nested_parsed, (list, dict)):
-                    raw_normalized.extend(_normalize_history(nested_parsed))
-                    continue
-            raw_normalized.append({"role": role, "content": clean_text})
-    reconciled = []
-    for msg in raw_normalized:
-        role = msg["role"]
-        content = msg["content"]
-        if reconciled and reconciled[-1]["role"] == role:
-            reconciled[-1]["content"] += f"\n{content}"
-        else:
-            reconciled.append({"role": role, "content": content})
-    return reconciled
+        total += int(e.get("score_delta") or _score_value(e))
+    return max(0, total)
+
+
+def _health(current: dict | None, collection: list) -> int:
+    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:
+    chapter, next_ch = MYSTERY_CHAPTERS[0], None
+    for c in MYSTERY_CHAPTERS:
+        if count >= c["threshold"]:
+            chapter = c
+        elif next_ch is None:
+            next_ch = c
+    next_line = (
+        f"{next_ch['threshold'] - count} discoveries until {next_ch['title']}."
+        if next_ch else "The Impossible Bloom is near. Follow the whisper."
+    )
+    return {
+        "mystery_title": chapter["title"],
+        "mystery_clue":  chapter["clue"],
+        "mystery_next":  next_line,
+    }
+
+
+def _story_event(count: int) -> dict:
+    return FOREST_EVENTS[count % len(FOREST_EVENTS)]
+
+
+def _build_current(mushroom, collection: list) -> dict:
+    count   = len(collection)
+    current = mushroom.to_dict()
+    current["poison"]      = "Yes" if mushroom.name in POISONOUS else "No"
+    current["score_total"] = str(_score_collection(collection))
+    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.",
+    })
+    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
+# ---------------------------------------------------------------------------
+def discover_mushroom(collection=None, catalog=None):
+    """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}. "
+        f"{'WARNING: this mushroom is POISONOUS! React with fear and urgency.' if mushroom.name in POISONOUS else ''}"
+        f"{'This is LEGENDARY — react with awe and excitement!' if mushroom.rarity == 'Legendary' else ''}"
+        f"{'This is RARE — react with wonder and curiosity.' if mushroom.rarity == 'Rare' else ''}"
+        f"Forest event: {current['event_title']}. Myco mood: {current['myco_mood']}. "
+        f"Mystery chapter: {current['mystery_title']}. "
+        "React in character. Hint at what to do next (Study, Pick, Follow Whisper, or Collect)."
+    )
+    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):
+    """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
+
+    ctx   = _ctx(current, coll)
+    reply = _llm_with_history(hist, clean, ctx)
+    if not reply:
+        reply = _fallback_chat(current)
+
+    return "", _append(hist, "user", clean) + [{"role": "assistant", "content": reply}]
 
-def _denormalize_history(history):
-    return _normalize_history(history)
 
-def mushroom_card_from_state(current):
+companion_reply = myco_reply
+
+
+def collect_current(current=None, collection=None, history=None):
+    """Collect mushroom into MycoDex. LLM narrates the entry."""
+    coll = _safe_collection(collection)
+    hist = _safe_history(history)
+
     if current is None:
-        return mushroom_card(None)
-    if isinstance(current, str):
-        current = force_parse_json_or_literal(current)
-    if isinstance(current, str):
-        return mushroom_card(None)
-    return mushroom_card(
-        Mushroom.from_dict(current),
-        current.get("clue"),
-        current.get("secret"),
-        current,
+        return coll, _append(hist, "assistant", "We need to find a mushroom first!")
+
+    if collection_contains(coll, current["name"]):
+        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    = {
+        **current,
+        "score_delta": str(score_delta),
+        "score_total": str(score_total),
+        "health":      str(_health(current, coll)),
+        "reward_text": f"+{score_delta} spores",
+    }
+    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 = _llm(prompt, ctx) or _fallback_collect(current)
+    return updated_coll, _append(hist, "assistant", reply)
 
-def search_forest(position, collection):
-    pos = _safe_pos(position)
-    mushroom, current, history = discover_mushroom(collection)
-    if isinstance(current, str):
-        current = force_parse_json_or_literal(current)
-    return (
-        forest_scene(current, collection, pos),
-        game_status_markdown(current, collection, pos),
-        mushroom_card_from_state(current),
-        current,
-        _normalize_history(history),
-        dex_markdown(collection),
-        progress_markdown(collection),
-    )
 
-def ask_companion(message, history, current, collection, position):
-    legacy_hist = _denormalize_history(history)
-    if legacy_hist and legacy_hist[-1]["role"] == "user":
-        legacy_hist.append({"role": "assistant", "content": "..."})
-    result = myco_reply(message, legacy_hist, current, collection, position)
-    if isinstance(result, (tuple, list)) and len(result) == 2:
-        return result[0], _normalize_history(result[1])
-    return "", _normalize_history(result)
-
-def collect_discovery(current, collection, history, position):
-    legacy_hist = _denormalize_history(history)
-    updated_coll, updated_hist = collect_current(current, collection, legacy_hist)
-    pos = _safe_pos(position)
-    if isinstance(current, str):
-        current = force_parse_json_or_literal(current)
-    return (
-        updated_coll,
-        forest_scene(current, updated_coll, pos),
-        game_status_markdown(current, updated_coll, pos),
-        dex_markdown(updated_coll),
-        world_map_markdown(updated_coll),
-        _normalize_history(updated_hist),
-        progress_markdown(updated_coll),
-    )
+def pick_current(current=None, collection=None, history=None):
+    """Pick mushroom as game item. Poison = game over. LLM narrates dramatically."""
+    coll = _safe_collection(collection)
+    hist = _safe_history(history)
 
-def pick_discovery(current, collection, history, position):
-    legacy_hist = _denormalize_history(history)
-    updated_coll, updated_current, updated_hist = pick_current(current, collection, legacy_hist)
-    if isinstance(updated_current, str):
-        updated_current = force_parse_json_or_literal(updated_current)
-    pos = _safe_pos(position)
-    return (
-        updated_coll,
-        updated_current,
-        forest_scene(updated_current, updated_coll, pos),
-        game_status_markdown(updated_current, updated_coll, pos),
-        mushroom_card_from_state(updated_current),
-        dex_markdown(updated_coll),
-        world_map_markdown(updated_coll),
-        _normalize_history(updated_hist),
-        progress_markdown(updated_coll),
+    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   = {
+            **current,
+            "danger":      "Poisonous",
+            "game_over":   "Yes",
+            "health":      "0",
+            "score_delta": str(POISON_PENALTY),
+            "score_total": str(score_total),
+            "reward_text": f"Poison! {POISON_PENALTY} spores · Game Over",
+        }
+        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 = _llm(prompt, ctx) or _fallback_pick(current)
+        return coll, game_over, _append(hist, "assistant", f"💀 {reply}")
+
+    score_delta  = _score_value(current)
+    score_total  = _score_collection(coll) + score_delta
+    picked       = {
+        **current,
+        "picked":      "Yes",
+        "danger":      "Safe",
+        "score_delta": str(score_delta),
+        "score_total": str(score_total),
+        "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 = _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. LLM reveals mystery fragments."""
+    coll = _safe_collection(collection)
+    hist = _safe_history(history)
 
-def follow_story_whisper(current, collection, history, position):
-    legacy_hist = _denormalize_history(history)
-    updated_current, updated_hist = follow_whisper(current, collection, legacy_hist)
-    if isinstance(updated_current, str):
-        updated_current = force_parse_json_or_literal(updated_current)
-    pos = _safe_pos(position)
-    return (
-        updated_current,
-        forest_scene(updated_current, collection, pos),
-        game_status_markdown(updated_current, collection, pos),
-        mushroom_card_from_state(updated_current),
-        _normalize_history(updated_hist),
+    if current is None:
+        return None, _append(hist, "assistant",
+            "Myco cups one ear. The forest only whispers near mushrooms — search a clearing first.")
+
+    ctx = _ctx(current, coll)
+
+    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    = _llm(prompt, ctx) or _fallback_whisper(current)
+    revealed = {**current, **mystery, "whisper_followed": "Yes"}
+    return revealed, _append(hist, "assistant", f"🌌 {reply}")
+
 
-def study_discovery(current, history, collection, position):
-    legacy_hist = _denormalize_history(history)
-    updated_current, updated_hist = study_current(current, legacy_hist)
-    if isinstance(updated_current, str):
-        updated_current = force_parse_json_or_literal(updated_current)
-    pos = _safe_pos(position)
-    return (
-        updated_current,
-        forest_scene(updated_current, collection, pos),
-        game_status_markdown(updated_current, collection, pos),
-        mushroom_card_from_state(updated_current),
-        _normalize_history(updated_hist),
+def study_current(current=None, history=None):
+    """Study mushroom. LLM gives a careful field observation."""
+    hist = _safe_history(history)
+
+    if current is None:
+        return None, _append(hist, "assistant", "Nothing to study yet — find a mushroom first!")
+
+    prompt = (
+        f"Study the mushroom {current.get('name','unknown')} carefully. "
+        "Provide a concise field observation and one hint about its magic or danger."
     )
+    reply = _llm(prompt, _ctx(current, [])) or _fallback_study(current)
+    return reply, _append(hist, "assistant", reply)
+
+
+def eat_current(current=None, collection=None, history=None):
+    """Eating mushrooms raw is always blocked. This dynamic response is now fully driven by Myco AI."""
+    coll = _safe_collection(collection)
+    hist = _safe_history(history)
 
-def move_player(position, direction, current, collection):
-    x, y = _safe_pos(position)
-    if direction == "north": y -= 1
-    elif direction == "south": y += 1
-    elif direction == "west":  x -= 1
-    elif direction == "east":  x += 1
-    pos = _safe_pos((x, y))
-    if isinstance(current, str):
-        current = force_parse_json_or_literal(current)
-    # Moving just updates position — no LLM call, no discovery.
-    # The player clicks Search Clearing when they want to find a mushroom.
-    return (
-        pos,
-        forest_scene(current, collection, pos),
-        game_status_markdown(current, collection, pos),
-        mushroom_card_from_state(current),
-        current,
-        gr.update(),
-        dex_markdown(collection),
-        progress_markdown(collection),
+    if current is None:
+        return coll, _append(hist, "assistant", "There's nothing here to eat!")
+
+    ctx = _ctx(current, coll)
+    prompt = (
+        f"The player is attempting to directly EAT the raw mushroom: {current.get('name','unknown')}. "
+        "This is highly forbidden, unsafe, and unidentified! React as Myco with absolute dynamic panic, "
+        "gently scold them in character for trying something so dangerous, and assertively tell them "
+        "they need to Study it instead of eating it!"
+    )
+    
+    # Classic static text fallback just in case inference drops
+    fallback_reply = (
+        f"No no no! {current.get('name','That')} could be dangerous raw! "
+        "I'll never let you eat an unidentified mushroom. Study it first!"
     )
+    
+    reply = _llm(prompt, ctx) or fallback_reply
+    return coll, _append(hist, "assistant", reply)
 
-def block_unsafe_eating(current, history):
-    legacy_hist = _denormalize_history(history)
-    updated_hist = eat_current(current, legacy_hist)
-    return _normalize_history(updated_hist)
-
-def open_play_tab():
-    return gr.update(selected="play")
-
-def _safe_pos(position):
-    if position is None:
-        return START_POSITION
-    x, y = position
-    return (max(0, min(2, int(x))), max(0, min(2, int(y))))
-
-GUIDE_MARKDOWN = """
-## How to play
-
-1. Go to **🎮 Play** and click **🎮 Search Clearing** to discover a mushroom.
-2. **Myco (the AI) reacts** — read what it senses about the mushroom.
-3. Choose your action:
-   - **🔍 Study** — Myco examines the mushroom and updates its magic field.
-   - **🍄 Pick** — grab it as a game item. Poisonous picks = Game Over!
-   - **📖 Collect** — add it to the MycoDex for safe keeping and score.
-   - **🌌 Follow Whisper** — reveal mystery fragments. Risky on unstudied mushrooms!
-   - **🍽️ Eat?** — Myco will stop you every time (for good reason).
-4. **Ask Myco** anything in the chat — it knows the forest, the mystery, and the mushrooms.
-5. Use **⬆️⬇️⬅️➡️** to move through the 3×3 forest grid.
-
-**Scoring:** Common = 10 spores · Rare = 35 · Legendary = 100 · Poison = −25 + Game Over
-
-**Poisonous mushrooms:** Ghost Gill · Pepper Pixie · Ruby Knuckle · Clockwork Chanterelle
-"""
 
-def build_app():
-    with gr.Blocks(title="Myco — Forest Adventure") as demo:
-        gr.HTML("""
-        <style>
-            .gradio-container { background: #1a1a2e !important; }
-            #forest-scene, #discovery-card { contain: layout style; content-visibility: auto; }
-            .progress-level, .progress-level-inner, .generating { display: none !important; }
-        </style>
-        """)
-
-        current_mushroom = gr.State(None)
-        collection       = gr.State([])
-        player_position  = gr.State(START_POSITION)
-
-        gr.HTML(hero_markdown())
-
-        with gr.Tabs(selected="home") as tabs:
-            with gr.Tab("🏠 Home", id="home"):
-                gr.HTML(home_forest_markdown())
-                start_play_button = gr.Button(
-                    "🌲 Enter the Forest",
-                    variant="primary",
-                    size="lg",
-                    elem_classes=["forest-start-btn"]
-                )
-
-            with gr.Tab("🎮 Play", id="play"):
-                gr.HTML(game_intro_markdown())
-                scene = gr.HTML(forest_scene(None, EMPTY_COLLECTION, START_POSITION), elem_id="forest-scene")
-
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        search_button = gr.Button("🎮 Search Clearing", variant="primary", size="lg")
-                    with gr.Column(scale=1):
-                        gr.Markdown("**Move Myco**")
-                        with gr.Row():
-                            gr.HTML("<div></div>")
-                            north_button = gr.Button("⬆️", size="sm")
-                            gr.HTML("<div></div>")
-                        with gr.Row():
-                            west_button = gr.Button("⬅️", size="sm")
-                            pick_button = gr.Button("🍄 Pick", variant="primary", size="sm")
-                            east_button = gr.Button("➡️", size="sm")
-                        with gr.Row():
-                            gr.HTML("<div></div>")
-                            south_button = gr.Button("⬇️", size="sm")
-                            gr.HTML("<div></div>")
-
-                status = gr.Markdown(game_status_markdown(None, EMPTY_COLLECTION, START_POSITION))
-
-                with gr.Row(equal_height=True, elem_id="discovery-card"):
-                    with gr.Column(scale=2):
-                        gr.Markdown("### 🍄 Current Discovery")
-                        discovery = gr.Markdown(mushroom_card(None))
-                        with gr.Row():
-                            study_button   = gr.Button("🔍 Study",          variant="secondary")
-                            collect_button = gr.Button("🧺 Collect",        variant="secondary")
-                        with gr.Row():
-                            whisper_button = gr.Button("🌌 Follow Whisper", variant="secondary")
-                            eat_button     = gr.Button("🍽️ Eat?",           variant="stop")
-
-                    with gr.Column(scale=3):
-                        gr.Markdown("### 💬 Chat with Myco")
-                        chat = gr.Chatbot(value=cast(Any, _normalize_history(welcome_history())), label="Myco", height=400, show_label=False)
-                        with gr.Row():
-                            prompt = gr.Textbox(placeholder="Ask Myco about this place...", show_label=False, scale=4, lines=1)
-                            ask_button = gr.Button("Ask 🍄", variant="primary", scale=1)
-
-            with gr.Tab("📖 MycoDex"):
-                with gr.Row():
-                    progress = gr.Markdown(progress_markdown(EMPTY_COLLECTION))
-                    dex      = gr.Markdown(dex_markdown(EMPTY_COLLECTION))
-                with gr.Group(elem_classes="myco-image-2"):
-                    gr.Image(value="assets/images/Myco-2.png", show_label=False, container=False, interactive=False)
-
-            with gr.Tab("🗺️ Map"):
-                world_map = gr.HTML(world_map_markdown(EMPTY_COLLECTION))
-
-            with gr.Tab("🧭 Guide"):
-                gr.Markdown(GUIDE_MARKDOWN)
-                with gr.Group(elem_classes="myco-image"):
-                    gr.Image(value="assets/images/Myco.png", show_label=False, container=False, interactive=False)
-
-            with gr.Tab("🍄 Myco"):
-                render_shroom_tab()
-
-        # ── Event wiring ──
-        start_play_button.click(open_play_tab, outputs=[tabs])
-
-        search_button.click(search_forest, inputs=[player_position, collection],
-                            outputs=[scene, status, discovery, current_mushroom, chat, dex, progress], show_progress="hidden")
-
-        ask_button.click(ask_companion, inputs=[prompt, chat, current_mushroom, collection, player_position],
-                         outputs=[prompt, chat], show_progress="hidden")
-        prompt.submit(ask_companion, inputs=[prompt, chat, current_mushroom, collection, player_position],
-                      outputs=[prompt, chat], show_progress="hidden")
-
-        # FIX: each button gets its own .click() with a hardcoded gr.State string
-        # so the direction value is baked in at definition time, not captured from
-        # a loop variable (which would make all four buttons pass "east").
-        north_button.click(move_player, inputs=[player_position, gr.State("north"), current_mushroom, collection],
-                           outputs=[player_position, scene, status, discovery, current_mushroom, chat, dex, progress], show_progress="hidden")
-        south_button.click(move_player, inputs=[player_position, gr.State("south"), current_mushroom, collection],
-                           outputs=[player_position, scene, status, discovery, current_mushroom, chat, dex, progress], show_progress="hidden")
-        west_button.click(move_player, inputs=[player_position, gr.State("west"), current_mushroom, collection],
-                          outputs=[player_position, scene, status, discovery, current_mushroom, chat, dex, progress], show_progress="hidden")
-        east_button.click(move_player, inputs=[player_position, gr.State("east"), current_mushroom, collection],
-                          outputs=[player_position, scene, status, discovery, current_mushroom, chat, dex, progress], show_progress="hidden")
-
-        study_button.click(study_discovery, inputs=[current_mushroom, chat, collection, player_position],
-                           outputs=[current_mushroom, scene, status, discovery, chat], show_progress="hidden")
-
-        collect_button.click(collect_discovery, inputs=[current_mushroom, collection, chat, player_position],
-                             outputs=[collection, scene, status, dex, world_map, chat, progress], show_progress="hidden")
-
-        pick_button.click(pick_discovery, inputs=[current_mushroom, collection, chat, player_position],
-                          outputs=[collection, current_mushroom, scene, status, discovery, dex, world_map, chat, progress], show_progress="hidden")
-
-        whisper_button.click(follow_story_whisper, inputs=[current_mushroom, collection, chat, player_position],
-                             outputs=[current_mushroom, scene, status, discovery, chat], show_progress="hidden")
-
-        eat_button.click(block_unsafe_eating, inputs=[current_mushroom, chat], outputs=[chat], show_progress="hidden")
-
-        demo.queue()
-    return demo
-  
+# Myco narrative
+
+def get_myco_narrative(current=None):
+    # 1. Personality Prompt
+    prompt = (
+        "You are Myco, a tiny, emotional mushroom companion. "
+        "Write a whimsical, mysterious thought about the forest. "
+        "DO NOT use JSON. Do NOT use action tags. Just speak naturally."
+    )
+    
+    context = {}
+    if current:
+        context = {"name": current.get("name"), "rarity": current.get("rarity")}
+    
+    # 2. Get the response
+    reply = _llm(prompt, context=context)
+    
+    # 3. CRITICAL: Aggressive Clean-up
+    # If the LLM ignored our "no JSON" instruction, we parse it ourselves.
+    if reply:
+        # If it's wrapped in JSON, extract the 'thought'
+        if reply.strip().startswith("{"):
+            try:
+                data = json.loads(reply)
+                return data.get("thought", "The forest feels deep today... ✨")
+            except:
+                pass # If it's broken JSON, just return the reply
+        
+        # If it's just raw text, return it
+        return reply
+
+    return "The forest feels deep today... ✨"
+