major update: data saved to hf, user sessions maintain separation, fixed scoring bug

app.py

@@ -5,34 +5,24 @@ from src.models.data_manager import DataManager
 from src.scoring.scorer import Scorer
 from src.scoring.statistics import StatisticsCalculator
 from src.scoring.achievements import AchievementSystem
-from src.session.session_manager import SessionManager
 from src.ui.template_renderer import TemplateRenderer
 from src.ui.page_handlers import PageHandlers
 from src.ui.interface_builder import InterfaceBuilder
 
 class CollaborativeDecodingApp:
     def __init__(self):
-        self.current_prompt = None
-        
-        # Initialize managers
+        # Initialize shared managers (no per-user state)
         self.llm_manager = LLMManager()
         self.similarity_calculator = SimilarityCalculator()
         self.data_manager = DataManager()
         self.scorer = Scorer()
         self.statistics_calculator = StatisticsCalculator()
         self.achievement_system = AchievementSystem()
-        self.session_manager = SessionManager(
-            data_manager=self.data_manager,
-            achievement_system=self.achievement_system
-        )
         
         # Initialize UI components
         self.template_renderer = TemplateRenderer()
         self.page_handlers = PageHandlers(self)
         self.interface_builder = InterfaceBuilder(self, self.page_handlers)
-        
-        # Use session manager's session ID
-        self.session_id = self.session_manager.session_id
 
     def load_data(self):
         self.data_manager.load_prompts_data()
@@ -42,14 +32,15 @@ class CollaborativeDecodingApp:
         self.similarity_calculator.load_model()
 
     def get_random_prompt(self):
-        self.current_prompt = self.data_manager.get_random_prompt()
-        return self.current_prompt
+        """Get a random prompt from the dataset"""
+        return self.data_manager.get_random_prompt()
 
     def validate_user_input(self, user_input):
+        """Validate user input using LLM manager"""
         return self.llm_manager.validate_user_input(user_input)
 
-    def process_submission(self, user_input):
-        """Process user submission and return results"""
+    def process_submission(self, user_input, current_prompt, session_id):
+        """Process user submission and return results with updated state"""
         # Validation
         if not user_input.strip():
             return "Please enter some text to continue the response.", None, None, None, None, None, None
@@ -57,34 +48,34 @@ class CollaborativeDecodingApp:
         if not self.validate_user_input(user_input):
             return "Please keep your input to 5 tokens or less.", None, None, None, None, None, None
         
-        if not self.current_prompt:
+        if not current_prompt:
             return "Error: No prompt loaded. Please refresh the page.", None, None, None, None, None, None
         
         # Generate response
         try:
             generated_response = self.llm_manager.generate_response_from_user_input(
-                self.current_prompt["prompt"],
-                self.current_prompt["llm_partial_response"], 
+                current_prompt["prompt"],
+                current_prompt["llm_partial_response"], 
                 user_input
             )
         except Exception as e:
             return f"Error generating response: {str(e)}", None, None, None, None, None, None
         
         # Calculate similarity score
-        original_full = self.current_prompt["llm_full_response_original"]
+        original_full = current_prompt["llm_full_response_original"]
         cosine_distance = self.similarity_calculator.compute_cosine_distance(original_full, generated_response)
         
         # Save interaction with token count
         num_user_tokens = self.llm_manager.count_tokens(user_input)
-        self.data_manager.save_interaction(
-            self.current_prompt, user_input, generated_response, 
-            cosine_distance, self.session_id, num_user_tokens
+        self.data_manager.save_interaction_to_hf(
+            current_prompt, user_input, generated_response, 
+            cosine_distance, session_id, num_user_tokens
         )
         
         # Calculate additional metrics for results display
-        all_results = self.data_manager.load_results_data()
+        all_results = self.data_manager.get_results()
         prompt_results = self.data_manager.filter_results_by_partial_response(
-            all_results, self.current_prompt["prompt"], self.current_prompt["llm_partial_response"]
+            all_results, current_prompt["prompt"], current_prompt["llm_partial_response"]
         )
         
         # Calculate rank and percentile

data/results.jsonl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b2f25a144bab0f085cf223889a98a9215d578b4069a2a41d9cf545c87e4a9976
-size 219450738

src/models/data_manager.py

@@ -4,14 +4,31 @@ import json
 import os
 import random
 import datetime
+import uuid
+from pathlib import Path
+from datasets import load_dataset
+from huggingface_hub import CommitScheduler
 
 
+JSON_DATASET_DIR = Path("results")
+JSON_DATASET_DIR.mkdir(parents=True, exist_ok=True)
+JSON_DATASET_PATH = JSON_DATASET_DIR / f"results_{uuid.uuid4()}.json"
+
+scheduler = CommitScheduler(
+    repo_id="alon-albalak/collaborative-decoding-results",
+    repo_type="dataset",
+    folder_path=JSON_DATASET_DIR.as_posix(),
+    path_in_repo="data",
+    every=10
+)
+
 class DataManager:
     """Manages loading and saving of prompts and results data"""
     
     def __init__(self):
         self.prompts_data = []
-        
+        self.results = None
+
     def load_prompts_data(self, filepath="data/prompts.jsonl"):
         """Load prompts data from JSONL file"""
         with open(filepath, "r") as f:
@@ -23,6 +40,18 @@ class DataManager:
             raise RuntimeError("No prompts data loaded. Call load_prompts_data() first.")
         return random.choice(self.prompts_data)
     
+    def get_results(self):
+        """Get all results data, loading if not already loaded."""
+        if self.results is None:
+            self.results = self.load_results_from_hf()
+        return self.results
+    
+    def add_results(self, new_results):
+        """Add new results to the existing results list."""
+        if self.results is None:
+            raise RuntimeError("Results not loaded. Call get_results() first.")
+        self.results.extend(new_results)
+
     def load_results_data(self, filepath="data/results.jsonl"):
         """Load all results data from results.jsonl file."""
         results = []
@@ -35,6 +64,15 @@ class DataManager:
             pass  # Return empty list if file doesn't exist
         return results
     
+    def load_results_from_hf(self, hf_repo="alon-albalak/collaborative-decoding-results"):
+        """Load results data from Hugging Face dataset repository."""
+        try:
+            dataset = load_dataset(hf_repo, split="train")
+            return dataset.to_list()
+        except Exception as e:
+            print(f"Error loading dataset from Hugging Face: {e}")
+            return []
+    
     def save_interaction(self, prompt_data, user_continuation, generated_response, 
                         cosine_distance, session_id, num_user_tokens, filepath="data/results.jsonl"):
         """Save a user interaction to the results file"""
@@ -55,6 +93,29 @@ class DataManager:
         with open(filepath, "a") as f:
             f.write(json.dumps(interaction) + "\n")
     
+    def save_interaction_to_hf(self, prompt_data, user_continuation, generated_response, 
+                               cosine_distance, session_id, num_user_tokens):
+        interaction = {
+            "prompt": prompt_data["prompt"],
+            "model": prompt_data["model"],
+            "llm_partial_response": prompt_data["llm_partial_response"],
+            "llm_full_response_original": prompt_data["llm_full_response_original"],
+            "user_continuation": user_continuation,
+            "full_response_from_user": generated_response,
+            "cosine_distance": cosine_distance,
+            "timestamp": datetime.datetime.now().isoformat(),
+            "continuation_source": session_id,
+            "num_user_tokens": num_user_tokens,
+            "continuation_prompt": "",
+            "full_continuation_prompt": ""
+        }
+
+        self.add_results([interaction])
+
+        with scheduler.lock:
+            with open(JSON_DATASET_PATH, "a") as f:
+                f.write(json.dumps(interaction) + "\n")
+
     def filter_results_by_partial_response(self, results, prompt, partial_response):
         """Filter results to only include entries for the current prompt."""
         return [r for r in results if r["prompt"] == prompt and r["llm_partial_response"] == partial_response]
@@ -65,7 +126,7 @@ class DataManager:
     
     def get_gallery_responses(self, min_score=0.3, limit=20):
         """Get gallery responses with minimum creativity score"""
-        all_results = self.load_results_data()
+        all_results = self.get_results()
         
         # Filter by minimum score and sort by score (descending)
         filtered_results = [r for r in all_results if r["cosine_distance"] >= min_score]
@@ -76,7 +137,7 @@ class DataManager:
     
     def get_inspire_me_examples(self, prompt, partial_response, limit=5):
         """Get inspiring examples for the current prompt"""
-        all_results = self.load_results_data()
+        all_results = self.get_results()
         
         # Filter to current prompt and get good examples (≥0.2 score)
         examples = [r for r in all_results 

src/models/llm_manager.py

@@ -5,8 +5,6 @@ import torch
 from transformers import AutoTokenizer, AutoModelForCausalLM
 
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
-HF_TOKEN = os.getenv("HF_TOKEN")
-
 
 class LLMManager:
     """Manages LLM model loading and text generation operations"""
@@ -27,13 +25,13 @@ class LLMManager:
 
         self.device = device
         self.dtype = dtype
-
+        
     def load_models(self, model_name="meta-llama/Llama-3.2-1B-Instruct"):
         """Load the LLM model and tokenizer"""
-        self.tokenizer = AutoTokenizer.from_pretrained(model_name, token=HF_TOKEN)
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
         self.model = AutoModelForCausalLM.from_pretrained(model_name, dtype=self.dtype, low_cpu_mem_usage=True)
         self.model = self.model.to(self.device)
-
+        
         if self.tokenizer.pad_token is None:
             self.tokenizer.pad_token = self.tokenizer.eos_token
     
@@ -86,9 +84,6 @@ class LLMManager:
                 temperature=1.0,
                 pad_token_id=self.tokenizer.eos_token_id
             )
-
-        # Move output back to CPU and decode
-        outputs = outputs.cpu()
         
         full_response = self.tokenizer.decode(outputs[0].cpu(), skip_special_tokens=True)
         assistant_part = full_response.split("Assistant: ")[-1]

src/scoring/scorer.py

@@ -1,8 +1,7 @@
 """Scoring logic and enhanced score display functionality"""
 
 import random
-from typing import List, Optional
-
+from .achievements import AchievementSystem
 
 class Scorer:
     """Handles scoring calculations and display generation"""
@@ -49,7 +48,7 @@ class Scorer:
         # Find rank (1-based)
         rank = None
         for i, score in enumerate(sorted_scores):
-            if abs(score - user_score) < 1e-6:  # Handle floating point precision
+            if user_score >= score:
                 rank = i + 1
                 break
         
@@ -60,7 +59,10 @@ class Scorer:
         if len(sorted_scores) <= 1:
             percentile = 50.0
         else:
-            percentile = (len(sorted_scores) - rank) / len(sorted_scores) * 100
+            # Compute raw percentile: proportion of users the current user is better than.
+            raw_percentile = (len(sorted_scores) - rank) / len(sorted_scores) * 100.0
+            # Ensure percentile is always within 0-100 even if rank is out of expected bounds
+            percentile = max(0.0, min(100.0, raw_percentile))
         
         return rank, percentile
     
@@ -115,7 +117,7 @@ class Scorer:
             html_content += f"""
                 <div class="score-metric">
                     <div class="metric-value">#{rank}</div>
-                    <div class="metric-label">Rank out of {same_category_attempts}</div>
+                    <div class="metric-label">Rank out of {same_category_attempts+1}</div>
                 </div>
                 <div class="score-metric">
                     <div class="metric-value">{percentile:.1f}%</div>
@@ -140,7 +142,6 @@ class Scorer:
         """
         
         # Add achievement titles
-        from .achievements import AchievementSystem
         achievement_system = AchievementSystem()
         achievements = achievement_system.determine_achievement_titles(cosine_distance, user_tokens)
         

src/scoring/statistics.py

@@ -86,7 +86,7 @@ class StatisticsCalculator:
     
     def calculate_session_ranking_stats(self, session_results, data_manager, scorer):
         """Calculate comprehensive ranking statistics for the session."""
-        all_results = data_manager.load_results_data()
+        all_results = data_manager.get_results()
         ranking_stats = {
             "best_rank": None,
             "best_percentile": None,

src/session/session_manager.py

@@ -1,14 +1,13 @@
 """Session management and progress tracking functionality"""
 
 import uuid
-from typing import Dict, List, Optional
 
 
 class SessionManager:
     """Manages user session state and progress tracking"""
     
-    def __init__(self, data_manager=None, achievement_system=None):
-        self.session_id = str(uuid.uuid4())
+    def __init__(self, session_id=None, data_manager=None, achievement_system=None):
+        self.session_id = session_id or str(uuid.uuid4())
         self.data_manager = data_manager
         self.achievement_system = achievement_system
         
@@ -17,7 +16,7 @@ class SessionManager:
         if not self.data_manager:
             return self._get_empty_session_stats()
             
-        all_results = self.data_manager.load_results_data()
+        all_results = self.data_manager.get_results()
         session_results = self.data_manager.filter_results_by_session(all_results, self.session_id)
         
         if not session_results:

src/ui/interface_builder.py

@@ -12,12 +12,17 @@ class InterfaceBuilder:
         self.page_handlers = page_handlers
     
     def create_interface(self):
-        with gr.Blocks(title="Help the LLM be Creative!", css_paths=CSS_PATHS, theme="light") as demo:
+        with gr.Blocks(title="Help the LLM be Creative!", css_paths=CSS_PATHS) as demo:
             
             # Navigation state management
             current_page = gr.State("welcome")
             has_results = gr.State(False)
             
+            # Session and data state management  
+            current_prompt = gr.State(None)
+            session_id = gr.State(None)
+            session_data = gr.State({})
+            
             # Navigation bar
             nav_container = gr.Column(elem_classes=["nav-container"])
             with nav_container:
@@ -68,7 +73,7 @@ class InterfaceBuilder:
                 )
                 
                 tutorial_partial_response_display = gr.Textbox(
-                    label="🤖 Here's my boring start... (help me make it better!)",
+                    label="🤖 Here's the boring start of my response... (help me continue creatively!)",
                     lines=5,
                     interactive=False,
                     elem_classes=["assistant-box"],
@@ -80,7 +85,7 @@ class InterfaceBuilder:
                     with gr.Row():
                         with gr.Column(scale=4):
                             tutorial_user_input = gr.Textbox(
-                                label="✨ Add your creative input here (max 5 tokens)",
+                                label="✨ Continue where my response above leaves off, and then I'll finish the response after you (max 5 tokens)",
                                 placeholder="Type a few words to inspire me...",
                                 lines=2,
                                 elem_classes=["user-box"],
@@ -150,22 +155,22 @@ class InterfaceBuilder:
             creative_page = gr.Column(visible=False)
             with creative_page:
                 prompt_display = gr.Textbox(
-                    label="🎯 Here's what I was asked to write about:",
+                    label="🎯 Here's what I was asked to do:",
                     lines=3,
                     interactive=False,
                     elem_classes=["prompt-box"]
                 )
                 
                 partial_response_display = gr.Textbox(
-                    label="🤖 Here's my boring start... (help me make it better!)",
+                    label="🤖 Here's the boring start of my response... (help me continue creatively!)",
                     lines=5,
                     interactive=False,
                     elem_classes=["assistant-box"]
                 )
                 
                 user_input = gr.Textbox(
-                    label="✨ Add your creative input here (max 5 tokens)",
-                    placeholder="Type a few words to inspire me...",
+                    label="✨ Continue where my response above leaves off, and then I'll finish the response after you (max 5 tokens)",
+                    placeholder="Type a few words to continue my response...",
                     lines=1, # changed to single line so that "enter" submits the request
                     elem_classes=["user-box"]
                 )
@@ -341,7 +346,9 @@ class InterfaceBuilder:
                 tutorial_step_explanation, tutorial_prompt_display, tutorial_partial_response_display,
                 tutorial_input_section, tutorial_results_section, tutorial_user_input, tutorial_token_counter,
                 tutorial_score_display, tutorial_original_response, tutorial_creative_response,
-                tutorial_prev_btn, tutorial_next_btn, tutorial_play_btn
+                tutorial_prev_btn, tutorial_next_btn, tutorial_play_btn,
+                # State variables
+                current_prompt, session_id, session_data
             )
             
             # Demo starts with landing page visible
@@ -362,7 +369,8 @@ class InterfaceBuilder:
                            tutorial_step_explanation, tutorial_prompt_display, tutorial_partial_response_display,
                            tutorial_input_section, tutorial_results_section, tutorial_user_input, tutorial_token_counter,
                            tutorial_score_display, tutorial_original_response, tutorial_creative_response,
-                           tutorial_prev_btn_ref, tutorial_next_btn_ref, tutorial_play_btn_ref):
+                           tutorial_prev_btn_ref, tutorial_next_btn_ref, tutorial_play_btn_ref,
+                           current_prompt, session_id, session_data):
         """Wire up all the event handlers for the interface"""
         
         # Wire up landing page buttons
@@ -379,7 +387,8 @@ class InterfaceBuilder:
         
         skip_to_game_btn.click(
             self.page_handlers.start_game,
-            outputs=[current_page, landing_page, tutorial_page, creative_page, gallery_page, results_page, session_page, nav_welcome, nav_tutorial, nav_creative, nav_gallery, nav_results, nav_session, prompt_display, partial_response_display, inspire_me_display]
+            inputs=[current_prompt, session_id],
+            outputs=[current_page, landing_page, tutorial_page, creative_page, gallery_page, results_page, session_page, nav_welcome, nav_tutorial, nav_creative, nav_gallery, nav_results, nav_session, prompt_display, partial_response_display, inspire_me_display, current_prompt, session_id]
         )
         
         # Wire up gallery button (handled at end of function)
@@ -411,7 +420,8 @@ class InterfaceBuilder:
         
         tutorial_play_btn.click(
             self.page_handlers.load_creative_with_prompt,
-            outputs=[current_page, landing_page, tutorial_page, creative_page, gallery_page, results_page, session_page, nav_welcome, nav_tutorial, nav_creative, nav_gallery, nav_results, nav_session, prompt_display, partial_response_display, inspire_me_display],
+            inputs=[current_prompt, session_id],
+            outputs=[current_page, landing_page, tutorial_page, creative_page, gallery_page, results_page, session_page, nav_welcome, nav_tutorial, nav_creative, nav_gallery, nav_results, nav_session, prompt_display, partial_response_display, inspire_me_display, current_prompt, session_id],
             js="() => { window.scrollTo({ top: 0, behavior: 'smooth' }); }"
         )
         
@@ -445,7 +455,7 @@ class InterfaceBuilder:
             outputs=[submit_btn, loading_message, error_message, landing_page, gallery_page, creative_page, results_page, cosine_distance_display]
         ).then(
             self.page_handlers.on_submit_process,
-            inputs=[user_input],
+            inputs=[user_input, current_prompt, session_id],
             outputs=[submit_btn, loading_message, error_message, landing_page, gallery_page, creative_page, results_page, cosine_distance_display, results_prompt_display, results_partial_display, results_user_input_display, original_response_display, results_continuation_display, violin_plot_display, current_page, has_results, nav_results, nav_session, nav_welcome, nav_tutorial, nav_creative, nav_gallery]
         )
         
@@ -455,7 +465,7 @@ class InterfaceBuilder:
             outputs=[submit_btn, loading_message, error_message, landing_page, gallery_page, creative_page, results_page, cosine_distance_display]
         ).then(
             self.page_handlers.on_submit_process,
-            inputs=[user_input],
+            inputs=[user_input, current_prompt, session_id],
             outputs=[submit_btn, loading_message, error_message, landing_page, gallery_page, creative_page, results_page, cosine_distance_display, results_prompt_display, results_partial_display, results_user_input_display, original_response_display, results_continuation_display, violin_plot_display, current_page, has_results, nav_results, nav_session, nav_welcome, nav_tutorial, nav_creative, nav_gallery]
         )
         
@@ -469,20 +479,21 @@ class InterfaceBuilder:
         # Try new prompt button - new prompt and switch to creative page  
         try_again_new_btn.click(
             self.page_handlers.try_new_prompt,
-            outputs=[current_page, landing_page, tutorial_page, creative_page, gallery_page, results_page, session_page, nav_welcome, nav_tutorial, nav_creative, nav_gallery, nav_results, nav_session, prompt_display, partial_response_display, submit_btn, user_input, loading_message, error_message, inspire_me_display],
+            outputs=[current_page, landing_page, tutorial_page, creative_page, gallery_page, results_page, session_page, nav_welcome, nav_tutorial, nav_creative, nav_gallery, nav_results, nav_session, prompt_display, partial_response_display, submit_btn, user_input, loading_message, error_message, inspire_me_display, current_prompt],
             js="() => { window.scrollTo({ top: 0, behavior: 'smooth' }); }"
         )
 
         # Wire up inspire me button
         inspire_me_btn.click(
             self.page_handlers.show_inspire_me_examples,
+            inputs=[current_prompt],
             outputs=[inspire_me_display]
         )
         
         # Wire up real-time token counter
         user_input.change(
             self.page_handlers.update_token_count,
-            inputs=[user_input, partial_response_display],
+            inputs=[user_input],
             outputs=[token_counter, token_visualization]
         )
         
@@ -501,7 +512,8 @@ class InterfaceBuilder:
         
         nav_creative.click(
             self.page_handlers.load_creative_with_prompt,
-            outputs=[current_page, landing_page, tutorial_page, creative_page, gallery_page, results_page, session_page, nav_welcome, nav_tutorial, nav_creative, nav_gallery, nav_results, nav_session, prompt_display, partial_response_display, inspire_me_display],
+            inputs=[current_prompt, session_id],
+            outputs=[current_page, landing_page, tutorial_page, creative_page, gallery_page, results_page, session_page, nav_welcome, nav_tutorial, nav_creative, nav_gallery, nav_results, nav_session, prompt_display, partial_response_display, inspire_me_display, current_prompt, session_id],
             js="() => { window.scrollTo({ top: 0, behavior: 'smooth' }); }"
         )
         
@@ -520,6 +532,7 @@ class InterfaceBuilder:
         # Update session page when navigating to it
         nav_session.click(
             self.page_handlers.navigate_to_session,
+            inputs=[session_id],
             outputs=[current_page, landing_page, tutorial_page, creative_page, gallery_page, results_page, session_page, nav_welcome, nav_tutorial, nav_creative, nav_gallery, nav_results, nav_session, session_main_stats, session_history_display, session_achievements_display],
             js="() => { window.scrollTo({ top: 0, behavior: 'smooth' }); }"
         )
@@ -530,21 +543,10 @@ class InterfaceBuilder:
             outputs=[current_page, landing_page, tutorial_page, creative_page, gallery_page, results_page, session_page, nav_welcome, nav_tutorial, nav_creative, nav_gallery, nav_results, nav_session],
             js="() => { window.scrollTo({ top: 0, behavior: 'smooth' }); }"
         )
-        
-        # Connect welcome page buttons (duplicate wiring for multiple entry points)
-        skip_to_game_btn.click(
-            self.page_handlers.load_creative_with_prompt,
-            outputs=[current_page, landing_page, tutorial_page, creative_page, gallery_page, results_page, session_page, nav_welcome, nav_tutorial, nav_creative, nav_gallery, nav_results, nav_session, prompt_display, partial_response_display, inspire_me_display],
-            js="() => { window.scrollTo({ top: 0, behavior: 'smooth' }); }"
-        )
-        
-        tutorial_btn.click(
-            self.page_handlers.load_tutorial_with_content,
-            outputs=[current_page, landing_page, tutorial_page, creative_page, gallery_page, results_page, session_page, nav_welcome, nav_tutorial, nav_creative, nav_gallery, nav_results, nav_session, tutorial_step_explanation, tutorial_prompt_display, tutorial_partial_response_display, tutorial_input_section, tutorial_results_section, tutorial_prev_btn_ref, tutorial_next_btn_ref, tutorial_play_btn_ref, tutorial_current_step],
-            js="() => { window.scrollTo({ top: 0, behavior: 'smooth' }); }"
-        )
-        
+
+        # Wire up gallery button from landing page
         gallery_btn.click(
             self.page_handlers.load_gallery_with_content,
-            outputs=[current_page, landing_page, tutorial_page, creative_page, gallery_page, results_page, session_page, nav_welcome, nav_tutorial, nav_creative, nav_gallery, nav_results, nav_session, gallery_display]
+            outputs=[current_page, landing_page, tutorial_page, creative_page, gallery_page, results_page, session_page, nav_welcome, nav_tutorial, nav_creative, nav_gallery, nav_results, nav_session, gallery_display],
+            js="() => { window.scrollTo({ top: 0, behavior: 'smooth' }); }"
         )

src/ui/page_handlers.py

@@ -1,7 +1,9 @@
 """Page handling and navigation functionality"""
+import uuid
 
 import gradio as gr
 from ..config.settings import TUTORIAL_EXAMPLE
+from ..session.session_manager import SessionManager
 
 
 class PageHandlers:
@@ -116,14 +118,14 @@ class PageHandlers:
         
         return gallery_html
     
-    def show_inspire_me_examples(self):
+    def show_inspire_me_examples(self, current_prompt):
         """Show new random inspiring examples for current prompt"""
-        if not self.app.current_prompt:
+        if not current_prompt:
             return ""
         
         examples = self.app.data_manager.get_inspire_me_examples(
-            self.app.current_prompt["prompt"],
-            self.app.current_prompt["llm_partial_response"],
+            current_prompt["prompt"],
+            current_prompt["llm_partial_response"],
             limit=5
         )
         
@@ -269,21 +271,31 @@ class PageHandlers:
             prev_step  # Update tutorial step
         )
     
-    def start_game(self):
-        """Start the game"""
-        prompt_data = self.app.get_random_prompt()
+    def start_game(self, current_prompt, session_id):
+        """Start the game with state management"""
+        
+        # Initialize session if needed
+        if session_id is None:
+            session_id = str(uuid.uuid4())
+        
+        # Get new prompt if needed
+        if current_prompt is None:
+            current_prompt = self.app.get_random_prompt()
+        
         # Load initial inspire me examples
         initial_examples = self.app.data_manager.get_inspire_me_examples(
-            prompt_data["prompt"],
-            prompt_data["llm_partial_response"],
+            current_prompt["prompt"],
+            current_prompt["llm_partial_response"],
             limit=5
         )
         inspire_html = self.generate_inspire_me_html(initial_examples)
         switch_result = self.switch_to_page("creative", update_nav=False)
         return switch_result + (
-            prompt_data['prompt'],
-            prompt_data['llm_partial_response'],
-            inspire_html
+            current_prompt['prompt'],
+            current_prompt['llm_partial_response'],
+            inspire_html,
+            current_prompt,
+            session_id
         )
     
     def back_to_landing(self):
@@ -291,7 +303,7 @@ class PageHandlers:
         result = self.switch_to_page("welcome", update_nav=True)
         return result + ("",)  # Add empty gallery_display as the 14th output
     
-    def update_token_count(self, text, partial_response=""):
+    def update_token_count(self, text):
         """Update token counter and visual tokens in real-time"""
         if not text.strip():
             return (
@@ -360,8 +372,8 @@ class PageHandlers:
             gr.update()
         )
     
-    def on_submit_process(self, user_text):
-        result = self.app.process_submission(user_text)
+    def on_submit_process(self, user_text, current_prompt, session_id):
+        result = self.app.process_submission(user_text, current_prompt, session_id)
         generated_response, cosine_distance, rank, percentile, mean_score, violin_plot, prompt_results = result
         
         if "Error:" in generated_response or "Please" in generated_response:
@@ -410,10 +422,10 @@ class PageHandlers:
             gr.update(visible=False),                       # creative_page (hide)
             gr.update(visible=True),                        # results_page (show)
             gr.update(visible=True, value=score_text),      # cosine_distance_display
-            gr.update(value=self.app.current_prompt['prompt']), # results_prompt_display
-            gr.update(value=self.app.current_prompt['llm_partial_response']), # results_partial_display
+            gr.update(value=current_prompt['prompt']), # results_prompt_display
+            gr.update(value=current_prompt['llm_partial_response']), # results_partial_display
             gr.update(value=user_text),                     # results_user_input_display
-            gr.update(value=self.app.current_prompt['llm_full_response_original']), # original_response_display
+            gr.update(value=current_prompt['llm_full_response_original']), # original_response_display
             gr.update(value=generated_response),          # results_continuation_display
             gr.update(visible=True, value=violin_plot) if violin_plot else gr.update(visible=False),  # violin_plot_display
             "results",                                       # current_page state
@@ -438,35 +450,43 @@ class PageHandlers:
         )
     
     def try_new_prompt(self):
-        prompt_data = self.app.get_random_prompt()
+        new_prompt = self.app.get_random_prompt()
         initial_examples = self.app.data_manager.get_inspire_me_examples(
-            prompt_data["prompt"],
-            prompt_data["llm_partial_response"],
+            new_prompt["prompt"],
+            new_prompt["llm_partial_response"],
             limit=5
         )
         inspire_html = self.generate_inspire_me_html(initial_examples)
         switch_result = self.switch_to_page("creative")
         return switch_result + (
-            prompt_data['prompt'],       # prompt_display
-            prompt_data['llm_partial_response'], # partial_response_display
+            new_prompt['prompt'],       # prompt_display
+            new_prompt['llm_partial_response'], # partial_response_display
             gr.update(interactive=True), # submit_btn
             "",                         # user_input (clear)
             gr.update(visible=False),   # loading_message
             gr.update(visible=False),   # error_message
-            inspire_html                # inspire_me_display
+            inspire_html,               # inspire_me_display
+            new_prompt                  # current_prompt state update
         )
     
-    def load_creative_with_prompt(self):
+    def load_creative_with_prompt(self, current_prompt, session_id):
         """Load creative page with a new prompt"""
-        prompt_data = self.app.get_random_prompt()
+        
+        # Initialize session if needed
+        if session_id is None:
+            session_id = str(uuid.uuid4())
+            
+        # Get new prompt (if none provided)
+        if current_prompt is None:
+            current_prompt = self.app.get_random_prompt()
         initial_examples = self.app.data_manager.get_inspire_me_examples(
-            prompt_data["prompt"],
-            prompt_data["llm_partial_response"],
+            current_prompt["prompt"],
+            current_prompt["llm_partial_response"],
             limit=5
         )
         inspire_html = self.generate_inspire_me_html(initial_examples)
         switch_result = self.switch_to_page("creative")
-        return switch_result + (prompt_data['prompt'], prompt_data['llm_partial_response'], inspire_html)
+        return switch_result + (current_prompt['prompt'], current_prompt['llm_partial_response'], inspire_html, current_prompt, session_id)
     
     def load_gallery_with_content(self):
         """Load gallery page with gallery content"""
@@ -491,8 +511,16 @@ class PageHandlers:
             1  # Reset tutorial step to 1
         )
     
-    def navigate_to_session(self):
-        main_stats, history, achievements = self.app.session_manager.generate_session_page_html(
+    def navigate_to_session(self, session_id):
+        
+        # Create session manager instance with session_id
+        session_manager = SessionManager(
+            session_id=session_id,
+            data_manager=self.app.data_manager,
+            achievement_system=self.app.achievement_system
+        )
+        
+        main_stats, history, achievements = session_manager.generate_session_page_html(
             self.app.template_renderer,
             self.app.statistics_calculator,
             self.app.scorer