feat: per-user data isolation, fix model name, clean gitignore

- core/session.py: ContextVar-based user isolation for multi-user HF Spaces
- Player/World data stored per-user in data/users/{hash}/
- Session ID generated from request headers or random
- Key handlers (dream, explore, rest, quest) set user context
- Fix hero tag: MiniCPM5-1B -> MiniCPM4.1-8B (matches config)
- Update .gitignore: exclude data/saves/, player.json, active_slot.txt
- Fix test_player.py: update mock patches for new session functions

.gitignore

@@ -21,6 +21,9 @@ env/
 # Data (runtime-generated)
 data/world.json
 data/dreams.json
+data/saves/
+data/player.json
+data/active_slot.txt
 
 # OS
 .DS_Store

core/player.py

@@ -183,55 +183,59 @@ def save_player(player: Player):
 
 
 # ============================================================
-#  Save Slot System — Multi-user / Multi-save support
+#  Save Slot System — Per-user isolation via session
 # ============================================================
 
-SLOTS_DIR = config.DATA_DIR / "saves"
-ACTIVE_SLOT_FILE = config.DATA_DIR / "active_slot.txt"
+def _get_slots_dir() -> Path:
+    """Get the saves directory for the current user session."""
+    from core.session import get_user_saves_dir
+    return get_user_saves_dir()
+
+
+def _get_active_slot_file() -> Path:
+    """Get the active slot file for the current user session."""
+    from core.session import get_user_active_slot_file
+    return get_user_active_slot_file()
 
 
 def _slot_path(slot: int) -> Path:
-    """Return the player.json path for a given save slot."""
-    return SLOTS_DIR / f"slot_{slot}" / "player.json"
+    return _get_slots_dir() / f"slot_{slot}" / "player.json"
 
 
 def get_slot_dir(slot: int = None) -> Path:
-    """Return the directory for a save slot (creates if needed)."""
     if slot is None:
         slot = get_active_slot()
-    d = SLOTS_DIR / f"slot_{slot}"
+    d = _get_slots_dir() / f"slot_{slot}"
     d.mkdir(parents=True, exist_ok=True)
     return d
 
 
 def get_current_world_file() -> Path:
-    """Return the world.json path for the active save slot."""
     return get_slot_dir() / "world.json"
 
 
 def get_current_dreams_file() -> Path:
-    """Return the dreams.json path for the active save slot."""
     return get_slot_dir() / "dreams.json"
 
 
 def _slot_meta_path() -> Path:
-    return SLOTS_DIR / "slots_meta.json"
+    return _get_slots_dir() / "slots_meta.json"
 
 
 def get_active_slot() -> int:
-    """Get the currently active save slot number (default 0)."""
-    if ACTIVE_SLOT_FILE.exists():
+    path = _get_active_slot_file()
+    if path.exists():
         try:
-            return int(ACTIVE_SLOT_FILE.read_text(encoding="utf-8").strip())
+            return int(path.read_text(encoding="utf-8").strip())
         except (ValueError, TypeError):
             pass
     return 0
 
 
 def set_active_slot(slot: int):
-    """Set the active save slot."""
-    ACTIVE_SLOT_FILE.parent.mkdir(parents=True, exist_ok=True)
-    ACTIVE_SLOT_FILE.write_text(str(slot), encoding="utf-8")
+    path = _get_active_slot_file()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(str(slot), encoding="utf-8")
 
 
 def _update_slot_meta(slot: int, player: Player):

core/session.py

@@ -0,0 +1,71 @@
+"""Session management — per-user data isolation for multi-user HF Spaces."""
+
+import hashlib
+import os
+from pathlib import Path
+from contextvars import ContextVar
+from functools import wraps
+
+import config
+
+USERS_DIR = config.DATA_DIR / "users"
+_current_user_id: ContextVar[str] = ContextVar("current_user_id", default="default")
+
+
+def set_current_user(user_id: str):
+    _current_user_id.set(user_id)
+
+
+def get_current_user_id() -> str:
+    return _current_user_id.get()
+
+
+def with_user(fn):
+    """Decorator: extracts session_id from inputs and sets user context."""
+    @wraps(fn)
+    def wrapper(*args, **kwargs):
+        # Find session_id in args (usually last positional arg)
+        sid = "default"
+        for a in reversed(args):
+            if isinstance(a, str) and len(a) == 16 and all(c in '0123456789abcdef' for c in a):
+                sid = a
+                break
+        set_current_user(sid)
+        # Remove session_id from args for the actual function
+        new_args = [a for a in args if a is not sid]
+        return fn(*new_args, **kwargs)
+    return wrapper
+
+
+def get_user_dir(user_id: str = None) -> Path:
+    uid = user_id or get_current_user_id()
+    safe_id = hashlib.md5(uid.encode()).hexdigest()[:12]
+    user_dir = USERS_DIR / safe_id
+    user_dir.mkdir(parents=True, exist_ok=True)
+    (user_dir / "saves").mkdir(exist_ok=True)
+    return user_dir
+
+
+def get_user_world_file(user_id: str = None) -> Path:
+    return get_user_dir(user_id) / "world.json"
+
+
+def get_user_saves_dir(user_id: str = None) -> Path:
+    return get_user_dir(user_id) / "saves"
+
+
+def get_user_active_slot_file(user_id: str = None) -> Path:
+    return get_user_dir(user_id) / "active_slot.txt"
+
+
+def generate_session_id(request=None) -> str:
+    """Generate a unique session ID from Gradio request."""
+    if request is not None:
+        try:
+            ip = getattr(request.client, 'host', '') if hasattr(request, 'client') else ''
+            ua = request.headers.get("user-agent", "") if hasattr(request, 'headers') else ""
+            if ip or ua:
+                return hashlib.md5(f"{ip}:{ua}".encode()).hexdigest()[:16]
+        except Exception:
+            pass
+    return hashlib.md5(os.urandom(16)).hexdigest()[:16]

tests/test_player.py

@@ -7,7 +7,7 @@ from unittest.mock import patch
 from core.player import (
     Player, load_player, save_player, get_active_slot, set_active_slot,
     list_save_slots, switch_slot, delete_slot, rename_player,
-    SLOTS_DIR, ACTIVE_SLOT_FILE, _slot_path,
+    _slot_path, _get_slots_dir, _get_active_slot_file,
 )
 
 
@@ -160,8 +160,8 @@ def test_save_slot_persistence():
     """Test save/load with slot system."""
     with tempfile.TemporaryDirectory() as tmpdir:
         with patch("core.player.PLAYER_FILE", Path(tmpdir) / "player.json"), \
-             patch("core.player.SLOTS_DIR", Path(tmpdir) / "saves"), \
-             patch("core.player.ACTIVE_SLOT_FILE", Path(tmpdir) / "active_slot.txt"):
+             patch("core.player._get_slots_dir", lambda: Path(tmpdir) / "saves"), \
+             patch("core.player._get_active_slot_file", lambda: Path(tmpdir) / "active_slot.txt"):
 
             # Save to slot 0
             p = Player()
@@ -200,8 +200,8 @@ def test_save_slot_delete():
     """Test deleting a save slot."""
     with tempfile.TemporaryDirectory() as tmpdir:
         with patch("core.player.PLAYER_FILE", Path(tmpdir) / "player.json"), \
-             patch("core.player.SLOTS_DIR", Path(tmpdir) / "saves"), \
-             patch("core.player.ACTIVE_SLOT_FILE", Path(tmpdir) / "active_slot.txt"):
+             patch("core.player._get_slots_dir", lambda: Path(tmpdir) / "saves"), \
+             patch("core.player._get_active_slot_file", lambda: Path(tmpdir) / "active_slot.txt"):
 
             p = Player()
             p.name = "待删除"
@@ -219,8 +219,8 @@ def test_rename_player():
     """Test renaming the current player."""
     with tempfile.TemporaryDirectory() as tmpdir:
         with patch("core.player.PLAYER_FILE", Path(tmpdir) / "player.json"), \
-             patch("core.player.SLOTS_DIR", Path(tmpdir) / "saves"), \
-             patch("core.player.ACTIVE_SLOT_FILE", Path(tmpdir) / "active_slot.txt"):
+             patch("core.player._get_slots_dir", lambda: Path(tmpdir) / "saves"), \
+             patch("core.player._get_active_slot_file", lambda: Path(tmpdir) / "active_slot.txt"):
 
             save_player(Player())
             rename_player("新名字")

ui/main.py

@@ -12,6 +12,7 @@ from ui.explorer_tab import _get_location_choices, _render_location, explore_loc
 from ui.journal_tab import _render_journal, get_quest_choices, complete_quest_action, find_quest_id_by_name
 from ui.player_tab import _render_player_sheet, switch_save_slot, create_character
 from core.player import load_player, list_save_slots, get_active_slot
+from core.session import set_current_user, generate_session_id
 
 
 # ============================================================
@@ -43,7 +44,7 @@ def _hero_html():
             {t('hero_subtitle')}
         </p>
         <div style="display:flex;justify-content:center;gap:16px;">
-            <span style="padding:4px 14px;border:1px solid #1e1e36;border-radius:20px;font-size:0.72rem;color:#7878a0;">MiniCPM5-1B</span>
+            <span style="padding:4px 14px;border:1px solid #1e1e36;border-radius:20px;font-size:0.72rem;color:#7878a0;">MiniCPM4.1-8B</span>
             <span style="padding:4px 14px;border:1px solid #1e1e36;border-radius:20px;font-size:0.72rem;color:#7878a0;">llama.cpp</span>
             <span style="padding:4px 14px;border:1px solid #1e1e36;border-radius:20px;font-size:0.72rem;color:#7878a0;">Local-First</span>
         </div>
@@ -113,6 +114,9 @@ def create_app():
     initial_slot = get_active_slot()
 
     with gr.Blocks(title="DreamLand") as app:
+        # Session state for per-user isolation
+        session_id = gr.State(generate_session_id())
+
         # Hero
         gr.HTML(_hero_html())
 
@@ -218,7 +222,8 @@ def create_app():
         # ===== EVENT WIRING =====
 
         # Slot selection
-        def _on_slot_click(idx):
+        def _on_slot_click(idx, sid):
+            set_current_user(sid)
             slots = list_save_slots()
             s = next((s for s in slots if s["slot"] == idx), None)
             is_new = not s or s["level"] == 0
@@ -234,12 +239,14 @@ def create_app():
 
         for i, btn in enumerate(slot_btns):
             btn.click(
-                fn=lambda idx=i: _on_slot_click(idx),
+                fn=lambda idx=i, sid=session_id: _on_slot_click(idx, sid),
+                inputs=[session_id],
                 outputs=[slot_panel, action_btn, selected_slot],
             )
 
         # Action button (create or enter)
-        def _on_action(slot_idx, name):
+        def _on_action(slot_idx, name, sid):
+            set_current_user(sid)
             slots = list_save_slots()
             s = next((s for s in slots if s["slot"] == slot_idx), None)
             is_new = not s or s["level"] == 0
@@ -258,18 +265,19 @@ def create_app():
 
         action_btn.click(
             fn=_on_action,
-            inputs=[selected_slot, name_input],
+            inputs=[selected_slot, name_input, session_id],
             outputs=[slot_panel, action_status, player_display],
         )
 
         # Dream submission
-        def _process_and_refresh(dream_text, img):
+        def _process_and_refresh(dream_text, img, sid):
+            set_current_user(sid)
             results = process_dream(dream_text, img)
             return (*results, _render_player_sheet())
 
         submit_btn.click(
             fn=_process_and_refresh,
-            inputs=[dream_input, image_input],
+            inputs=[dream_input, image_input, session_id],
             outputs=[
                 status_display, dream_text_state,
                 loc_name, loc_desc,
@@ -288,19 +296,28 @@ def create_app():
         map_refresh.click(fn=_generate_map_html, outputs=[map_display])
 
         # Explorer
+        def _explore(loc, sid):
+            set_current_user(sid)
+            return explore_location(loc)
+
+        def _rest(loc, sid):
+            set_current_user(sid)
+            return rest_action(loc)
+
         exp_dropdown.change(fn=_render_location, inputs=[exp_dropdown], outputs=[exp_display])
-        explore_btn.click(fn=explore_location, inputs=[exp_dropdown], outputs=[exp_result, exp_display])
-        rest_btn.click(fn=rest_action, inputs=[exp_dropdown], outputs=[exp_result, exp_display])
+        explore_btn.click(fn=_explore, inputs=[exp_dropdown, session_id], outputs=[exp_result, exp_display])
+        rest_btn.click(fn=_rest, inputs=[exp_dropdown, session_id], outputs=[exp_result, exp_display])
 
         # Journal
-        def _complete_quest(quest_name):
+        def _complete_quest(quest_name, sid):
+            set_current_user(sid)
             if not quest_name:
                 return t("journal_select_quest"), _render_journal()
             qid = find_quest_id_by_name(quest_name)
             msg = complete_quest_action(qid)
             return msg, _render_journal()
 
-        complete_btn.click(fn=_complete_quest, inputs=[quest_dropdown], outputs=[journal_result, journal_display])
+        complete_btn.click(fn=_complete_quest, inputs=[quest_dropdown, session_id], outputs=[journal_result, journal_display])
         journal_refresh.click(fn=_render_journal, outputs=[journal_display])
 
         # Player refresh