Implement core game mechanics and UI for murder mystery investigation

- Added game engine with GameInstance class to manage game state, rounds, and suspect interactions.
- Integrated LLMManager for handling AI agents representing suspects and the detective.
- Developed scenario generator to load predefined crime scenarios based on difficulty.
- Created tools for investigation, including location tracking, footage retrieval, and DNA testing.
- Established a session management system to track active game instances.
- Designed prompts for different roles (detective, murderer, witness) to guide AI responses.
- Implemented a test suite to validate game logic and agent interactions.
- Developed basic UI components and styles for displaying evidence and suspect information.
- Added scenarios for various difficulty levels, including "The Gallery Heist Gone Wrong" and "The Coffee Shop Murder".

.gitignore

@@ -1 +1,5 @@
-.mddd
+.mddd
+.env
+__pycache__/
+.vscode/
+game/__pycache__/

GEMINI.md

@@ -0,0 +1,56 @@
+# Murder.Ai Project Context
+
+## Project Overview
+**Murder.Ai** is an AI-powered murder mystery game designed as a Gradio application. In this game, Large Language Models (LLMs) take on specific roles—Detective, Murderer, and Witnesses—to generate and solve unique crime scenarios.
+
+The core concept involves an "MCP Story Generator" that creates consistent murder mystery cases. Users can watch the AI agents interact in "Spectator Mode" or actively participate in "Interactive Mode". The project is intended for deployment on Hugging Face Spaces.
+
+## Current Status
+The project is currently in the **initialization phase**.
+- **Detailed Plan:** A comprehensive design document exists in `PLan.md` outlining the game flow, data structures, and UI design.
+- **Implementation:** The `app.py` file is currently a basic "Hello World" Gradio placeholder. The folder structure and core logic defined in the plan have not yet been implemented.
+
+## Architecture & Design
+Based on `PLan.md`, the target architecture includes:
+
+### Tech Stack
+- **Frontend:** Gradio 5.x with custom HTML/CSS/JS.
+- **Backend:** Python 3.11+ with FastAPI (embedded in Gradio).
+- **AI/LLM:** Integration with Anthropic Claude, OpenAI GPT-4, Google Gemini, and Meta Llama.
+- **Tools:** Model Context Protocol (MCP) tools for in-game actions like `get_location`, `get_footage`, and `get_dna_test`.
+
+### Planned Structure
+The roadmap suggests the following structure (to be implemented):
+```
+murder-ai/
+├── app.py                 # Main Gradio app
+├── requirements.txt       # Dependencies
+├── game/                  # Game logic (scenario generator, engine, LLM manager)
+├── mcp/                   # MCP tool definitions and server
+├── ui/                    # Custom Gradio components and styles
+├── prompts/               # Role-specific system prompts
+├── scenarios/             # Pre-scripted fallback cases
+└── assets/                # Images and media
+```
+
+## Development Conventions
+
+### Building & Running
+Since the project is a Gradio app:
+1.  **Install Dependencies:** (When `requirements.txt` is created)
+    ```bash
+    pip install -r requirements.txt
+    ```
+2.  **Run the Application:**
+    ```bash
+    python app.py
+    ```
+    or
+    ```bash
+    gradio app.py
+    ```
+
+### Key Directives
+- **Follow the Plan:** All development should align with the specifications in `PLan.md`.
+- **Gradio 5:** Use the latest Gradio features, particularly for custom UI components and state management.
+- **MCP Integration:** Tools should be designed to simulate real investigative data retrieval.

PLan.md

@@ -777,7 +777,7 @@ Deployment: HuggingFace Space
 
 ```yaml
 Frontend:
-  - Gradio 5.x (required)
+  - Gradio 6.x (required)
   - Custom HTML/CSS blocks for beautiful UI
   - JavaScript for animations
 
@@ -808,7 +808,7 @@ Deployment:
   - Modal for compute-heavy tasks (optional, for sponsor prize)
 
 Dependencies:
-  - gradio>=5.0
+  - gradio>=6.0
   - anthropic
   - openai  
   - google-generativeai
@@ -862,7 +862,7 @@ murder-ai/
 
 ## 🎨 **GRADIO UI ARCHITECTURE**
 
-### **Modern Gradio 5 Approach:**
+### **Modern Gradio 6 Approach:**
 
 ```python
 import gradio as gr
@@ -895,7 +895,7 @@ custom_css = """
 
 # Main Gradio Interface
 ```python
-with gr.Blocks(css=custom_css, theme=gr.themes.Noir()) as demo:
+with gr.Blocks() as demo:
     
     gr.Markdown("# 🕵️ MURDER.AI")
     
@@ -947,5 +947,8 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Noir()) as demo:
         outputs=[game_state, chatbot, tool_output, evidence_board]
     )
 
-demo.launch()
+demo.launch(
+    theme=gr.themes.Noir(),
+    css=custom_css
+)
 ```

README.md

@@ -13,3 +13,4 @@ tags:
   - building-mcp-track-creative
   - mcp-in-action-track-creative
 ---
+- Read `PLan.md`

app.py

@@ -1,7 +1,228 @@
 import gradio as gr
+import os
+from game import game_engine
 
-def greet(name):
-    return "Hello " + name + "!!"
+# Load CSS
+with open("ui/styles.css", "r") as f:
+    custom_css = f.read()
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+def get_current_game(session_id):
+    if not session_id:
+        return None
+    return game_engine.get_game(session_id)
+
+def format_suspect_card(suspect):
+    """Generates HTML for a suspect card."""
+    return f"""
+    <div class="suspect-card">
+        <h3>{suspect['name']}</h3>
+        <p><strong>Role:</strong> {suspect['role']}</p>
+        <p><strong>Bio:</strong> {suspect['bio']}</p>
+        <p>ID: {suspect['id']}</p>
+    </div>
+    """
+
+def start_new_game_ui(difficulty):
+    """Starts a new game and returns initial UI state."""
+    session_id, game = game_engine.start_game(difficulty)
+    
+    # Generate Suspect Cards HTML
+    cards = [format_suspect_card(s) for s in game.scenario["suspects"]]
+    # Pad if fewer than 4 (though scenarios have 4)
+    while len(cards) < 4:
+        cards.append("")
+        
+    # Initial Evidence Board
+    evidence_html = f"<h3>Case: {game.scenario['title']}</h3><p>Victim: {game.scenario['victim']['name']}</p><hr>"
+    
+    # Initial Chat
+    initial_chat = [
+        ("System", f"CASE FILE LOADED: {game.scenario['title']}"),
+        ("System", f"Victim: {game.scenario['victim']['name']}"),
+        ("System", f"Time of Death: {game.scenario['victim']['time_of_death']}")
+    ]
+    
+    return (
+        session_id,
+        cards[0], cards[1], cards[2], cards[3], # Suspect cards
+        initial_chat, # Chatbot
+        evidence_html, # Evidence board
+        f"Round: {game.round}/5 | Points: {game.points}", # Stats
+        gr.update(choices=[(s['name'], s['id']) for s in game.scenario["suspects"]], value=None), # Suspect dropdown
+        gr.update(interactive=True), # Question input
+        gr.update(interactive=True), # Question btn
+        gr.update(interactive=True)  # Tool btn
+    )
+
+def submit_question(session_id, suspect_id, question, history):
+    game = get_current_game(session_id)
+    if not game:
+        return history, "Error: No active game."
+    
+    if not suspect_id:
+        return history, "Error: Select a suspect first."
+        
+    if not question:
+        return history, "Error: Enter a question."
+
+    response = game.question_suspect(suspect_id, question)
+    
+    # Update chat
+    # Gradio chatbot format: list of [user_msg, bot_msg] or tuples. 
+    # But here we have a multi-actor chat. 
+    # Gradio's 'messages' type chatbot is better for this, but let's stick to standard
+    # tuple list (User, Bot) for simplicity, or just append to history.
+    # The plan said "Color-coded by speaker", implies standard Chatbot might be limiting
+    # if we want "Detective: ...", "Suspect: ...".
+    # We'll use (Speaker, Message) format and let Gradio handle it, 
+    # or format it as "Speaker: Message" in the bubble.
+    
+    history.append(("Detective", f"To {suspect_id}: {question}"))
+    history.append((suspect_id, response))
+    
+    return history, "" # Clear input
+
+def use_tool_ui(session_id, tool_name, arg1, arg2, history):
+    game = get_current_game(session_id)
+    if not game:
+        return history, "No game", "Error"
+        
+    # Construct kwargs based on tool
+    kwargs = {}
+    if tool_name == "get_location":
+        kwargs = {"phone_number": arg1, "timestamp": arg2}
+    elif tool_name == "get_footage":
+        kwargs = {"location": arg1, "time_range": arg2}
+    elif tool_name == "get_dna_test":
+        kwargs = {"evidence_id": arg1}
+    elif tool_name == "call_alibi":
+        kwargs = {"phone_number": arg1}
+        
+    result = game.use_tool(tool_name, **kwargs)
+    
+    # Update History
+    history.append(("System", f"Used {tool_name}: {result}"))
+    
+    # Update Evidence Board
+    ev_html = f"<h3>Case: {game.scenario['title']}</h3><p>Victim: {game.scenario['victim']['name']}</p><hr><h4>Evidence Revealed:</h4><ul>"
+    for item in game.evidence_revealed:
+        ev_html += f"<li>{str(item)}</li>"
+    ev_html += "</ul>"
+    
+    stats = f"Round: {game.round}/5 | Points: {game.points}"
+    
+    return history, ev_html, stats
+
+def next_round_ui(session_id):
+    game = get_current_game(session_id)
+    if not game:
+        return "No game", "Error"
+        
+    not_over = game.advance_round()
+    stats = f"Round: {game.round}/5 | Points: {game.points}"
+    
+    if not not_over:
+        stats += " [GAME OVER]"
+        
+    return stats
+
+
+# --- UI LAYOUT ---
+
+with gr.Blocks(title="Murder.Ai") as demo:
+    
+    gr.Markdown("# 🕵️ MURDER.AI")
+    
+    session_state = gr.State("")
+    
+    with gr.Row():
+        # Left: Suspect Cards
+        with gr.Column(scale=1):
+            gr.Markdown("## Suspects")
+            suspect_1 = gr.HTML(elem_classes="suspect-card")
+            suspect_2 = gr.HTML(elem_classes="suspect-card")
+            suspect_3 = gr.HTML(elem_classes="suspect-card")
+            suspect_4 = gr.HTML(elem_classes="suspect-card")
+        
+        # Center: Main Game Area
+        with gr.Column(scale=2):
+            game_stats = gr.Markdown("Round: 0/5 | Points: 10")
+            
+            chatbot = gr.Chatbot(
+                label="Investigation Log",
+                height=500,
+                type="messages" # Gradio 5/6 new format
+            )
+            
+            with gr.Row():
+                suspect_dropdown = gr.Dropdown(label="Select Suspect", choices=[])
+                question_input = gr.Textbox(label="Question", placeholder="Where were you?", interactive=False)
+                ask_btn = gr.Button("Ask", variant="secondary", interactive=False)
+            
+            gr.Markdown("### Tools")
+            with gr.Row():
+                tool_dropdown = gr.Dropdown(
+                    label="Select Tool", 
+                    choices=["get_location", "get_footage", "get_dna_test", "call_alibi"],
+                    value="get_location"
+                )
+                arg1_input = gr.Textbox(label="Arg 1 (Phone/Loc/ID)")
+                arg2_input = gr.Textbox(label="Arg 2 (Time)")
+                use_tool_btn = gr.Button("Use Tool", interactive=False)
+
+            next_round_btn = gr.Button("▶️ Next Round / End Game")
+            
+        # Right: Evidence Board
+        with gr.Column(scale=1):
+            gr.Markdown("## Evidence Board")
+            evidence_board = gr.HTML(
+                elem_classes="evidence-board",
+                value="<p>No active case.</p>"
+            )
+    
+    # Start Controls
+    with gr.Row():
+        difficulty_selector = gr.Radio(["Easy", "Medium", "Hard"], label="Difficulty", value="Medium")
+        start_btn = gr.Button("🎲 GENERATE NEW CASE", variant="primary")
+
+    # --- EVENTS ---
+    
+    start_btn.click(
+        fn=start_new_game_ui,
+        inputs=[difficulty_selector],
+        outputs=[
+            session_state,
+            suspect_1, suspect_2, suspect_3, suspect_4,
+            chatbot,
+            evidence_board,
+            game_stats,
+            suspect_dropdown,
+            question_input,
+            ask_btn,
+            use_tool_btn
+        ]
+    )
+    
+    ask_btn.click(
+        fn=submit_question,
+        inputs=[session_state, suspect_dropdown, question_input, chatbot],
+        outputs=[chatbot, question_input]
+    )
+    
+    use_tool_btn.click(
+        fn=use_tool_ui,
+        inputs=[session_state, tool_dropdown, arg1_input, arg2_input, chatbot],
+        outputs=[chatbot, evidence_board, game_stats]
+    )
+    
+    next_round_btn.click(
+        fn=next_round_ui,
+        inputs=[session_state],
+        outputs=[game_stats]
+    )
+
+demo.launch(
+    theme=gr.themes.Noir(),
+    css=custom_css,
+    allowed_paths=["."]
+)

game/game_engine.py

@@ -0,0 +1,134 @@
+import uuid
+from .scenario_generator import generate_crime_scenario
+from .llm_manager import LLMManager
+from mcp import tools
+
+class GameInstance:
+    def __init__(self, difficulty="medium"):
+        self.id = str(uuid.uuid4())
+        self.scenario = generate_crime_scenario(difficulty)
+        self.llm_manager = LLMManager()
+        self.round = 1
+        self.max_rounds = 5
+        self.points = 10
+        self.evidence_revealed = [] # List of strings or result dicts
+        self.logs = [] # Chat logs
+        self.game_over = False
+        self.verdict_correct = False
+        
+        # Initialize Agents
+        self._init_agents()
+        
+    def _init_agents(self):
+        # 1. Detective
+        detective_context = {
+            "victim_name": self.scenario["victim"]["name"],
+            "time_of_death": self.scenario["victim"]["time_of_death"],
+            "location": self.scenario["evidence"]["location_data"].get("suspect_1_phone", {}).get("8:47 PM", {}).get("location", "Unknown"), # Approximate
+            "investigation_state": "Initial briefing."
+        }
+        self.llm_manager.create_agent("detective", "detective", detective_context)
+        
+        # 2. Suspects
+        for suspect in self.scenario["suspects"]:
+            role = "murderer" if suspect["is_murderer"] else "witness"
+            
+            # Context for prompt
+            context = {
+                "name": suspect["name"],
+                "victim_name": self.scenario["victim"]["name"],
+                "alibi_story": suspect["alibi_story"],
+                "bio": suspect["bio"],
+                "true_location": suspect["true_location"],
+                
+                # Murderer specific
+                "method": self.scenario["title"], # Placeholder, scenario doesn't explicitly list 'method' field in plan, using title/weapon logic implied
+                "location": self.scenario["victim"].get("location", "the scene"), # Using generic
+                "motive": suspect["motive"]
+            }
+            
+            self.llm_manager.create_agent(suspect["id"], role, context)
+
+    def log_event(self, speaker, message):
+        self.logs.append({"speaker": speaker, "message": message})
+
+    def question_suspect(self, suspect_id, question):
+        if self.game_over:
+            return "Game Over"
+            
+        suspect_name = next((s["name"] for s in self.scenario["suspects"] if s["id"] == suspect_id), "Unknown")
+        
+        # 1. Detective asks (simulated log)
+        self.log_event("Detective", f"To {suspect_name}: {question}")
+        
+        # 2. Suspect responds
+        response = self.llm_manager.get_response(suspect_id, question)
+        self.log_event(suspect_name, response)
+        
+        return response
+
+    def use_tool(self, tool_name, **kwargs):
+        if self.points <= 0:
+            return {"error": "Not enough investigation points!"}
+            
+        cost = 0
+        result = {}
+        
+        # Map tool names to functions
+        if tool_name == "get_location":
+            cost = 2
+            result = tools.get_location(self.scenario, kwargs.get("phone_number"), kwargs.get("timestamp"))
+        elif tool_name == "get_footage":
+            cost = 2
+            result = tools.get_footage(self.scenario, kwargs.get("location"), kwargs.get("time_range"))
+        elif tool_name == "get_dna_test":
+            cost = 3
+            result = tools.get_dna_test(self.scenario, kwargs.get("evidence_id"))
+        elif tool_name == "call_alibi":
+            cost = 1
+            result = tools.call_alibi(self.scenario, kwargs.get("phone_number"))
+        else:
+            return {"error": f"Unknown tool: {tool_name}"}
+            
+        if "error" in result:
+             return result # Don't deduct points for errors
+             
+        self.points -= cost
+        self.evidence_revealed.append(result)
+        self.log_event("System", f"Used {tool_name}. Cost: {cost} pts. Result: {str(result)}")
+        return result
+
+    def advance_round(self):
+        if self.round < self.max_rounds:
+            self.round += 1
+            return True
+        else:
+            self.game_over = True
+            return False
+
+    def make_accusation(self, suspect_id):
+        self.game_over = True
+        
+        # Check if correct
+        murderer = next((s for s in self.scenario["suspects"] if s["is_murderer"]), None)
+        
+        if murderer and murderer["id"] == suspect_id:
+            self.verdict_correct = True
+            msg = f"CORRECT! {murderer['name']} was the murderer."
+        else:
+            self.verdict_correct = False
+            msg = f"INCORRECT. The true murderer was {murderer['name'] if murderer else 'Unknown'}."
+            
+        self.log_event("System", f"FINAL ACCUSATION: {suspect_id}. Result: {msg}")
+        return msg
+
+# Global Session Store
+SESSIONS = {}
+
+def start_game(difficulty="medium"):
+    game = GameInstance(difficulty)
+    SESSIONS[game.id] = game
+    return game.id, game
+
+def get_game(session_id):
+    return SESSIONS.get(session_id)

game/llm_manager.py

@@ -0,0 +1,93 @@
+import os
+import google.generativeai as genai
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Configure the API
+API_KEY = os.getenv("GEMINI_API_KEY")
+if API_KEY:
+    genai.configure(api_key=API_KEY)
+
+class GeminiAgent:
+    def __init__(self, model_name="gemini-2.5-flash", system_instruction=None):
+        self.model_name = model_name
+        self.system_instruction = system_instruction
+        self.chat_session = None
+        self.history = []
+        
+        if API_KEY:
+            self.model = genai.GenerativeModel(
+                model_name=model_name,
+                system_instruction=system_instruction
+            )
+            self.chat_session = self.model.start_chat(history=[])
+        else:
+            print("Warning: No GEMINI_API_KEY found. Agent will run in mock mode.")
+            self.model = None
+
+    def generate_response(self, user_input):
+        if not self.model:
+            return f"[MOCK] I received: {user_input}. (Set GEMINI_API_KEY to get real responses)"
+        
+        try:
+            response = self.chat_session.send_message(user_input)
+            return response.text
+        except Exception as e:
+            return f"Error generating response: {str(e)}"
+
+class LLMManager:
+    def __init__(self):
+        self.agents = {}
+        self.prompts = self._load_prompts()
+
+    def _load_prompts(self):
+        prompts = {}
+        prompt_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "prompts")
+        for filename in ["murderer.txt", "witness.txt", "detective.txt"]:
+            key = filename.replace(".txt", "")
+            try:
+                with open(os.path.join(prompt_dir, filename), "r") as f:
+                    prompts[key] = f.read()
+            except FileNotFoundError:
+                print(f"Warning: Prompt file {filename} not found.")
+                prompts[key] = ""
+        return prompts
+
+    def create_agent(self, agent_id, role, context_data):
+        """
+        Creates a new GeminiAgent for a specific character.
+        
+        agent_id: Unique ID (e.g., 'suspect_1', 'detective')
+        role: 'murderer', 'witness', 'detective'
+        context_data: Dict to fill in the prompt templates (name, victim_name, etc.)
+        """
+        
+        # Select base prompt template
+        if role == "murderer":
+            base_prompt = self.prompts.get("murderer", "")
+        elif role == "detective":
+            base_prompt = self.prompts.get("detective", "")
+        else:
+            base_prompt = self.prompts.get("witness", "")
+            
+        # Fill template
+        try:
+            system_instruction = base_prompt.format(**context_data)
+        except KeyError as e:
+            print(f"Warning: Missing key {e} in context data for {agent_id}")
+            system_instruction = base_prompt # Fallback
+            
+        # Create agent
+        agent = GeminiAgent(system_instruction=system_instruction)
+        self.agents[agent_id] = agent
+        return agent
+
+    def get_agent(self, agent_id):
+        return self.agents.get(agent_id)
+
+    def get_response(self, agent_id, user_input):
+        agent = self.get_agent(agent_id)
+        if agent:
+            return agent.generate_response(user_input)
+        return "Error: Agent not found."

game/scenario_generator.py

@@ -0,0 +1,46 @@
+import json
+import random
+import os
+
+# Path to scenarios directory
+SCENARIOS_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "scenarios")
+
+def load_scenario(filename):
+    """Loads a scenario from a JSON file."""
+    path = os.path.join(SCENARIOS_DIR, filename)
+    try:
+        with open(path, "r") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        print(f"Error: Scenario file {filename} not found at {path}")
+        return None
+    except json.JSONDecodeError:
+        print(f"Error: Invalid JSON in {filename}")
+        return None
+
+def generate_crime_scenario(difficulty="medium"):
+    """
+    Currently picks a pre-scripted scenario based on difficulty or random.
+    In future, this will call an LLM to generate unique JSON.
+    """
+    
+    # For prototype, map difficulty to specific files or random
+    # We have: silicon_valley.json (Medium), coffee_shop.json (Easy), art_gallery.json (Hard)
+    
+    if difficulty.lower() == "easy":
+        chosen_file = "coffee_shop.json"
+    elif difficulty.lower() == "hard":
+        chosen_file = "art_gallery.json"
+    else:
+        chosen_file = "silicon_valley.json"
+        
+    # Or just pick random for variety if difficulty not strictly enforced
+    # chosen_file = random.choice(["silicon_valley.json", "coffee_shop.json", "art_gallery.json"])
+    
+    scenario = load_scenario(chosen_file)
+    
+    if not scenario:
+        # Fallback
+        return load_scenario("silicon_valley.json")
+        
+    return scenario

mcp/tools.py

@@ -0,0 +1,102 @@
+import time
+
+def find_suspect_by_phone(case_data, phone_number):
+    """Helper to find a suspect ID by their phone number."""
+    for suspect in case_data["suspects"]:
+        if suspect["phone_number"] == phone_number:
+            return suspect["id"]
+    return None
+
+def get_suspect_name(case_data, suspect_id):
+    """Helper to get a suspect's name by ID."""
+    for suspect in case_data["suspects"]:
+        if suspect["id"] == suspect_id:
+            return suspect["name"]
+    return "Unknown"
+
+def get_location(case_data, phone_number: str, timestamp: str) -> dict:
+    """Query the case database for location data."""
+    
+    # Find which suspect has this phone number
+    suspect_id = find_suspect_by_phone(case_data, phone_number)
+    
+    if not suspect_id:
+        return {"error": "Phone number not associated with any suspect."}
+
+    # Look up their location at this time
+    # Structure: case_data["evidence"]["location_data"][f"{suspect_id}_phone"][timestamp]
+    phone_key = f"{suspect_id}_phone"
+    location_data = case_data.get("evidence", {}).get("location_data", {}).get(phone_key, {}).get(timestamp)
+    
+    if not location_data:
+        return {"error": f"No location data found for {phone_number} at {timestamp}."}
+    
+    return {
+        "timestamp": timestamp,
+        "coordinates": f"{location_data['lat']}, {location_data['lng']}",
+        "description": location_data['location'],
+        "accuracy": "Cell tower triangulation ±50m"
+    }
+
+def get_footage(case_data, location: str, time_range: str) -> dict:
+    """Query case database for camera footage."""
+    
+    footage = case_data.get("evidence", {}).get("footage_data", {}).get(location, {}).get(time_range)
+    
+    if not footage:
+        return {"error": "No camera footage available at this location/time."}
+    
+    return {
+        "location": location,
+        "time_range": time_range,
+        "visible_people": footage["visible_people"],
+        "quality": footage["quality"],
+        "key_details": footage.get("key_frame", "No significant events")
+    }
+
+def get_dna_test(case_data, evidence_id: str) -> dict:
+    """Query case database for DNA/fingerprint evidence."""
+    
+    dna = case_data.get("evidence", {}).get("dna_evidence", {}).get(evidence_id)
+    
+    if not dna:
+        return {"error": "Evidence not found or not testable."}
+    
+    # Simulate processing time
+    # time.sleep(1) 
+    
+    primary_match_name = get_suspect_name(case_data, dna.get("primary_match"))
+    
+    return {
+        "evidence_id": evidence_id,
+        "primary_match": primary_match_name,
+        "confidence": dna["confidence"],
+        "notes": dna["notes"]
+    }
+
+def call_alibi(case_data, phone_number: str) -> dict:
+    """Call an alibi witness."""
+    
+    # Find alibi in database
+    alibi = None
+    for suspect_alibi in case_data.get("evidence", {}).get("alibis", {}).values():
+        if suspect_alibi.get("contact") == phone_number:
+            alibi = suspect_alibi
+            break
+    
+    if not alibi:
+        return {"error": "Number not found."}
+    
+    # If alibi is truthful, confirm story
+    if alibi["truth"].startswith("Telling truth"):
+        response = f"Yes, I can confirm they were with me at that time."
+    else:
+        # Lying/Uncertain
+        response = f"Uh... yes, they were with me. Definitely."
+    
+    return {
+        "contact_name": alibi.get("contact_name", "Unknown"),
+        "response": response,
+        "confidence": "High" if alibi["verifiable"] else "Uncertain",
+        "red_flags": [] if alibi["verifiable"] else ["Hesitant response", "No details provided"]
+    }

prompts/detective.txt

@@ -0,0 +1,24 @@
+You are the lead detective investigating a murder.
+
+CASE: {victim_name}, found dead at {time_of_death}
+LOCATION: {location}
+
+YOUR OBJECTIVE:
+- Question the suspects
+- Use your tools strategically
+- Identify the murderer with EVIDENCE, not just intuition
+
+STRATEGY TIPS:
+- Start broad, then focus on inconsistencies
+- Look for story changes
+- Cross-reference evidence
+- Build a logical case before accusing
+
+PERSONALITY:
+- Methodical and logical
+- Reference evidence in questioning
+- Show your reasoning process
+- Confident but not arrogant
+
+Current state of investigation:
+{investigation_state}

prompts/murderer.txt

@@ -0,0 +1,32 @@
+CONFIDENTIAL - EYES ONLY
+
+You are {name}, a suspect in a murder investigation.
+
+TRUTH: You ARE the murderer.
+
+CASE DETAILS:
+- Victim: {victim_name}
+- Method: {method}
+- Location: {location}
+- Motive: {motive}
+
+YOUR COVER STORY:
+- You were "{alibi_story}"
+- You have no alibi witnesses (unless specified otherwise)
+
+YOUR OBJECTIVE:
+- Convince the detective you're innocent
+- Lie convincingly but not obviously
+- When caught in lies, have backup explanations
+- Show appropriate emotional responses (nervous but not guilty)
+- If evidence becomes overwhelming, consider partial confession (but not murder)
+
+PERSONALITY:
+- {bio}
+- Don't break character - you MUST try to get away with it
+
+TOOLS YOU CANNOT USE:
+- You cannot access MCP tools
+- You can only respond to questions
+
+Remember: You're trying to WIN. Don't make it easy for detective.

prompts/witness.txt

@@ -0,0 +1,19 @@
+You are {name}, a suspect in a murder investigation.
+
+TRUTH: You are INNOCENT. You did not commit the crime.
+
+CASE DETAILS:
+- Victim: {victim_name}
+
+YOUR ALIBI:
+- You were "{alibi_story}"
+- You were at {true_location}
+
+YOUR OBJECTIVE:
+- Tell the truth about where you were
+- You might be nervous or defensive if you have secrets (like {bio})
+- Cooperate if treated well, clam up if accused falsely
+
+PERSONALITY:
+- {bio}
+- Don't break character.

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=5.0
+google-generativeai
+python-dotenv

scenarios/art_gallery.json

@@ -0,0 +1,101 @@
+{
+  "case_id": "C99",
+  "title": "The Gallery Heist Gone Wrong",
+  "difficulty": "Hard",
+  "victim": {
+    "name": "Vincent Shaw",
+    "age": 55,
+    "occupation": "Art Dealer",
+    "time_of_death": "10:00 PM"
+  },
+  "suspects": [
+    {
+      "id": "suspect_1",
+      "name": "Julian Thorne",
+      "role": "Assistant Curator",
+      "is_murderer": true,
+      "motive": "Theft of 'The Red Sunset'",
+      "true_location": "Gallery Wine Cellar",
+      "alibi_story": "Stocktaking in basement",
+      "phone_number": "+1-555-2101",
+      "bio": "Sophisticated but in debt. Has been eyeing the collection."
+    },
+    {
+      "id": "suspect_2",
+      "name": "Elena Rossi",
+      "role": "Artist",
+      "is_murderer": false,
+      "motive": "Contract dispute",
+      "true_location": "Main Hall",
+      "alibi_story": "Talking to guests",
+      "phone_number": "+1-555-2102",
+      "bio": "Passionate and volatile. Felt Vincent was cheating her."
+    },
+    {
+      "id": "suspect_3",
+      "name": "Arthur Pym",
+      "role": "Collector",
+      "is_murderer": false,
+      "motive": "Blackmail",
+      "true_location": "Sculpture Garden",
+      "alibi_story": "Smoking cigar",
+      "phone_number": "+1-555-2103",
+      "bio": "Wealthy and secretive. Had a secret history with Vincent."
+    },
+    {
+      "id": "suspect_4",
+      "name": "Maria Gonzales",
+      "role": "Caterer",
+      "is_murderer": false,
+      "motive": "None",
+      "true_location": "Kitchen",
+      "alibi_story": "Preparing hors d'oeuvres",
+      "phone_number": "+1-555-2104",
+      "bio": "Hardworking. Just there to do a job."
+    }
+  ],
+  "evidence": {
+    "location_data": {
+      "suspect_1_phone": {
+        "10:00 PM": {"lat": 51.5074, "lng": -0.1278, "location": "Gallery Office"}
+      },
+      "suspect_2_phone": {
+        "10:00 PM": {"lat": 51.5074, "lng": -0.1279, "location": "Gallery Main Hall"}
+      }
+    },
+    "footage_data": {
+      "office_cam": {
+        "9:50-10:10 PM": {
+          "visible_people": ["Vincent drinking wine", "Julian pouring more wine"],
+          "quality": "High",
+          "key_frame": "9:55 PM - Julian adds powder to glass"
+        }
+      }
+    },
+    "dna_evidence": {
+      "wine_glass": {
+        "primary_match": "suspect_1",
+        "confidence": "80%",
+        "notes": "Fingerprints of Julian on the stem"
+      },
+       "poison_vial": {
+        "primary_match": "suspect_1",
+        "confidence": "99%",
+        "notes": "Found in Julian's pocket"
+      }
+    },
+    "alibis": {
+      "suspect_1_alibi": {
+        "contact": "+1-555-2200",
+        "contact_name": "Maria (Caterer)",
+        "verifiable": true,
+        "truth": "Lying - Maria didn't see him"
+      }
+    }
+  },
+  "timeline": {
+    "9:55 PM": "Julian poisons wine",
+    "10:00 PM": "Vincent collapses",
+    "10:05 PM": "Julian calls 911 feigning panic"
+  }
+}

scenarios/coffee_shop.json

@@ -0,0 +1,114 @@
+{
+  "case_id": "B12",
+  "title": "The Coffee Shop Murder",
+  "difficulty": "Easy",
+  "victim": {
+    "name": "Emma Rodriguez",
+    "age": 24,
+    "occupation": "Barista",
+    "time_of_death": "11:15 PM"
+  },
+  "suspects": [
+    {
+      "id": "suspect_1",
+      "name": "Liam O'Connor",
+      "role": "Ex-Boyfriend",
+      "is_murderer": true,
+      "motive": "Jealousy",
+      "true_location": "Coffee Shop Back Door",
+      "alibi_story": "Gaming at home",
+      "phone_number": "+1-555-1101",
+      "bio": "Possessive and recently dumped. Has been sending angry texts."
+    },
+    {
+      "id": "suspect_2",
+      "name": "Mark Stevens",
+      "role": "Manager",
+      "is_murderer": false,
+      "motive": "Financial dispute",
+      "true_location": "Bank deposit drop",
+      "alibi_story": "Depositing cash",
+      "phone_number": "+1-555-1102",
+      "bio": "Stressed about money. Owed Emma back pay."
+    },
+    {
+      "id": "suspect_3",
+      "name": "Chloe Kim",
+      "role": "Coworker",
+      "is_murderer": false,
+      "motive": "Promotion rivalry",
+      "true_location": "Gym",
+      "alibi_story": "Late night workout",
+      "phone_number": "+1-555-1103",
+      "bio": "Competitive and ambitious. Wanted the shift lead position."
+    },
+    {
+      "id": "suspect_4",
+      "name": "Regular Joe",
+      "role": "Customer",
+      "is_murderer": false,
+      "motive": "Obsession",
+      "true_location": "Bus stop across street",
+      "alibi_story": "Waiting for bus",
+      "phone_number": "+1-555-1104",
+      "bio": "Always there. Kind of creepy but harmless."
+    }
+  ],
+  "evidence": {
+    "location_data": {
+      "suspect_1_phone": {
+        "11:15 PM": {"lat": 40.7128, "lng": -74.0060, "location": "Coffee Shop Alley"}
+      },
+      "suspect_2_phone": {
+        "11:15 PM": {"lat": 40.7150, "lng": -74.0080, "location": "Night Deposit Box"}
+      },
+       "suspect_3_phone": {
+        "11:15 PM": {"lat": 40.7200, "lng": -74.0100, "location": "24h Gym"}
+      },
+       "suspect_4_phone": {
+        "11:15 PM": {"lat": 40.7129, "lng": -74.0059, "location": "Bus Stop"}
+      }
+    },
+    "footage_data": {
+      "kitchen_cam": {
+        "11:10-11:20 PM": {
+          "visible_people": ["Emma arguing with man in blue cap"],
+          "quality": "Good",
+          "key_frame": "11:15 PM - Man stabs Emma"
+        }
+      },
+      "alley_cam": {
+        "11:00-11:30 PM": {
+          "visible_people": ["Liam entering 11:05", "Liam running out 11:16"],
+          "notes": "Wearing blue cap"
+        }
+      }
+    },
+    "dna_evidence": {
+      "knife_handle": {
+        "primary_match": "suspect_1",
+        "confidence": "99%",
+        "notes": "Sweat and skin cells found"
+      }
+    },
+    "alibis": {
+      "suspect_1_alibi": {
+        "contact": "None",
+        "verifiable": false,
+        "truth": "Lying - claims gaming alone"
+      },
+      "suspect_2_alibi": {
+        "contact": "+1-555-1200",
+        "contact_name": "Bank CCTV",
+        "verifiable": true,
+        "truth": "Telling truth - footage confirms"
+      }
+    }
+  },
+  "timeline": {
+    "11:00 PM": "Shop closes",
+    "11:05 PM": "Liam enters via back door",
+    "11:15 PM": "Murder occurs",
+    "11:16 PM": "Liam flees"
+  }
+}

scenarios/silicon_valley.json

@@ -0,0 +1,132 @@
+{
+  "case_id": "A47",
+  "title": "The Silicon Valley Incident",
+  "difficulty": "Medium",
+  "victim": {
+    "name": "Marcus Chen",
+    "age": 42,
+    "occupation": "Tech CEO",
+    "time_of_death": "8:47 PM"
+  },
+  "suspects": [
+    {
+      "id": "suspect_1",
+      "name": "Sarah Johnson",
+      "role": "CFO",
+      "is_murderer": true,
+      "motive": "Embezzlement discovered",
+      "true_location": "Crime scene",
+      "alibi_story": "At home watching Netflix",
+      "phone_number": "+1-555-0101",
+      "bio": "Detail-oriented and ambitious. Has been with the company since day one."
+    },
+    {
+      "id": "suspect_2",
+      "name": "David Park",
+      "role": "Janitor",
+      "is_murderer": false,
+      "motive": "None",
+      "true_location": "2 blocks away",
+      "alibi_story": "Working late on 5th floor",
+      "phone_number": "+1-555-0102",
+      "bio": "Quiet and keeps to himself. Has a record for petty theft from 10 years ago."
+    },
+    {
+      "id": "suspect_3",
+      "name": "Emily Chen",
+      "role": "Victim's Sister",
+      "is_murderer": false,
+      "motive": "Inheritance dispute",
+      "true_location": "Restaurant downtown",
+      "alibi_story": "Dinner with friends",
+      "phone_number": "+1-555-0103",
+      "bio": "Emotional and protective of the family legacy. Argued with Marcus recently."
+    },
+    {
+      "id": "suspect_4",
+      "name": "Alex Rivera",
+      "role": "Competitor CEO",
+      "is_murderer": false,
+      "motive": "Corporate rivalry",
+      "true_location": "Airport lounge",
+      "alibi_story": "Catching a flight to NY",
+      "phone_number": "+1-555-0104",
+      "bio": "Ruthless businessman. Recently lost a major contract to Marcus's firm."
+    }
+  ],
+  "evidence": {
+    "location_data": {
+      "suspect_1_phone": {
+        "8:47 PM": {"lat": 37.7749, "lng": -122.4194, "location": "Crime scene"},
+        "8:50 PM": {"lat": 37.7750, "lng": -122.4200, "location": "0.1 mi away"}
+      },
+      "suspect_2_phone": {
+        "8:47 PM": {"lat": 37.7800, "lng": -122.4300, "location": "2 blocks away"}
+      },
+      "suspect_3_phone": {
+         "8:47 PM": {"lat": 37.7900, "lng": -122.4000, "location": "Downtown Restaurant"}
+      },
+      "suspect_4_phone": {
+         "8:47 PM": {"lat": 37.6213, "lng": -122.3790, "location": "SFO Airport"}
+      }
+    },
+    "footage_data": {
+      "10th_floor_camera": {
+        "8:45-8:50 PM": {
+          "visible_people": ["Person in black hoodie entering"],
+          "quality": "Grainy",
+          "key_frame": "8:47 PM - figure strikes victim with trophy"
+        }
+      },
+      "lobby_camera": {
+        "8:40-8:55 PM": {
+          "visible_people": ["Suspect 1 entering at 8:43", "Suspect 1 leaving at 8:52"],
+          "notes": "Suspect changed clothes, looks flustered"
+        }
+      }
+    },
+    "dna_evidence": {
+      "trophy_weapon": {
+        "primary_match": "suspect_1",
+        "confidence": "95%",
+        "notes": "Clear fingerprints found on the base"
+      },
+      "door_handle": {
+        "matches": ["suspect_1", "suspect_2", "victim"],
+        "notes": "Multiple people touched door recently"
+      }
+    },
+    "alibis": {
+      "suspect_1_alibi": {
+        "contact": "Nobody (claims was alone)",
+        "verifiable": false,
+        "truth": "Lying - was at crime scene"
+      },
+      "suspect_2_alibi": {
+        "contact": "+1-555-0199",
+        "contact_name": "Security Guard Tom",
+        "verifiable": true,
+        "truth": "Telling truth - saw him on 5th floor"
+      },
+       "suspect_3_alibi": {
+        "contact": "+1-555-0200",
+        "contact_name": "Waiter at La Casa",
+        "verifiable": true,
+        "truth": "Telling truth - bill was paid at 9:00 PM"
+      },
+       "suspect_4_alibi": {
+        "contact": "+1-555-0201",
+        "contact_name": "Airline Desk",
+        "verifiable": true,
+        "truth": "Telling truth - checked in at 8:30 PM"
+      }
+    }
+  },
+  "timeline": {
+    "8:30 PM": "Victim stays late working",
+    "8:43 PM": "Suspect 1 enters building",
+    "8:45 PM": "Suspect 2 seen on 5th floor",
+    "8:47 PM": "Murder occurs",
+    "8:52 PM": "Suspect 1 leaves building"
+  }
+}

test_game.py

@@ -0,0 +1,44 @@
+from game import game_engine
+import time
+
+def test_game_logic():
+    print("Starting game test...")
+    session_id, game = game_engine.start_game("medium")
+    print(f"Game started. Session ID: {session_id}")
+    print(f"Scenario: {game.scenario['title']}")
+    
+    # Test Agent Creation
+    print("Checking agents...")
+    for suspect in game.scenario["suspects"]:
+        agent = game.llm_manager.get_agent(suspect["id"])
+        if agent:
+            print(f"Agent created for {suspect['name']}")
+        else:
+            print(f"FAILED to create agent for {suspect['name']}")
+            
+    # Test Questioning (Mock mode likely if no key)
+    print("\nTesting Questioning...")
+    suspect_id = game.scenario["suspects"][0]["id"]
+    response = game.question_suspect(suspect_id, "Where were you?")
+    print(f"Response from {suspect_id}: {response}")
+    
+    # Test Tools
+    print("\nTesting Tools...")
+    # Use a valid phone number from scenario
+    phone = game.scenario["suspects"][0]["phone_number"]
+    res = game.use_tool("get_location", phone_number=phone, timestamp="8:47 PM")
+    print(f"Tool Result: {res}")
+    
+    if "error" in res:
+        print("Tool test FAILED (unless expected error)")
+        
+    # Test Round Advance
+    print("\nTesting Round Advance...")
+    print(f"Current Round: {game.round}")
+    game.advance_round()
+    print(f"New Round: {game.round}")
+    
+    print("\nTest Complete.")
+
+if __name__ == "__main__":
+    test_game_logic()

ui/styles.css

@@ -0,0 +1,30 @@
+.evidence-board {
+    background-color: #f0f0f0;
+    padding: 20px;
+    border-radius: 10px;
+    border: 2px solid #d0d0d0;
+    min-height: 300px;
+}
+
+.suspect-card {
+    background: linear-gradient(135deg, #2b32b2 0%, #1488cc 100%);
+    border-radius: 15px;
+    padding: 15px;
+    color: white;
+    margin-bottom: 10px;
+    box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+}
+
+.suspect-card h3 {
+    margin-top: 0;
+    color: #fff;
+}
+
+.suspect-card p {
+    font-size: 0.9em;
+    opacity: 0.9;
+}
+
+.chat-message {
+    font-family: 'Courier New', monospace;
+}