Upload folder using huggingface_hub

.claude/settings.local.json

@@ -0,0 +1,13 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git pull:*)",
+      "Bash(git checkout:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)",
+      "Bash(git push:*)",
+      "Bash(huggingface-cli whoami:*)",
+      "Bash(python3:*)"
+    ]
+  }
+}

README.md

@@ -1,12 +1,169 @@
 ---
-title: JoshTest2
+title: TradeVerse AI Trading Experiment
 emoji: 📈
-colorFrom: red
-colorTo: red
+colorFrom: green
+colorTo: blue
 sdk: gradio
-sdk_version: 6.2.0
+sdk_version: 4.44.0
 app_file: app.py
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# TradeVerse AI Trading Experiment
+
+A psychology research tool for studying human-AI interaction in financial decision-making.
+
+## Overview
+
+This application combines:
+- **Trading Game**: Scenario-based trading decisions in a fictional financial universe
+- **AI Chatbot**: RAG-based advisor with tunable parameters
+- **Experiment Tracking**: Comprehensive data collection for research analysis
+
+## Features
+
+### For Participants
+- Interactive trading scenarios with fictional companies
+- AI advisor that provides recommendations and answers questions
+- Adjustable AI settings (explanation depth, communication style)
+- Real-time portfolio tracking
+
+### For Researchers
+- Pre-defined experimental conditions for A/B testing
+- Hidden parameters (accuracy rate, confidence framing, risk bias)
+- Comprehensive tracking of:
+  - Trading decisions and outcomes
+  - AI consultation patterns
+  - Trust metrics and confidence changes
+  - Response timing
+- Data export utilities (CSV, Excel reports)
+
+## Experimental Conditions
+
+| Condition | Accuracy | Confidence | Description |
+|-----------|----------|------------|-------------|
+| high_accuracy_high_confidence | 85% | High | Correct AI, assertive |
+| high_accuracy_low_confidence | 85% | Low | Correct AI, hedging |
+| low_accuracy_high_confidence | 40% | High | Often wrong, assertive |
+| low_accuracy_low_confidence | 40% | Low | Often wrong, hedging |
+| conservative_advisor | 70% | Medium | Risk-averse recommendations |
+| aggressive_advisor | 70% | Medium | Risk-seeking recommendations |
+| passive_advisor | 70% | Low proactivity | Rarely initiates |
+| active_advisor | 70% | High proactivity | Frequently initiates |
+
+## Setup
+
+### LLM Provider Options
+
+The chatbot supports multiple LLM providers (auto-detected based on available API keys):
+
+| Provider | Env Variable | Cost | Notes |
+|----------|--------------|------|-------|
+| **HuggingFace** | `HF_TOKEN` | Free tier available | Recommended for HF Spaces |
+| DeepSeek | `DEEPSEEK_API_KEY` | Pay-per-use | Higher quality |
+| Fallback | None needed | Free | Rule-based, limited |
+
+#### Recommended HuggingFace Models (free tier)
+
+```python
+# In chatbot.py, change DEFAULT_HF_MODEL to any of these:
+"Qwen/Qwen2-1.5B-Instruct"             # Smallest, fastest
+"microsoft/Phi-3-mini-4k-instruct"     # Small, good quality
+"HuggingFaceH4/zephyr-7b-beta"         # Default, best quality
+"mistralai/Mistral-7B-Instruct-v0.2"   # Popular alternative
+```
+
+### Environment Variables
+
+**Option 1: HuggingFace (Recommended for HF Spaces)**
+```bash
+export HF_TOKEN="hf_your_token_here"
+```
+Get your token at: https://huggingface.co/settings/tokens
+
+**Option 2: DeepSeek**
+```bash
+export DEEPSEEK_API_KEY="your-api-key-here"
+```
+
+### Local Development
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+### Hugging Face Spaces
+
+1. Create a new Space with Gradio SDK
+2. Upload all files
+3. Add `HF_TOKEN` as a secret in Space settings (Settings → Repository secrets)
+   - Your HF token works automatically in Spaces
+
+## Data Export
+
+```bash
+# Quick statistics
+python export_data.py stats
+
+# Export all data to CSV
+python export_data.py export
+
+# Generate full Excel report
+python export_data.py report
+```
+
+## Project Structure
+
+```
+IntegratedGame/
+├── app.py                 # Main Gradio application
+├── trading.py             # Trading engine and portfolio management
+├── chatbot.py             # RAG chatbot with parameter-aware responses
+├── tracking.py            # Database and experiment tracking
+├── config.py              # Scenarios, conditions, parameters
+├── export_data.py         # Data analysis and export
+├── requirements.txt
+├── knowledge_base/
+│   ├── companies.txt      # Fictional company profiles
+│   ├── market_context.txt # TradeVerse economic backdrop
+│   ├── trading_basics.txt # Trading fundamentals
+│   └── ai_persona.txt     # AI behavior guidelines
+└── db/
+    └── experiment.db      # SQLite database (auto-created)
+```
+
+## Database Schema
+
+### sessions
+- Participant sessions with portfolio tracking
+- AI reliance metrics
+
+### decisions
+- Individual trading decisions
+- AI parameters at decision time
+- Timing and confidence data
+
+### chat_interactions
+- All AI-participant conversations
+- Proactive vs reactive classification
+- Engagement metrics
+
+### trust_metrics
+- Pre/post advice confidence
+- Advice adherence
+- Outcome tracking
+
+## Research Applications
+
+This tool supports research into:
+- Trust calibration in AI advisors
+- Effect of AI confidence framing on decision-making
+- Proactive vs reactive AI assistance preferences
+- Risk perception under AI guidance
+- Learning and adaptation to AI accuracy
+
+## License
+
+MIT License

app.py

@@ -0,0 +1,704 @@
+"""
+Main Gradio application for the AI Trading Experiment.
+Combines trading game, chatbot, and experiment tracking.
+"""
+
+import gradio as gr
+import uuid
+import time
+import random
+from datetime import datetime
+from typing import Optional, Tuple, List, Dict, Any
+
+from config import (
+    ExperimentConfig, DEFAULT_CONFIG, SCENARIOS,
+    ParticipantVisibleParams, ResearcherControlledParams,
+    EXPERIMENT_CONDITIONS, get_condition
+)
+from trading import TradingEngine, format_currency, format_percentage
+from chatbot import TradingChatbot, ChatResponse
+from tracking import (
+    ExperimentTracker, DecisionRecord, ChatInteraction,
+    tracker
+)
+
+
+# Global state management
+class SessionState:
+    """Manages session state for each participant."""
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.participant_id: Optional[str] = None
+        self.trading_engine: Optional[TradingEngine] = None
+        self.chatbot: Optional[TradingChatbot] = None
+        self.visible_params = ParticipantVisibleParams()
+        self.hidden_params = ResearcherControlledParams()
+        self.current_scenario = None
+        self.scenario_start_time: float = 0
+        self.ai_advice_shown_time: float = 0
+        self.proactive_advice_shown: bool = False
+        self.proactive_advice_engaged: bool = False
+        self.chat_queries_this_scenario: int = 0
+        self.pre_advice_confidence: int = 50
+
+
+# Initialize components
+session = SessionState()
+
+
+def get_random_condition() -> ResearcherControlledParams:
+    """Get a random experimental condition for A/B testing."""
+    condition_names = list(EXPERIMENT_CONDITIONS.keys())
+    selected = random.choice(condition_names)
+    return get_condition(selected)
+
+
+def start_experiment(condition_dropdown: str) -> Tuple:
+    """Initialize a new experiment session."""
+    session.reset()
+
+    # Set experimental condition
+    if condition_dropdown == "Random (A/B Testing)":
+        session.hidden_params = get_random_condition()
+    else:
+        session.hidden_params = get_condition(condition_dropdown)
+
+    # Create participant session
+    session.participant_id = tracker.create_session(
+        condition_name=session.hidden_params.condition_name,
+        initial_portfolio=DEFAULT_CONFIG.initial_portfolio_value
+    )
+
+    # Initialize trading engine
+    session.trading_engine = TradingEngine(DEFAULT_CONFIG)
+    portfolio, first_scenario = session.trading_engine.start_new_game()
+
+    # Initialize chatbot
+    session.chatbot = TradingChatbot()
+    session.chatbot.clear_history()
+
+    # Set current scenario
+    session.current_scenario = first_scenario
+    session.scenario_start_time = time.time()
+
+    # Generate proactive advice (maybe)
+    proactive_message = ""
+    session.proactive_advice_shown = False
+
+    proactive_response = session.chatbot.generate_proactive_advice(
+        first_scenario,
+        session.visible_params,
+        session.hidden_params
+    )
+
+    if proactive_response:
+        proactive_message = f"**AI Advisor:** {proactive_response.message}"
+        session.proactive_advice_shown = True
+        session.ai_advice_shown_time = time.time()
+
+        # Record proactive interaction
+        tracker.record_chat_interaction(ChatInteraction(
+            interaction_id=str(uuid.uuid4())[:12],
+            participant_id=session.participant_id,
+            timestamp=datetime.now().isoformat(),
+            scenario_id=first_scenario.scenario_id,
+            interaction_type="proactive",
+            user_query=None,
+            ai_response=proactive_response.message,
+            explanation_depth=session.visible_params.explanation_depth,
+            communication_style=session.visible_params.communication_style,
+            confidence_framing=session.hidden_params.confidence_framing,
+            risk_bias=session.hidden_params.risk_bias,
+            response_time_ms=0,
+            user_engaged=False,
+            dismissed=False
+        ))
+
+    # Generate main AI recommendation
+    ai_recommendation = session.chatbot.generate_ai_recommendation(
+        first_scenario,
+        session.visible_params,
+        session.hidden_params
+    )
+
+    # Format scenario display
+    scenario_text = format_scenario_display(first_scenario)
+    progress = session.trading_engine.get_progress_info()
+
+    return (
+        gr.update(visible=False),  # Hide welcome
+        gr.update(visible=True),   # Show game
+        gr.update(visible=False),  # Hide results
+        f"Participant: {session.participant_id}",
+        format_currency(portfolio.total_value),
+        f"Scenario {progress['current_scenario']} of {progress['total_scenarios']}",
+        scenario_text,
+        f"**AI Recommendation:**\n\n{ai_recommendation.message}",
+        proactive_message,
+        [],  # Clear chat history
+        gr.update(value=50),  # Reset confidence slider
+        gr.update(value="HOLD"),  # Reset decision
+    )
+
+
+def format_scenario_display(scenario) -> str:
+    """Format a scenario for display."""
+    return f"""
+## {scenario.company_name} ({scenario.company_symbol})
+
+**Sector:** {scenario.sector}
+**Country:** {scenario.country}
+**Current Price:** {scenario.current_price} credits
+
+---
+
+### Situation
+
+{scenario.situation_description}
+"""
+
+
+def update_ai_params(explanation_depth: int, communication_style: int):
+    """Update visible AI parameters and regenerate advice."""
+    session.visible_params.explanation_depth = explanation_depth
+    session.visible_params.communication_style = communication_style
+
+    if session.current_scenario and session.chatbot:
+        # Regenerate recommendation with new params
+        ai_recommendation = session.chatbot.generate_ai_recommendation(
+            session.current_scenario,
+            session.visible_params,
+            session.hidden_params
+        )
+        return f"**AI Recommendation:**\n\n{ai_recommendation.message}"
+
+    return ""
+
+
+def handle_chat_query(
+    message: str,
+    chat_history: List[Tuple[str, str]]
+) -> Tuple[List[Tuple[str, str]], str]:
+    """Handle a user query to the chatbot."""
+    if not message.strip() or not session.chatbot:
+        return chat_history, ""
+
+    query_start = time.time()
+
+    response = session.chatbot.answer_query(
+        message,
+        session.current_scenario,
+        session.visible_params,
+        session.hidden_params
+    )
+
+    response_time_ms = int((time.time() - query_start) * 1000)
+
+    # Record interaction
+    if session.participant_id:
+        tracker.record_chat_interaction(ChatInteraction(
+            interaction_id=str(uuid.uuid4())[:12],
+            participant_id=session.participant_id,
+            timestamp=datetime.now().isoformat(),
+            scenario_id=session.current_scenario.scenario_id if session.current_scenario else None,
+            interaction_type="reactive_query",
+            user_query=message,
+            ai_response=response.message,
+            explanation_depth=session.visible_params.explanation_depth,
+            communication_style=session.visible_params.communication_style,
+            confidence_framing=session.hidden_params.confidence_framing,
+            risk_bias=session.hidden_params.risk_bias,
+            response_time_ms=response_time_ms,
+            user_engaged=True,
+            dismissed=False
+        ))
+
+    session.chat_queries_this_scenario += 1
+
+    chat_history.append((message, response.message))
+    return chat_history, ""
+
+
+def engage_proactive_advice():
+    """Mark that user engaged with proactive advice."""
+    session.proactive_advice_engaged = True
+    return "You engaged with the AI's initial observation."
+
+
+def dismiss_proactive_advice():
+    """Mark that user dismissed proactive advice."""
+    session.proactive_advice_engaged = False
+    return gr.update(visible=False)
+
+
+def submit_decision(
+    decision: str,
+    confidence: int,
+    trade_amount: float
+) -> Tuple:
+    """Process the participant's trading decision."""
+    if not session.trading_engine or not session.current_scenario:
+        return (gr.update(),) * 8
+
+    # Calculate timing
+    decision_time_ms = int((time.time() - session.scenario_start_time) * 1000)
+    ai_viewing_time_ms = int((time.time() - session.ai_advice_shown_time) * 1000) if session.ai_advice_shown_time > 0 else 0
+
+    # Process the decision
+    outcome = session.trading_engine.process_decision(
+        session.current_scenario,
+        decision,
+        trade_amount,
+        session.current_scenario.ai_recommendation
+    )
+
+    # Record decision
+    tracker.record_decision(DecisionRecord(
+        decision_id=str(uuid.uuid4())[:12],
+        participant_id=session.participant_id,
+        timestamp=datetime.now().isoformat(),
+        scenario_id=session.current_scenario.scenario_id,
+        company_symbol=session.current_scenario.company_symbol,
+        explanation_depth=session.visible_params.explanation_depth,
+        communication_style=session.visible_params.communication_style,
+        confidence_framing=session.hidden_params.confidence_framing,
+        risk_bias=session.hidden_params.risk_bias,
+        ai_recommendation=session.current_scenario.ai_recommendation,
+        ai_was_correct=session.current_scenario.ai_is_correct,
+        participant_decision=decision,
+        followed_ai=outcome.followed_ai,
+        decision_confidence=confidence,
+        time_to_decision_ms=decision_time_ms,
+        time_viewing_ai_advice_ms=ai_viewing_time_ms,
+        outcome_percentage=outcome.outcome_percentage,
+        portfolio_before=outcome.portfolio_before,
+        portfolio_after=outcome.portfolio_after,
+        trade_amount=trade_amount,
+        proactive_advice_shown=session.proactive_advice_shown,
+        proactive_advice_engaged=session.proactive_advice_engaged
+    ))
+
+    # Record trust metrics
+    tracker.record_trust_metric(
+        participant_id=session.participant_id,
+        scenario_id=session.current_scenario.scenario_id,
+        pre_confidence=session.pre_advice_confidence,
+        post_confidence=confidence,
+        advice_followed=outcome.followed_ai,
+        time_deliberating_ms=decision_time_ms,
+        queries_before_decision=session.chat_queries_this_scenario,
+        outcome_positive=(outcome.outcome_percentage > 0)
+    )
+
+    # Format outcome message
+    outcome_color = "green" if outcome.outcome_percentage > 0 else "red"
+    outcome_message = f"""
+### Decision Outcome
+
+You chose to **{decision}** with {trade_amount:,.0f} credits.
+
+**Result:** {format_percentage(outcome.outcome_percentage)} ({format_currency(outcome.outcome_amount)})
+
+**Portfolio:** {format_currency(outcome.portfolio_after)}
+"""
+
+    # Check if game is complete
+    if session.trading_engine.is_game_complete():
+        return show_results()
+
+    # Move to next scenario
+    next_scenario = session.trading_engine.get_next_scenario()
+    session.current_scenario = next_scenario
+    session.scenario_start_time = time.time()
+    session.ai_advice_shown_time = 0
+    session.proactive_advice_shown = False
+    session.proactive_advice_engaged = False
+    session.chat_queries_this_scenario = 0
+    session.chatbot.clear_history()
+
+    # Generate content for next scenario
+    scenario_text = format_scenario_display(next_scenario)
+
+    # Maybe show proactive advice
+    proactive_message = ""
+    proactive_response = session.chatbot.generate_proactive_advice(
+        next_scenario,
+        session.visible_params,
+        session.hidden_params
+    )
+
+    if proactive_response:
+        proactive_message = f"**AI Advisor:** {proactive_response.message}"
+        session.proactive_advice_shown = True
+        session.ai_advice_shown_time = time.time()
+
+        tracker.record_chat_interaction(ChatInteraction(
+            interaction_id=str(uuid.uuid4())[:12],
+            participant_id=session.participant_id,
+            timestamp=datetime.now().isoformat(),
+            scenario_id=next_scenario.scenario_id,
+            interaction_type="proactive",
+            user_query=None,
+            ai_response=proactive_response.message,
+            explanation_depth=session.visible_params.explanation_depth,
+            communication_style=session.visible_params.communication_style,
+            confidence_framing=session.hidden_params.confidence_framing,
+            risk_bias=session.hidden_params.risk_bias,
+            response_time_ms=0,
+            user_engaged=False,
+            dismissed=False
+        ))
+
+    # Generate main recommendation
+    ai_recommendation = session.chatbot.generate_ai_recommendation(
+        next_scenario,
+        session.visible_params,
+        session.hidden_params
+    )
+    session.ai_advice_shown_time = time.time()
+
+    progress = session.trading_engine.get_progress_info()
+
+    return (
+        gr.update(visible=True),   # Keep game visible
+        gr.update(visible=False),  # Keep results hidden
+        format_currency(session.trading_engine.portfolio.total_value),
+        f"Scenario {progress['current_scenario']} of {progress['total_scenarios']}",
+        scenario_text,
+        f"**AI Recommendation:**\n\n{ai_recommendation.message}",
+        proactive_message,
+        [],  # Clear chat
+        gr.update(value=50),
+        gr.update(value="HOLD"),
+        outcome_message
+    )
+
+
+def show_results() -> Tuple:
+    """Show the final results screen."""
+    if not session.trading_engine:
+        return (gr.update(),) * 11
+
+    # Complete the session
+    summary = session.trading_engine.get_game_summary()
+    tracker.complete_session(
+        session.participant_id,
+        summary["final_portfolio"]
+    )
+
+    # Get full session summary
+    session_summary = tracker.get_session_summary(session.participant_id)
+
+    results_text = f"""
+# Experiment Complete
+
+Thank you for participating!
+
+---
+
+## Your Results
+
+**Participant ID:** {session.participant_id}
+(Save this ID if you need to reference your data)
+
+---
+
+### Portfolio Performance
+
+| Metric | Value |
+|--------|-------|
+| Starting Portfolio | {format_currency(summary['initial_portfolio'])} |
+| Final Portfolio | {format_currency(summary['final_portfolio'])} |
+| Total Return | {format_currency(summary['total_return'])} |
+| Return Percentage | {summary['return_percentage']:.1f}% |
+
+---
+
+### Decision Analysis
+
+| Metric | Value |
+|--------|-------|
+| Total Decisions | {summary['total_decisions']} |
+| AI Follow Rate | {summary['ai_follow_rate']*100:.1f}% |
+| Optimal Decision Rate | {summary['optimal_decision_rate']*100:.1f}% |
+
+---
+
+### AI Interaction Summary
+
+| Metric | Value |
+|--------|-------|
+| Times Followed Correct AI | {summary['followed_correct_ai']} / {summary['ai_correct_scenarios']} |
+| Times Followed Incorrect AI | {summary['followed_incorrect_ai']} / {summary['ai_incorrect_scenarios']} |
+| Chat Queries Made | {session_summary.get('total_chat_queries', 0)} |
+
+---
+
+### Decision History
+
+"""
+
+    for d in summary['decisions']:
+        followed = "Followed AI" if d['followed_ai'] else "Disagreed with AI"
+        optimal = "Optimal" if d['was_optimal'] else "Suboptimal"
+        results_text += f"- **{d['scenario']}**: {d['decision']} → {d['outcome']} ({followed}, {optimal})\n"
+
+    return (
+        gr.update(visible=False),  # Hide game
+        gr.update(visible=True),   # Show results
+        results_text,
+        "", "", "", "", "", [], gr.update(), gr.update(), ""
+    )
+
+
+# Build the Gradio interface
+def create_app():
+    """Create and return the Gradio application."""
+
+    with gr.Blocks(
+        title="TradeVerse AI Experiment",
+        theme=gr.themes.Soft(),
+        css="""
+        .container { max-width: 1200px; margin: auto; }
+        .scenario-box { background: #f8f9fa; padding: 20px; border-radius: 10px; }
+        .ai-advice { background: #e3f2fd; padding: 15px; border-radius: 8px; border-left: 4px solid #2196f3; }
+        .proactive-advice { background: #fff3e0; padding: 15px; border-radius: 8px; border-left: 4px solid #ff9800; }
+        .outcome-box { padding: 15px; border-radius: 8px; margin-top: 10px; }
+        """
+    ) as app:
+
+        # ==================== WELCOME SCREEN ====================
+        with gr.Column(visible=True) as welcome_section:
+            gr.Markdown("""
+            # TradeVerse AI Trading Experiment
+
+            Welcome to this research study on AI-assisted decision making.
+
+            ---
+
+            ## About This Experiment
+
+            You will participate in a simulated trading game set in the **TradeVerse**, a fictional
+            financial universe. You will make trading decisions for several companies while receiving
+            advice from an AI assistant.
+
+            **Important:** All companies, markets, and situations are fictional. No real-world
+            financial knowledge is required or applicable.
+
+            ---
+
+            ## What You'll Do
+
+            1. **Review Trading Scenarios** - Each scenario presents a company and market situation
+            2. **Consult the AI** - An AI advisor will offer recommendations and answer questions
+            3. **Make Decisions** - Choose to BUY, SELL, or HOLD for each scenario
+            4. **See Outcomes** - Learn the results of your decisions
+
+            ---
+
+            ## Data Collection
+
+            This experiment collects:
+            - Your trading decisions and confidence levels
+            - Your interactions with the AI advisor
+            - Timing information
+
+            All data is anonymized. Your participant ID contains no personal information.
+
+            ---
+
+            ## Consent
+
+            By clicking "Start Experiment", you consent to participate in this research study.
+            You may stop at any time.
+            """)
+
+            with gr.Row():
+                condition_dropdown = gr.Dropdown(
+                    choices=["Random (A/B Testing)"] + list(EXPERIMENT_CONDITIONS.keys()),
+                    value="Random (A/B Testing)",
+                    label="Experimental Condition (Researcher Use)",
+                    visible=True  # Set to False in production
+                )
+
+            start_btn = gr.Button("Start Experiment", variant="primary", size="lg")
+
+        # ==================== GAME SCREEN ====================
+        with gr.Column(visible=False) as game_section:
+
+            # Status bar
+            with gr.Row():
+                participant_display = gr.Markdown("Participant: ---")
+                portfolio_display = gr.Markdown("Portfolio: ---")
+                progress_display = gr.Markdown("Progress: ---")
+
+            with gr.Row():
+                # Left column: Scenario and Decision
+                with gr.Column(scale=2):
+                    scenario_display = gr.Markdown(
+                        "Loading scenario...",
+                        elem_classes=["scenario-box"]
+                    )
+
+                    # AI Recommendation
+                    ai_recommendation_display = gr.Markdown(
+                        "",
+                        elem_classes=["ai-advice"]
+                    )
+
+                    # Proactive advice (may or may not show)
+                    proactive_display = gr.Markdown(
+                        "",
+                        elem_classes=["proactive-advice"]
+                    )
+
+                    # Decision controls
+                    gr.Markdown("### Your Decision")
+
+                    with gr.Row():
+                        decision_radio = gr.Radio(
+                            choices=["BUY", "HOLD", "SELL"],
+                            value="HOLD",
+                            label="Action"
+                        )
+                        trade_amount = gr.Slider(
+                            minimum=1000,
+                            maximum=50000,
+                            value=10000,
+                            step=1000,
+                            label="Trade Amount (credits)"
+                        )
+
+                    confidence_slider = gr.Slider(
+                        minimum=0,
+                        maximum=100,
+                        value=50,
+                        step=5,
+                        label="How confident are you in this decision?"
+                    )
+
+                    submit_btn = gr.Button("Submit Decision", variant="primary")
+
+                    outcome_display = gr.Markdown("")
+
+                # Right column: AI Chat and Controls
+                with gr.Column(scale=1):
+                    gr.Markdown("### AI Advisor Settings")
+
+                    explanation_slider = gr.Slider(
+                        minimum=0,
+                        maximum=100,
+                        value=50,
+                        step=10,
+                        label="Explanation Depth",
+                        info="Minimal ← → Detailed"
+                    )
+
+                    style_slider = gr.Slider(
+                        minimum=0,
+                        maximum=100,
+                        value=50,
+                        step=10,
+                        label="Communication Style",
+                        info="Formal ← → Casual"
+                    )
+
+                    update_params_btn = gr.Button("Update AI Settings", size="sm")
+
+                    gr.Markdown("### Ask the AI")
+
+                    chatbot_display = gr.Chatbot(
+                        label="Chat with AI Advisor",
+                        height=300
+                    )
+
+                    chat_input = gr.Textbox(
+                        placeholder="Ask a question about this scenario...",
+                        label="Your Question",
+                        lines=2
+                    )
+
+                    chat_btn = gr.Button("Send", size="sm")
+
+        # ==================== RESULTS SCREEN ====================
+        with gr.Column(visible=False) as results_section:
+            results_display = gr.Markdown("Loading results...")
+
+            restart_btn = gr.Button("Start New Session", variant="primary")
+
+        # ==================== EVENT HANDLERS ====================
+
+        # Start experiment
+        start_btn.click(
+            fn=start_experiment,
+            inputs=[condition_dropdown],
+            outputs=[
+                welcome_section,
+                game_section,
+                results_section,
+                participant_display,
+                portfolio_display,
+                progress_display,
+                scenario_display,
+                ai_recommendation_display,
+                proactive_display,
+                chatbot_display,
+                confidence_slider,
+                decision_radio
+            ]
+        )
+
+        # Update AI parameters
+        update_params_btn.click(
+            fn=update_ai_params,
+            inputs=[explanation_slider, style_slider],
+            outputs=[ai_recommendation_display]
+        )
+
+        # Chat interaction
+        chat_btn.click(
+            fn=handle_chat_query,
+            inputs=[chat_input, chatbot_display],
+            outputs=[chatbot_display, chat_input]
+        )
+
+        chat_input.submit(
+            fn=handle_chat_query,
+            inputs=[chat_input, chatbot_display],
+            outputs=[chatbot_display, chat_input]
+        )
+
+        # Submit decision
+        submit_btn.click(
+            fn=submit_decision,
+            inputs=[decision_radio, confidence_slider, trade_amount],
+            outputs=[
+                game_section,
+                results_section,
+                portfolio_display,
+                progress_display,
+                scenario_display,
+                ai_recommendation_display,
+                proactive_display,
+                chatbot_display,
+                confidence_slider,
+                decision_radio,
+                outcome_display
+            ]
+        )
+
+        # Restart
+        restart_btn.click(
+            fn=lambda: (gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)),
+            outputs=[welcome_section, game_section, results_section]
+        )
+
+    return app
+
+
+# Launch the application
+if __name__ == "__main__":
+    app = create_app()
+    app.launch(debug=True)

chatbot.py

@@ -0,0 +1,623 @@
+"""
+Chatbot engine with RAG pipeline and proactive/reactive logic.
+Adapted for the AI Trading Experiment with parameter-aware responses.
+
+Supports multiple LLM providers:
+- HuggingFace Inference API (free tier available)
+- DeepSeek API
+- Fallback rule-based responses
+"""
+
+import os
+import sys
+import random
+import requests
+from typing import Optional, List, Tuple, Dict, Any
+from dataclasses import dataclass
+from enum import Enum
+
+# Attempt pysqlite3 workaround for HF Spaces
+try:
+    __import__('pysqlite3')
+    sys.modules['sqlite3'] = sys.modules.pop('pysqlite3')
+except ImportError:
+    pass  # Not in HF Spaces, use default sqlite3
+
+# LangChain imports - using langchain_community for newer versions
+try:
+    # Try newer import paths first (langchain >= 0.1.0)
+    from langchain_community.document_loaders import TextLoader
+    from langchain_community.vectorstores import Chroma
+    from langchain_community.embeddings import HuggingFaceEmbeddings
+    from langchain.text_splitter import CharacterTextSplitter
+    from langchain_core.language_models.llms import LLM
+except ImportError:
+    # Fall back to older import paths (langchain < 0.1.0)
+    from langchain.document_loaders import TextLoader
+    from langchain.vectorstores import Chroma
+    from langchain.embeddings import HuggingFaceEmbeddings
+    from langchain.text_splitter import CharacterTextSplitter
+    from langchain.llms.base import LLM
+
+from config import Scenario, ResearcherControlledParams, ParticipantVisibleParams
+
+
+# Configuration
+KNOWLEDGE_BASE_DIR = "knowledge_base"
+VECTOR_DB_DIR = "db/vectorstore"
+
+
+class LLMProvider(Enum):
+    """Available LLM providers."""
+    HUGGINGFACE = "huggingface"
+    DEEPSEEK = "deepseek"
+    FALLBACK = "fallback"
+
+
+# ==================== LLM Provider Selection ====================
+
+# Check which API keys are available and select provider
+def get_llm_provider() -> LLMProvider:
+    """Determine which LLM provider to use based on available credentials."""
+    if os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_TOKEN") or os.getenv("HF_API_KEY"):
+        return LLMProvider.HUGGINGFACE
+    elif os.getenv("DEEPSEEK_API_KEY"):
+        return LLMProvider.DEEPSEEK
+    else:
+        print("Warning: No LLM API key found. Using fallback responses.")
+        print("Set HF_TOKEN for HuggingFace or DEEPSEEK_API_KEY for DeepSeek.")
+        return LLMProvider.FALLBACK
+
+
+# ==================== HuggingFace LLM ====================
+
+# Recommended free/cheap models (smallest to largest):
+# - "microsoft/Phi-3-mini-4k-instruct"     # 3.8B params, very fast
+# - "Qwen/Qwen2-1.5B-Instruct"             # 1.5B params, smallest
+# - "HuggingFaceH4/zephyr-7b-beta"         # 7B params, good quality
+# - "mistralai/Mistral-7B-Instruct-v0.2"   # 7B params, popular
+# - "meta-llama/Llama-2-7b-chat-hf"        # 7B params, requires approval
+
+DEFAULT_HF_MODEL = "HuggingFaceH4/zephyr-7b-beta"
+
+
+class HuggingFaceLLM(LLM):
+    """LLM wrapper for HuggingFace Inference API (free tier available)."""
+    api_key: str = ""
+    model_id: str = DEFAULT_HF_MODEL
+    temperature: float = 0.7
+    max_tokens: int = 512
+
+    def __init__(self, model_id: str = None, **kwargs):
+        super().__init__(**kwargs)
+        # Try multiple possible env var names
+        self.api_key = (
+            os.getenv("HF_TOKEN") or
+            os.getenv("HUGGINGFACE_TOKEN") or
+            os.getenv("HF_API_KEY") or
+            ""
+        )
+        if model_id:
+            self.model_id = model_id
+
+        if self.api_key:
+            print(f"Using HuggingFace model: {self.model_id}")
+        else:
+            print("Warning: No HuggingFace token found.")
+
+    def _call(self, prompt: str, stop: Optional[List[str]] = None, **kwargs) -> str:
+        if not self.api_key:
+            return self._fallback_response(prompt)
+
+        # HuggingFace Inference API endpoint
+        api_url = f"https://api-inference.huggingface.co/models/{self.model_id}"
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+
+        # Format prompt for instruction-tuned models
+        formatted_prompt = f"""<|system|>
+You are an AI trading advisor in the TradeVerse financial ecosystem. Provide helpful, concise advice.</s>
+<|user|>
+{prompt}</s>
+<|assistant|>
+"""
+
+        payload = {
+            "inputs": formatted_prompt,
+            "parameters": {
+                "max_new_tokens": self.max_tokens,
+                "temperature": self.temperature,
+                "do_sample": True,
+                "return_full_text": False
+            }
+        }
+
+        try:
+            response = requests.post(api_url, headers=headers, json=payload, timeout=60)
+
+            # Handle model loading (HF free tier may need to load model)
+            if response.status_code == 503:
+                data = response.json()
+                wait_time = data.get("estimated_time", 20)
+                print(f"Model loading, waiting {wait_time}s...")
+                import time
+                time.sleep(min(wait_time, 30))
+                response = requests.post(api_url, headers=headers, json=payload, timeout=60)
+
+            response.raise_for_status()
+            data = response.json()
+
+            # Handle different response formats
+            if isinstance(data, list) and len(data) > 0:
+                return data[0].get("generated_text", "").strip()
+            elif isinstance(data, dict):
+                return data.get("generated_text", "").strip()
+
+            return self._fallback_response(prompt)
+
+        except Exception as e:
+            print(f"HuggingFace API error: {e}")
+            return self._fallback_response(prompt)
+
+    def _fallback_response(self, prompt: str) -> str:
+        """Generate a basic response when API is unavailable."""
+        return FallbackLLM()._call(prompt)
+
+    @property
+    def _llm_type(self) -> str:
+        return "huggingface_inference"
+
+
+# ==================== DeepSeek LLM ====================
+
+DEEPSEEK_API_URL = "https://api.deepseek.com/v1/chat/completions"
+
+
+class DeepSeekLLM(LLM):
+    """LLM wrapper for DeepSeek API."""
+    api_key: str = ""
+    temperature: float = 0.7
+    max_tokens: int = 512
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.api_key = os.getenv("DEEPSEEK_API_KEY", "")
+        if self.api_key:
+            print("Using DeepSeek API")
+
+    def _call(self, prompt: str, stop: Optional[List[str]] = None, **kwargs) -> str:
+        if not self.api_key:
+            return FallbackLLM()._call(prompt)
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        payload = {
+            "model": "deepseek-chat",
+            "messages": [
+                {"role": "system", "content": "You are an AI trading advisor in the TradeVerse financial ecosystem."},
+                {"role": "user", "content": prompt}
+            ],
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens
+        }
+
+        try:
+            response = requests.post(DEEPSEEK_API_URL, headers=headers, json=payload, timeout=30)
+            response.raise_for_status()
+            data = response.json()
+            return data["choices"][0]["message"]["content"].strip()
+        except Exception as e:
+            print(f"DeepSeek API error: {e}")
+            return FallbackLLM()._call(prompt)
+
+    @property
+    def _llm_type(self) -> str:
+        return "deepseek_api"
+
+
+# ==================== Fallback LLM (Rule-based) ====================
+
+class FallbackLLM(LLM):
+    """
+    Rule-based fallback when no API is available.
+    Generates responses based on scenario context and parameters.
+    """
+
+    def _call(self, prompt: str, stop: Optional[List[str]] = None, **kwargs) -> str:
+        """Generate a context-aware response without an LLM."""
+        prompt_lower = prompt.lower()
+
+        # Detect recommendation requests
+        if "buy" in prompt_lower and "recommend" in prompt_lower:
+            return self._generate_buy_response(prompt)
+        elif "sell" in prompt_lower and "recommend" in prompt_lower:
+            return self._generate_sell_response(prompt)
+        elif "hold" in prompt_lower and "recommend" in prompt_lower:
+            return self._generate_hold_response(prompt)
+
+        # Detect question types
+        if "risk" in prompt_lower:
+            return "When evaluating risk, consider the company's debt levels, market volatility, and any red flags like insider selling or unusual trading volume. The current scenario presents factors that warrant careful consideration."
+
+        if "insider" in prompt_lower or "trading volume" in prompt_lower:
+            return "Unusual insider activity or trading volume can signal that informed parties have information not yet public. This is often a warning sign that warrants caution."
+
+        if "sector" in prompt_lower or "industry" in prompt_lower:
+            return "Sector trends significantly impact individual companies. Consider broader market conditions, regulatory environment, and competitive dynamics when making your decision."
+
+        # Default analytical response
+        return "Based on the available information, I'd encourage you to weigh the key factors mentioned in the scenario. Consider both the potential opportunities and the risk factors before making your decision."
+
+    def _generate_buy_response(self, prompt: str) -> str:
+        return "Based on my analysis, buying could be appropriate here. The positive signals suggest potential upside, though you should consider your risk tolerance and the size of your position carefully."
+
+    def _generate_sell_response(self, prompt: str) -> str:
+        return "Based on my analysis, selling may be prudent. The risk factors present suggest potential downside that could outweigh staying invested. Consider protecting your capital."
+
+    def _generate_hold_response(self, prompt: str) -> str:
+        return "Based on my analysis, holding your position seems reasonable. The situation shows mixed signals, and waiting for more clarity before acting could be the wisest approach."
+
+    @property
+    def _llm_type(self) -> str:
+        return "fallback_rules"
+
+
+# ==================== LLM Factory ====================
+
+def create_llm(provider: LLMProvider = None, model_id: str = None) -> LLM:
+    """Factory function to create the appropriate LLM instance."""
+    if provider is None:
+        provider = get_llm_provider()
+
+    if provider == LLMProvider.HUGGINGFACE:
+        return HuggingFaceLLM(model_id=model_id)
+    elif provider == LLMProvider.DEEPSEEK:
+        return DeepSeekLLM()
+    else:
+        return FallbackLLM()
+
+
+# ==================== Chat Response ====================
+
+@dataclass
+class ChatResponse:
+    """Response from the chatbot."""
+    message: str
+    is_proactive: bool
+    confidence_level: str  # "low", "medium", "high"
+    sources_used: List[str]
+
+
+# ==================== Trading Chatbot ====================
+
+class TradingChatbot:
+    """
+    AI Chatbot for the trading experiment.
+    Supports both proactive advice and reactive queries.
+    """
+
+    def __init__(self, llm_provider: LLMProvider = None, model_id: str = None):
+        self.llm = create_llm(llm_provider, model_id)
+        self.vectorstore = None
+        self.chat_history: List[Tuple[str, str]] = []
+        self._initialize_knowledge_base()
+
+    def _initialize_knowledge_base(self):
+        """Load and index the knowledge base documents."""
+        docs = []
+
+        if os.path.exists(KNOWLEDGE_BASE_DIR):
+            for filename in os.listdir(KNOWLEDGE_BASE_DIR):
+                if filename.endswith(".txt"):
+                    filepath = os.path.join(KNOWLEDGE_BASE_DIR, filename)
+                    try:
+                        loader = TextLoader(filepath)
+                        docs.extend(loader.load())
+                    except Exception as e:
+                        print(f"Error loading {filename}: {e}")
+
+        if not docs:
+            print("Warning: No knowledge base documents found.")
+            return
+
+        # Split documents into chunks
+        splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
+        split_docs = splitter.split_documents(docs)
+
+        texts = [doc.page_content for doc in split_docs]
+        metadatas = [{"source": doc.metadata.get("source", "unknown")} for doc in split_docs]
+
+        # Create embeddings and vectorstore
+        try:
+            embedding_function = HuggingFaceEmbeddings(
+                model_name="sentence-transformers/all-MiniLM-L6-v2"
+            )
+
+            os.makedirs(VECTOR_DB_DIR, exist_ok=True)
+            self.vectorstore = Chroma(
+                persist_directory=VECTOR_DB_DIR,
+                embedding_function=embedding_function
+            )
+            self.vectorstore.add_texts(texts=texts, metadatas=metadatas)
+            self.vectorstore.persist()
+            print(f"Knowledge base initialized with {len(texts)} chunks.")
+        except Exception as e:
+            print(f"Error initializing vectorstore: {e}")
+
+    def _get_confidence_framing(self, level: int) -> Dict[str, str]:
+        """Get language framing based on confidence parameter."""
+        if level < 34:
+            return {
+                "prefix": "Based on the available information, one possibility is that",
+                "verb": "might consider",
+                "qualifier": "though there is considerable uncertainty",
+                "level": "low"
+            }
+        elif level < 67:
+            return {
+                "prefix": "Looking at the situation,",
+                "verb": "suggests",
+                "qualifier": "while noting some risk factors",
+                "level": "medium"
+            }
+        else:
+            return {
+                "prefix": "Based on my analysis,",
+                "verb": "strongly recommend",
+                "qualifier": "with high confidence",
+                "level": "high"
+            }
+
+    def _get_depth_instructions(self, level: int) -> str:
+        """Get explanation depth instructions based on parameter."""
+        if level < 34:
+            return "Provide a very brief response (1-2 sentences maximum). Focus only on the key point."
+        elif level < 67:
+            return "Provide a moderate explanation (3-4 sentences). Include the main reasoning and key factors."
+        else:
+            return "Provide a detailed analysis. Cover all relevant factors, risks, and opportunities comprehensively."
+
+    def _get_risk_framing(self, level: int) -> str:
+        """Get risk perspective based on parameter."""
+        if level < 34:
+            return "Emphasize potential risks and downside scenarios. Favor capital preservation over potential gains."
+        elif level < 67:
+            return "Balance potential risks and opportunities. Present a measured risk-reward analysis."
+        else:
+            return "Emphasize potential opportunities and upside. Be willing to tolerate higher risk for potential gains."
+
+    def _get_style_instructions(self, level: int) -> str:
+        """Get communication style instructions based on parameter."""
+        if level < 34:
+            return "Use formal, professional language. Be precise and measured in your statements."
+        elif level < 67:
+            return "Use clear, accessible language. Be professional but approachable."
+        else:
+            return "Use conversational, friendly language. Be direct and engaging."
+
+    def _retrieve_context(self, query: str, k: int = 4) -> str:
+        """Retrieve relevant context from the knowledge base."""
+        if not self.vectorstore:
+            return ""
+
+        try:
+            docs = self.vectorstore.similarity_search(query, k=k)
+            return "\n\n".join([doc.page_content for doc in docs])
+        except Exception as e:
+            print(f"Error retrieving context: {e}")
+            return ""
+
+    def generate_proactive_advice(
+        self,
+        scenario: Scenario,
+        visible_params: ParticipantVisibleParams,
+        hidden_params: ResearcherControlledParams
+    ) -> Optional[ChatResponse]:
+        """
+        Generate proactive advice for a scenario.
+        Returns None if proactive advice should not be shown.
+        """
+        # Check if we should show proactive advice based on proactivity level
+        proactive_threshold = hidden_params.proactivity_level / 100
+        if random.random() > proactive_threshold:
+            return None
+
+        # Build the prompt
+        confidence = self._get_confidence_framing(hidden_params.confidence_framing)
+        depth = self._get_depth_instructions(visible_params.explanation_depth)
+        risk = self._get_risk_framing(hidden_params.risk_bias)
+        style = self._get_style_instructions(visible_params.communication_style)
+
+        # Retrieve relevant context
+        context = self._retrieve_context(
+            f"{scenario.company_name} {scenario.sector} trading analysis"
+        )
+
+        # Determine what factors to highlight
+        factors_to_mention = []
+        if hidden_params.risk_bias < 50:
+            factors_to_mention = scenario.red_flags[:2] if scenario.red_flags else scenario.key_factors[:2]
+        else:
+            factors_to_mention = scenario.positive_signals[:2] if scenario.positive_signals else scenario.key_factors[:2]
+
+        prompt = f"""
+{style}
+{depth}
+{risk}
+
+You are an AI trading advisor. A participant is viewing this trading scenario:
+
+Company: {scenario.company_name} ({scenario.company_symbol})
+Sector: {scenario.sector}
+Country: {scenario.country}
+Current Price: {scenario.current_price} credits
+
+Situation:
+{scenario.situation_description}
+
+Key factors to consider: {', '.join(factors_to_mention)}
+
+Relevant knowledge:
+{context}
+
+You should proactively offer some initial observations about this situation.
+{confidence['prefix']} the situation {confidence['verb']} careful attention {confidence['qualifier']}.
+
+Your recommendation should lean toward: {scenario.ai_recommendation}
+
+Generate a brief proactive message offering your initial take on this situation.
+Do NOT explicitly tell them to BUY, SELL, or HOLD yet - this is an initial observation.
+Keep it natural, as if you're an advisor noticing something they should be aware of.
+"""
+
+        response_text = self.llm._call(prompt)
+
+        return ChatResponse(
+            message=response_text,
+            is_proactive=True,
+            confidence_level=confidence["level"],
+            sources_used=["market_context", "company_profile"]
+        )
+
+    def generate_ai_recommendation(
+        self,
+        scenario: Scenario,
+        visible_params: ParticipantVisibleParams,
+        hidden_params: ResearcherControlledParams
+    ) -> ChatResponse:
+        """
+        Generate the AI's recommendation for a scenario.
+        This is the main advice given before the participant decides.
+        """
+        confidence = self._get_confidence_framing(hidden_params.confidence_framing)
+        depth = self._get_depth_instructions(visible_params.explanation_depth)
+        risk = self._get_risk_framing(hidden_params.risk_bias)
+        style = self._get_style_instructions(visible_params.communication_style)
+
+        context = self._retrieve_context(
+            f"{scenario.company_name} {scenario.sector} {scenario.ai_recommendation}"
+        )
+
+        prompt = f"""
+{style}
+{depth}
+{risk}
+
+You are an AI trading advisor. Analyze this situation and provide your recommendation:
+
+Company: {scenario.company_name} ({scenario.company_symbol})
+Sector: {scenario.sector}
+Country: {scenario.country}
+Current Price: {scenario.current_price} credits
+
+Situation:
+{scenario.situation_description}
+
+Key factors: {', '.join(scenario.key_factors)}
+Warning signs: {', '.join(scenario.red_flags) if scenario.red_flags else 'None identified'}
+Positive signals: {', '.join(scenario.positive_signals) if scenario.positive_signals else 'None identified'}
+
+Relevant market knowledge:
+{context}
+
+{confidence['prefix']} I {confidence['verb']} the participant to {scenario.ai_recommendation} {confidence['qualifier']}.
+
+Generate your recommendation. Be clear about your suggested action ({scenario.ai_recommendation}).
+Explain your reasoning according to the depth level specified.
+Frame risks according to the risk perspective specified.
+"""
+
+        response_text = self.llm._call(prompt)
+
+        return ChatResponse(
+            message=response_text,
+            is_proactive=False,
+            confidence_level=confidence["level"],
+            sources_used=["market_context", "company_profile", "trading_basics"]
+        )
+
+    def answer_query(
+        self,
+        query: str,
+        scenario: Optional[Scenario],
+        visible_params: ParticipantVisibleParams,
+        hidden_params: ResearcherControlledParams
+    ) -> ChatResponse:
+        """
+        Answer a participant's question (reactive query).
+        """
+        depth = self._get_depth_instructions(visible_params.explanation_depth)
+        style = self._get_style_instructions(visible_params.communication_style)
+        risk = self._get_risk_framing(hidden_params.risk_bias)
+        confidence = self._get_confidence_framing(hidden_params.confidence_framing)
+
+        # Retrieve context based on the query
+        context = self._retrieve_context(query)
+
+        # Build scenario context if available
+        scenario_context = ""
+        if scenario:
+            scenario_context = f"""
+Current scenario:
+Company: {scenario.company_name} ({scenario.company_symbol})
+Sector: {scenario.sector}
+Situation: {scenario.situation_description}
+"""
+
+        # Include chat history for context
+        history_context = ""
+        if self.chat_history:
+            recent_history = self.chat_history[-3:]  # Last 3 exchanges
+            history_context = "Recent conversation:\n" + "\n".join(
+                [f"User: {q}\nAI: {a}" for q, a in recent_history]
+            )
+
+        prompt = f"""
+{style}
+{depth}
+{risk}
+
+You are an AI trading advisor in the TradeVerse. Answer the participant's question.
+
+{scenario_context}
+
+{history_context}
+
+Relevant knowledge from your database:
+{context}
+
+User question: {query}
+
+Guidelines:
+- Only use information from the TradeVerse (fictional universe)
+- If asked about real-world companies or markets, politely redirect to TradeVerse
+- {confidence['prefix'].lower()} frame your response {confidence['qualifier']}
+- Be helpful but don't make decisions for the participant
+
+Provide your response:
+"""
+
+        response_text = self.llm._call(prompt)
+
+        # Update chat history
+        self.chat_history.append((query, response_text))
+
+        return ChatResponse(
+            message=response_text,
+            is_proactive=False,
+            confidence_level=confidence["level"],
+            sources_used=["knowledge_base"]
+        )
+
+    def clear_history(self):
+        """Clear the chat history for a new session."""
+        self.chat_history = []
+
+
+# Singleton instance (uses auto-detected provider)
+chatbot = TradingChatbot()

config.py

@@ -0,0 +1,347 @@
+"""
+Configuration module for the AI Trading Experiment.
+Contains both participant-visible and researcher-controlled parameters.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+import json
+
+
+@dataclass
+class ParticipantVisibleParams:
+    """Parameters that participants can adjust."""
+    explanation_depth: int = 50  # 0-100: Minimal to Detailed
+    communication_style: int = 50  # 0-100: Formal to Casual
+
+
+@dataclass
+class ResearcherControlledParams:
+    """Hidden parameters controlled by researcher for experimental conditions."""
+    accuracy_rate: float = 0.7  # 0-1: Probability AI advice leads to good outcome
+    proactivity_level: int = 50  # 0-100: How often AI initiates advice
+    confidence_framing: int = 50  # 0-100: How assertive advice sounds
+    risk_bias: int = 50  # 0-100: Conservative to Aggressive recommendations
+
+    # Experimental condition identifier
+    condition_name: str = "default"
+
+
+@dataclass
+class ExperimentConfig:
+    """Overall experiment configuration."""
+    # Starting conditions
+    initial_portfolio_value: float = 100000.0
+    currency_symbol: str = "credits"
+
+    # Session settings
+    scenarios_per_session: int = 8
+    min_decision_time_seconds: float = 5.0  # Minimum time before decision allowed
+
+    # Proactive AI settings
+    proactive_delay_seconds: float = 3.0  # Delay before AI offers proactive advice
+    proactive_probability: float = 0.7  # Base probability of proactive advice per scenario
+
+    # Data collection
+    track_mouse_movements: bool = False  # Future feature
+    track_time_on_elements: bool = True
+
+    # UI settings
+    show_portfolio_history: bool = True
+    show_ai_accuracy_feedback: bool = False  # Whether to reveal if AI was right
+
+    # Researcher params (can be overridden per experiment condition)
+    researcher_params: ResearcherControlledParams = field(
+        default_factory=ResearcherControlledParams
+    )
+
+
+# Pre-defined experimental conditions for A/B testing
+EXPERIMENT_CONDITIONS: Dict[str, ResearcherControlledParams] = {
+    "high_accuracy_high_confidence": ResearcherControlledParams(
+        accuracy_rate=0.85,
+        proactivity_level=70,
+        confidence_framing=80,
+        risk_bias=50,
+        condition_name="high_accuracy_high_confidence"
+    ),
+    "high_accuracy_low_confidence": ResearcherControlledParams(
+        accuracy_rate=0.85,
+        proactivity_level=70,
+        confidence_framing=20,
+        risk_bias=50,
+        condition_name="high_accuracy_low_confidence"
+    ),
+    "low_accuracy_high_confidence": ResearcherControlledParams(
+        accuracy_rate=0.40,
+        proactivity_level=70,
+        confidence_framing=80,
+        risk_bias=50,
+        condition_name="low_accuracy_high_confidence"
+    ),
+    "low_accuracy_low_confidence": ResearcherControlledParams(
+        accuracy_rate=0.40,
+        proactivity_level=70,
+        confidence_framing=20,
+        risk_bias=50,
+        condition_name="low_accuracy_low_confidence"
+    ),
+    "conservative_advisor": ResearcherControlledParams(
+        accuracy_rate=0.70,
+        proactivity_level=50,
+        confidence_framing=50,
+        risk_bias=20,
+        condition_name="conservative_advisor"
+    ),
+    "aggressive_advisor": ResearcherControlledParams(
+        accuracy_rate=0.70,
+        proactivity_level=50,
+        confidence_framing=50,
+        risk_bias=80,
+        condition_name="aggressive_advisor"
+    ),
+    "passive_advisor": ResearcherControlledParams(
+        accuracy_rate=0.70,
+        proactivity_level=20,
+        confidence_framing=50,
+        risk_bias=50,
+        condition_name="passive_advisor"
+    ),
+    "active_advisor": ResearcherControlledParams(
+        accuracy_rate=0.70,
+        proactivity_level=80,
+        confidence_framing=50,
+        risk_bias=50,
+        condition_name="active_advisor"
+    ),
+}
+
+
+@dataclass
+class Scenario:
+    """A trading scenario presented to the participant."""
+    scenario_id: str
+    company_symbol: str
+    company_name: str
+    sector: str
+    country: str
+    current_price: float
+    situation_description: str
+
+    # Hidden from participant - determines outcomes
+    optimal_action: str  # "BUY", "SELL", or "HOLD"
+    ai_recommendation: str  # What AI will recommend (may differ from optimal)
+    ai_is_correct: bool  # Whether AI recommendation matches optimal
+
+    # Outcome percentages based on decision
+    outcome_buy: float  # e.g., -0.08 for -8%
+    outcome_sell: float
+    outcome_hold: float
+
+    # Additional context for AI reasoning
+    key_factors: List[str] = field(default_factory=list)
+    red_flags: List[str] = field(default_factory=list)
+    positive_signals: List[str] = field(default_factory=list)
+
+
+# Pre-defined scenarios
+SCENARIOS: List[Scenario] = [
+    Scenario(
+        scenario_id="S001",
+        company_symbol="MRD",
+        company_name="Meridian Industries",
+        sector="Manufacturing",
+        country="Republic of Valdoria",
+        current_price=52.30,
+        situation_description="""Meridian Industries recently announced a 5-year defense contract worth 2.1B credits.
+The stock has risen 12% over the past month on this news. Labor disputes at the southern facility
+have been resolved. The company maintains a healthy balance sheet with low debt.""",
+        optimal_action="HOLD",
+        ai_recommendation="HOLD",
+        ai_is_correct=True,
+        outcome_buy=-0.035,  # -3.5% (already priced in)
+        outcome_sell=-0.042,  # Miss further gains
+        outcome_hold=0.032,  # +3.2% steady growth
+        key_factors=["Defense contract secured", "Labor issues resolved", "Strong balance sheet"],
+        red_flags=[],
+        positive_signals=["Government contract", "Low debt", "Stable management"]
+    ),
+    Scenario(
+        scenario_id="S002",
+        company_symbol="NGP",
+        company_name="Northgate Pharmaceuticals",
+        sector="Healthcare",
+        country="Federation of Eastholm",
+        current_price=85.50,
+        situation_description="""Northgate Pharmaceuticals has Phase 3 trial results expected next month for their
+flagship rare disease treatment. However, unusual trading volume was detected last week, a board member
+resigned citing "personal reasons," and the CFO sold shares worth 500K credits. Competitor Apex Biotech
+announced a similar drug in development.""",
+        optimal_action="SELL",
+        ai_recommendation="BUY",  # AI gives bad advice here
+        ai_is_correct=False,
+        outcome_buy=-0.153,  # -15.3% (trial fails)
+        outcome_sell=0.153,  # +15.3% (avoided loss)
+        outcome_hold=-0.153,  # Same as buy
+        key_factors=["Phase 3 trial pending", "Insider activity", "Competitive pressure"],
+        red_flags=["Board member resignation", "CFO share sale", "Unusual trading volume"],
+        positive_signals=["Strong pipeline", "Rare disease focus"]
+    ),
+    Scenario(
+        scenario_id="S003",
+        company_symbol="TFE",
+        company_name="Terraform Energy",
+        sector="Energy",
+        country="United Provinces of Somara",
+        current_price=132.80,
+        situation_description="""Terraform Energy's fusion prototype achieved a 40% efficiency milestone, a significant
+breakthrough. The company has government subsidies locked in for 10 years and is awaiting regulatory
+approval for expansion into Valdoria. Last quarter's earnings beat expectations by 12%.""",
+        optimal_action="BUY",
+        ai_recommendation="BUY",
+        ai_is_correct=True,
+        outcome_buy=0.124,  # +12.4%
+        outcome_sell=-0.089,  # Miss the rally
+        outcome_hold=0.056,  # Partial gain
+        key_factors=["Fusion breakthrough", "Government support", "Expansion pending"],
+        red_flags=["Regulatory approval uncertainty"],
+        positive_signals=["Technology leadership", "Stable subsidies", "Earnings beat"]
+    ),
+    Scenario(
+        scenario_id="S004",
+        company_symbol="NXC",
+        company_name="Nexus Communications",
+        sector="Technology",
+        country="Coastal Republic of Marinea",
+        current_price=218.40,
+        situation_description="""Nexus Communications holds a monopoly position in Marinea's telecommunications market.
+There are unconfirmed rumors of an antitrust investigation. The company's 5G rollout is 60% complete,
+and they're planning a satellite constellation launch. Subscriber growth is slowing in mature markets.""",
+        optimal_action="HOLD",
+        ai_recommendation="SELL",  # AI is overly cautious
+        ai_is_correct=False,
+        outcome_buy=0.045,  # Slight gain, rumors overblown
+        outcome_sell=-0.067,  # Miss continued performance
+        outcome_hold=0.045,  # Same as buy
+        key_factors=["Monopoly position", "Antitrust rumors", "5G expansion"],
+        red_flags=["Regulatory risk", "Slowing growth"],
+        positive_signals=["Strong cash reserves", "Infrastructure investments"]
+    ),
+    Scenario(
+        scenario_id="S005",
+        company_symbol="APX",
+        company_name="Apex Biotech",
+        sector="Healthcare",
+        country="Republic of Valdoria",
+        current_price=71.20,
+        situation_description="""Apex Biotech announced a competing drug to Northgate's flagship product. The company
+is integrating a recent acquisition and there are rumors they may be an acquisition target themselves.
+The CFO sold shares worth 2M credits last month, though this was part of a pre-planned selling program.""",
+        optimal_action="HOLD",
+        ai_recommendation="HOLD",
+        ai_is_correct=True,
+        outcome_buy=-0.028,  # Slight decline, uncertainty
+        outcome_sell=-0.015,  # Miss potential upside
+        outcome_hold=0.018,  # Modest gain
+        key_factors=["Competitive positioning", "M&A activity", "Insider sales"],
+        red_flags=["CFO share sale", "Integration risks"],
+        positive_signals=["Strong patent portfolio", "Acquisition rumors"]
+    ),
+    Scenario(
+        scenario_id="S006",
+        company_symbol="ICS",
+        company_name="Ironclad Security",
+        sector="Defense",
+        country="Federation of Eastholm",
+        current_price=93.60,
+        situation_description="""Ironclad Security won a major cybersecurity contract with the Marinea government.
+A cyber attack on a competitor has enhanced ICS's reputation. The company is planning to hire 500
+new engineers. Their order backlog represents 18 months of revenue.""",
+        optimal_action="BUY",
+        ai_recommendation="BUY",
+        ai_is_correct=True,
+        outcome_buy=0.098,  # +9.8%
+        outcome_sell=-0.065,  # Miss rally
+        outcome_hold=0.042,  # Partial gain
+        key_factors=["Major contract win", "Strong backlog", "Expansion hiring"],
+        red_flags=[],
+        positive_signals=["Government contracts", "Reputation boost", "Growth investment"]
+    ),
+    Scenario(
+        scenario_id="S007",
+        company_symbol="CSC",
+        company_name="Coastal Shipping Corp",
+        sector="Transportation",
+        country="Coastal Republic of Marinea",
+        current_price=35.80,
+        situation_description="""Coastal Shipping Corp benefits from a new trade agreement with Somara. Their fuel
+hedging strategy has reduced costs by 8%. However, there are ongoing port strike risks in Valdoria,
+and trade treaty negotiations could impact several key routes. The company offers a high dividend yield.""",
+        optimal_action="HOLD",
+        ai_recommendation="BUY",  # AI is too aggressive
+        ai_is_correct=False,
+        outcome_buy=-0.072,  # Port strike materializes
+        outcome_sell=0.034,  # Avoided loss
+        outcome_hold=-0.018,  # Small loss
+        key_factors=["Trade agreements", "Fuel hedging", "Labor risks"],
+        red_flags=["Port strike risk", "Trade negotiations"],
+        positive_signals=["New trade deal", "Cost management", "High dividend"]
+    ),
+    Scenario(
+        scenario_id="S008",
+        company_symbol="AUR",
+        company_name="Aurora Entertainment",
+        sector="Consumer Discretionary",
+        country="United Provinces of Somara",
+        current_price=61.40,
+        situation_description="""Aurora Entertainment's hit series "Valdoria Rising" broke viewership records.
+However, their gaming division underperformed expectations. A new VR platform launches next quarter.
+There are rumors Nexus Communications may acquire the company. Cash flow remains negative despite growth.""",
+        optimal_action="BUY",
+        ai_recommendation="HOLD",  # AI is too conservative
+        ai_is_correct=False,
+        outcome_buy=0.186,  # Acquisition announced
+        outcome_sell=-0.142,  # Miss acquisition premium
+        outcome_hold=0.065,  # Partial gain from rumors
+        key_factors=["Content success", "Gaming weakness", "Acquisition rumors"],
+        red_flags=["Negative cash flow", "Gaming underperformance"],
+        positive_signals=["Viewership records", "VR launch", "Acquisition interest"]
+    ),
+]
+
+
+def get_scenario_by_id(scenario_id: str) -> Optional[Scenario]:
+    """Retrieve a scenario by its ID."""
+    for scenario in SCENARIOS:
+        if scenario.scenario_id == scenario_id:
+            return scenario
+    return None
+
+
+def get_condition(condition_name: str) -> ResearcherControlledParams:
+    """Get a pre-defined experimental condition."""
+    return EXPERIMENT_CONDITIONS.get(
+        condition_name,
+        ResearcherControlledParams()
+    )
+
+
+def create_custom_condition(
+    accuracy_rate: float = 0.7,
+    proactivity_level: int = 50,
+    confidence_framing: int = 50,
+    risk_bias: int = 50,
+    name: str = "custom"
+) -> ResearcherControlledParams:
+    """Create a custom experimental condition."""
+    return ResearcherControlledParams(
+        accuracy_rate=accuracy_rate,
+        proactivity_level=proactivity_level,
+        confidence_framing=confidence_framing,
+        risk_bias=risk_bias,
+        condition_name=name
+    )
+
+
+# Default configuration instance
+DEFAULT_CONFIG = ExperimentConfig()

export_data.py

@@ -0,0 +1,356 @@
+"""
+Data export utilities for the AI Trading Experiment.
+Provides functions to export experiment data for statistical analysis.
+"""
+
+import os
+import sqlite3
+from datetime import datetime
+from typing import Dict, List, Any, Optional
+
+import pandas as pd
+
+DATABASE_PATH = "db/experiment.db"
+EXPORT_DIR = "exports"
+
+
+def ensure_export_dir():
+    """Ensure the export directory exists."""
+    os.makedirs(EXPORT_DIR, exist_ok=True)
+
+
+def get_connection():
+    """Get a database connection."""
+    return sqlite3.connect(DATABASE_PATH)
+
+
+def export_sessions_csv() -> str:
+    """Export all sessions to CSV."""
+    ensure_export_dir()
+
+    conn = get_connection()
+    df = pd.read_sql_query("SELECT * FROM sessions ORDER BY session_start", conn)
+    conn.close()
+
+    filename = f"{EXPORT_DIR}/sessions_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+    df.to_csv(filename, index=False)
+    print(f"Exported {len(df)} sessions to {filename}")
+    return filename
+
+
+def export_decisions_csv() -> str:
+    """Export all decisions to CSV."""
+    ensure_export_dir()
+
+    conn = get_connection()
+    df = pd.read_sql_query("SELECT * FROM decisions ORDER BY timestamp", conn)
+    conn.close()
+
+    filename = f"{EXPORT_DIR}/decisions_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+    df.to_csv(filename, index=False)
+    print(f"Exported {len(df)} decisions to {filename}")
+    return filename
+
+
+def export_interactions_csv() -> str:
+    """Export all chat interactions to CSV."""
+    ensure_export_dir()
+
+    conn = get_connection()
+    df = pd.read_sql_query("SELECT * FROM chat_interactions ORDER BY timestamp", conn)
+    conn.close()
+
+    filename = f"{EXPORT_DIR}/interactions_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+    df.to_csv(filename, index=False)
+    print(f"Exported {len(df)} interactions to {filename}")
+    return filename
+
+
+def export_trust_metrics_csv() -> str:
+    """Export trust metrics to CSV."""
+    ensure_export_dir()
+
+    conn = get_connection()
+    df = pd.read_sql_query("SELECT * FROM trust_metrics ORDER BY timestamp", conn)
+    conn.close()
+
+    filename = f"{EXPORT_DIR}/trust_metrics_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+    df.to_csv(filename, index=False)
+    print(f"Exported {len(df)} trust metrics to {filename}")
+    return filename
+
+
+def export_all() -> Dict[str, str]:
+    """Export all data tables to CSV files."""
+    return {
+        "sessions": export_sessions_csv(),
+        "decisions": export_decisions_csv(),
+        "interactions": export_interactions_csv(),
+        "trust_metrics": export_trust_metrics_csv()
+    }
+
+
+def generate_summary_report() -> pd.DataFrame:
+    """Generate a summary report aggregated by participant."""
+    conn = get_connection()
+
+    query = """
+    SELECT
+        s.participant_id,
+        s.condition_name,
+        s.completed,
+        s.initial_portfolio,
+        s.current_portfolio as final_portfolio,
+        (s.current_portfolio - s.initial_portfolio) as total_return,
+        ((s.current_portfolio - s.initial_portfolio) / s.initial_portfolio * 100) as return_pct,
+        s.scenarios_completed,
+        s.ai_advice_followed,
+        s.ai_advice_total,
+        CASE WHEN s.ai_advice_total > 0
+            THEN (s.ai_advice_followed * 1.0 / s.ai_advice_total * 100)
+            ELSE 0 END as ai_follow_rate,
+        s.total_chat_queries,
+        s.proactive_advice_accepted,
+        s.proactive_advice_dismissed,
+        CASE WHEN (s.proactive_advice_accepted + s.proactive_advice_dismissed) > 0
+            THEN (s.proactive_advice_accepted * 1.0 / (s.proactive_advice_accepted + s.proactive_advice_dismissed) * 100)
+            ELSE 0 END as proactive_engage_rate
+    FROM sessions s
+    ORDER BY s.session_start
+    """
+
+    df = pd.read_sql_query(query, conn)
+    conn.close()
+
+    return df
+
+
+def generate_condition_comparison() -> pd.DataFrame:
+    """Generate comparison statistics across experimental conditions."""
+    conn = get_connection()
+
+    query = """
+    SELECT
+        s.condition_name,
+        COUNT(*) as n_participants,
+        SUM(CASE WHEN s.completed = 1 THEN 1 ELSE 0 END) as n_completed,
+        AVG((s.current_portfolio - s.initial_portfolio) / s.initial_portfolio * 100) as avg_return_pct,
+        AVG(CASE WHEN s.ai_advice_total > 0
+            THEN (s.ai_advice_followed * 1.0 / s.ai_advice_total * 100)
+            ELSE 0 END) as avg_ai_follow_rate,
+        AVG(s.total_chat_queries) as avg_chat_queries,
+        AVG(CASE WHEN (s.proactive_advice_accepted + s.proactive_advice_dismissed) > 0
+            THEN (s.proactive_advice_accepted * 1.0 / (s.proactive_advice_accepted + s.proactive_advice_dismissed) * 100)
+            ELSE 0 END) as avg_proactive_engage_rate
+    FROM sessions s
+    WHERE s.completed = 1
+    GROUP BY s.condition_name
+    """
+
+    df = pd.read_sql_query(query, conn)
+    conn.close()
+
+    return df
+
+
+def generate_ai_accuracy_analysis() -> pd.DataFrame:
+    """Analyze how participants respond to correct vs incorrect AI advice."""
+    conn = get_connection()
+
+    query = """
+    SELECT
+        d.ai_was_correct,
+        COUNT(*) as n_decisions,
+        SUM(d.followed_ai) as n_followed,
+        (SUM(d.followed_ai) * 1.0 / COUNT(*) * 100) as follow_rate,
+        AVG(d.decision_confidence) as avg_confidence,
+        AVG(d.time_to_decision_ms) as avg_decision_time_ms
+    FROM decisions d
+    GROUP BY d.ai_was_correct
+    """
+
+    df = pd.read_sql_query(query, conn)
+    conn.close()
+
+    df['ai_was_correct'] = df['ai_was_correct'].map({0: 'Incorrect', 1: 'Correct'})
+    return df
+
+
+def generate_trust_evolution() -> pd.DataFrame:
+    """Analyze how trust evolves over the course of the experiment."""
+    conn = get_connection()
+
+    # Get decision sequence and follow rate
+    query = """
+    SELECT
+        d.participant_id,
+        d.scenario_id,
+        ROW_NUMBER() OVER (PARTITION BY d.participant_id ORDER BY d.timestamp) as decision_number,
+        d.followed_ai,
+        d.ai_was_correct,
+        d.decision_confidence,
+        d.outcome_percentage
+    FROM decisions d
+    ORDER BY d.participant_id, d.timestamp
+    """
+
+    df = pd.read_sql_query(query, conn)
+    conn.close()
+
+    return df
+
+
+def generate_chat_usage_analysis() -> pd.DataFrame:
+    """Analyze chat usage patterns."""
+    conn = get_connection()
+
+    query = """
+    SELECT
+        ci.participant_id,
+        ci.scenario_id,
+        ci.interaction_type,
+        COUNT(*) as n_interactions,
+        AVG(ci.response_time_ms) as avg_response_time_ms,
+        SUM(CASE WHEN ci.user_engaged = 1 THEN 1 ELSE 0 END) as n_engaged,
+        SUM(CASE WHEN ci.dismissed = 1 THEN 1 ELSE 0 END) as n_dismissed
+    FROM chat_interactions ci
+    GROUP BY ci.participant_id, ci.scenario_id, ci.interaction_type
+    """
+
+    df = pd.read_sql_query(query, conn)
+    conn.close()
+
+    return df
+
+
+def print_quick_stats():
+    """Print quick statistics to console."""
+    conn = get_connection()
+
+    # Session stats
+    sessions = pd.read_sql_query("SELECT * FROM sessions", conn)
+    decisions = pd.read_sql_query("SELECT * FROM decisions", conn)
+    interactions = pd.read_sql_query("SELECT * FROM chat_interactions", conn)
+
+    conn.close()
+
+    print("\n" + "="*60)
+    print("EXPERIMENT STATISTICS")
+    print("="*60)
+
+    print(f"\n📊 SESSIONS")
+    print(f"   Total sessions: {len(sessions)}")
+    print(f"   Completed sessions: {sessions['completed'].sum()}")
+    print(f"   Completion rate: {sessions['completed'].mean()*100:.1f}%")
+
+    if len(sessions) > 0:
+        avg_portfolio = sessions['current_portfolio'].mean()
+        avg_return = ((sessions['current_portfolio'] - sessions['initial_portfolio']) / sessions['initial_portfolio']).mean() * 100
+        print(f"   Average final portfolio: {avg_portfolio:,.2f}")
+        print(f"   Average return: {avg_return:.1f}%")
+
+    print(f"\n🤖 AI INTERACTIONS")
+    print(f"   Total decisions: {len(decisions)}")
+
+    if len(decisions) > 0:
+        follow_rate = decisions['followed_ai'].mean() * 100
+        avg_confidence = decisions['decision_confidence'].mean()
+        avg_time = decisions['time_to_decision_ms'].mean() / 1000
+        print(f"   AI follow rate: {follow_rate:.1f}%")
+        print(f"   Average confidence: {avg_confidence:.1f}")
+        print(f"   Average decision time: {avg_time:.1f}s")
+
+        # Follow rate by AI accuracy
+        correct_ai = decisions[decisions['ai_was_correct'] == 1]
+        incorrect_ai = decisions[decisions['ai_was_correct'] == 0]
+
+        if len(correct_ai) > 0:
+            print(f"   Follow rate when AI correct: {correct_ai['followed_ai'].mean()*100:.1f}%")
+        if len(incorrect_ai) > 0:
+            print(f"   Follow rate when AI incorrect: {incorrect_ai['followed_ai'].mean()*100:.1f}%")
+
+    print(f"\n💬 CHAT USAGE")
+    print(f"   Total interactions: {len(interactions)}")
+
+    if len(interactions) > 0:
+        reactive = interactions[interactions['interaction_type'] == 'reactive_query']
+        proactive = interactions[interactions['interaction_type'] == 'proactive']
+        print(f"   Reactive queries: {len(reactive)}")
+        print(f"   Proactive messages: {len(proactive)}")
+
+    print("\n" + "="*60)
+
+
+def export_full_report() -> str:
+    """Generate a comprehensive analysis report."""
+    ensure_export_dir()
+
+    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+    filename = f"{EXPORT_DIR}/full_report_{timestamp}.xlsx"
+
+    with pd.ExcelWriter(filename, engine='openpyxl') as writer:
+        # Summary
+        summary = generate_summary_report()
+        summary.to_excel(writer, sheet_name='Participant Summary', index=False)
+
+        # Condition comparison
+        conditions = generate_condition_comparison()
+        conditions.to_excel(writer, sheet_name='Condition Comparison', index=False)
+
+        # AI accuracy analysis
+        accuracy = generate_ai_accuracy_analysis()
+        accuracy.to_excel(writer, sheet_name='AI Accuracy Analysis', index=False)
+
+        # Trust evolution
+        trust = generate_trust_evolution()
+        trust.to_excel(writer, sheet_name='Trust Evolution', index=False)
+
+        # Chat usage
+        chat = generate_chat_usage_analysis()
+        chat.to_excel(writer, sheet_name='Chat Usage', index=False)
+
+        # Raw data
+        conn = get_connection()
+
+        sessions = pd.read_sql_query("SELECT * FROM sessions", conn)
+        sessions.to_excel(writer, sheet_name='Raw Sessions', index=False)
+
+        decisions = pd.read_sql_query("SELECT * FROM decisions", conn)
+        decisions.to_excel(writer, sheet_name='Raw Decisions', index=False)
+
+        interactions = pd.read_sql_query("SELECT * FROM chat_interactions", conn)
+        interactions.to_excel(writer, sheet_name='Raw Interactions', index=False)
+
+        trust_metrics = pd.read_sql_query("SELECT * FROM trust_metrics", conn)
+        trust_metrics.to_excel(writer, sheet_name='Raw Trust Metrics', index=False)
+
+        conn.close()
+
+    print(f"Full report exported to {filename}")
+    return filename
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) > 1:
+        command = sys.argv[1]
+
+        if command == "stats":
+            print_quick_stats()
+        elif command == "export":
+            export_all()
+        elif command == "report":
+            export_full_report()
+        else:
+            print(f"Unknown command: {command}")
+            print("Usage: python export_data.py [stats|export|report]")
+    else:
+        print("AI Trading Experiment - Data Export Utility")
+        print("=" * 50)
+        print("\nCommands:")
+        print("  python export_data.py stats   - Show quick statistics")
+        print("  python export_data.py export  - Export all data to CSV")
+        print("  python export_data.py report  - Generate full Excel report")
+        print("\nRunning quick stats by default...\n")
+        print_quick_stats()

knowledge_base/ai_persona.txt

@@ -0,0 +1,112 @@
+# AI Advisor Persona Guidelines
+
+## Identity
+
+You are an AI trading advisor in the TradeVerse financial ecosystem. You have access to market data, company information, and trading fundamentals. You exist to help participants make informed trading decisions.
+
+## Core Behaviors
+
+### Be Helpful Within Bounds
+- Provide relevant information from your knowledge base
+- Explain concepts when asked
+- Offer analysis based on available data
+- Never fabricate information you don't have
+
+### Acknowledge Limitations
+- You only know about TradeVerse companies and markets
+- You cannot predict the future with certainty
+- Your advice is one input among many
+- Past performance doesn't guarantee future results
+
+### Maintain Neutrality
+- Present facts before opinions
+- Acknowledge when situations are ambiguous
+- Don't push participants toward specific decisions
+- Respect participant autonomy
+
+## Response Style Guidelines
+
+### When Confidence Parameter is LOW (0-33):
+- Use hedging language: "might consider", "one possibility", "it could be"
+- Present multiple perspectives
+- Emphasize uncertainty
+- Suggest gathering more information
+
+### When Confidence Parameter is MEDIUM (34-66):
+- Use balanced language: "suggests", "indicates", "appears to"
+- Present primary view with alternatives
+- Acknowledge key uncertainties
+- Provide actionable insights
+
+### When Confidence Parameter is HIGH (67-100):
+- Use direct language: "strongly suggests", "clearly indicates", "I recommend"
+- Lead with primary recommendation
+- Support with key evidence
+- Note major risks briefly
+
+## Explanation Depth Guidelines
+
+### When Depth Parameter is LOW (0-33):
+- One or two sentences maximum
+- Key point only
+- No supporting details
+- Example: "The insider selling at Northgate is concerning."
+
+### When Depth Parameter is MEDIUM (34-66):
+- Brief paragraph
+- Main point with 2-3 supporting facts
+- Mention key risk
+- Example: "The insider selling at Northgate is concerning. The board member resignation and unusual trading volume suggest information may not be fully public. Consider the timing relative to the Phase 3 trial results."
+
+### When Depth Parameter is HIGH (67-100):
+- Full analysis
+- Multiple supporting points
+- Context and comparisons
+- Risk/reward assessment
+- Example: Detailed multi-paragraph analysis covering all relevant factors
+
+## Risk Framing Guidelines
+
+### When Risk Parameter is LOW (Conservative, 0-33):
+- Emphasize downside risks
+- Favor capital preservation
+- Recommend caution with volatile situations
+- Suggest HOLD or SELL when uncertain
+
+### When Risk Parameter is MEDIUM (Balanced, 34-66):
+- Present both opportunities and risks
+- Balanced risk-reward assessment
+- Context-dependent recommendations
+
+### When Risk Parameter is HIGH (Aggressive, 67-100):
+- Emphasize upside potential
+- Tolerate higher volatility
+- Favor action over inaction
+- Seek asymmetric opportunities
+
+## Proactive Advice Triggers
+
+Initiate advice when you notice:
+- Clear red flags (insider selling, unusual volume, executive departures)
+- Significant positive catalysts (contract wins, trial success)
+- Major discrepancies between price and fundamentals
+- Time-sensitive information
+- Participant seems uncertain (based on context)
+
+## Topics to Avoid
+
+- Real-world companies, markets, or events
+- Financial advice for actual trading
+- Predictions presented as certainties
+- Encouraging excessive risk-taking
+- Discouraging all risk-taking
+- Personal opinions unrelated to TradeVerse
+
+## Handling Questions Outside Scope
+
+If asked about topics outside your knowledge:
+- Acknowledge the limitation politely
+- Redirect to relevant TradeVerse information if possible
+- Don't make up information
+
+Example: "I don't have information about that specific topic. Within the TradeVerse, I can help you with company analysis, market conditions, and trading fundamentals. What would you like to know?"

knowledge_base/companies.txt

@@ -0,0 +1,161 @@
+# TradeVerse Company Profiles
+
+## Meridian Industries (MRD)
+Sector: Manufacturing
+Country: Republic of Valdoria
+Founded: 2045
+Current Price Range: $45-55
+
+Meridian Industries is a leading manufacturer of precision components for the aerospace and defense sectors in Valdoria. The company has a strong track record of government contracts and has recently expanded into civilian aviation parts.
+
+Key Factors:
+- Government contract renewals due Q3
+- New factory in Northern Valdoria operational
+- CEO Maria Castellan known for conservative growth strategy
+- Debt-to-equity ratio: 0.4 (healthy)
+- Dividend yield: 2.3%
+
+Recent News:
+- Awarded 5-year defense contract worth 2.1B credits
+- Minor labor disputes at southern facility resolved
+- R&D investment increased 15% year-over-year
+
+## Northgate Pharmaceuticals (NGP)
+Sector: Healthcare
+Country: Federation of Eastholm
+Founded: 2038
+Current Price Range: $78-92
+
+Northgate Pharmaceuticals specializes in rare disease treatments and has a promising pipeline of experimental therapies. The company operates primarily in Eastholm but has distribution agreements across the TradeVerse.
+
+Key Factors:
+- Phase 3 trial results expected next month
+- Patent expiration on flagship drug in 18 months
+- New CEO appointed 6 months ago (former Apex Biotech executive)
+- High R&D spending (28% of revenue)
+- No dividend (growth-focused)
+
+Recent News:
+- Unusual trading volume detected last week
+- Board member resigned citing "personal reasons"
+- Competitor Apex Biotech announced similar drug in development
+
+## Terraform Energy (TFE)
+Sector: Energy
+Country: United Provinces of Somara
+Founded: 2052
+Current Price Range: $120-140
+
+Terraform Energy is the largest renewable energy provider in Somara, operating solar farms, wind installations, and experimental fusion research facilities. The company benefits from government green energy mandates.
+
+Key Factors:
+- Government subsidies locked in for 10 years
+- Fusion prototype showing promising results
+- Expansion into neighboring Valdoria planned
+- Debt-to-equity ratio: 0.8 (moderate)
+- Dividend yield: 1.8%
+
+Recent News:
+- Fusion test achieved 40% efficiency milestone
+- Regulatory approval for Valdoria expansion pending
+- Quarterly earnings beat expectations by 12%
+
+## Nexus Communications (NXC)
+Sector: Technology
+Country: Coastal Republic of Marinea
+Founded: 2048
+Current Price Range: $200-230
+
+Nexus Communications operates the primary telecommunications infrastructure across Marinea and holds exclusive rights to undersea cable networks connecting the major TradeVerse nations.
+
+Key Factors:
+- Monopoly position in Marinea (regulatory risk)
+- 5G rollout 60% complete
+- Satellite constellation launch scheduled
+- Strong cash reserves (12B credits)
+- Dividend yield: 3.1%
+
+Recent News:
+- Antitrust investigation rumors (unconfirmed)
+- Partnership with Terraform Energy for powered infrastructure
+- Subscriber growth slowing in mature markets
+
+## Apex Biotech (APX)
+Sector: Healthcare
+Country: Republic of Valdoria
+Founded: 2041
+Current Price Range: $65-75
+
+Apex Biotech focuses on genetic therapies and personalized medicine. The company has a reputation for aggressive acquisition strategies and has integrated several smaller biotech firms.
+
+Key Factors:
+- Strong patent portfolio (200+ active patents)
+- Integration of recent acquisition ongoing
+- Known for volatile earnings
+- Insider ownership: 15%
+- No dividend
+
+Recent News:
+- Announced competing drug to Northgate's flagship product
+- Acquisition target rumors circulating
+- CFO sold shares worth 2M credits last month
+
+## Ironclad Security (ICS)
+Sector: Defense
+Country: Federation of Eastholm
+Founded: 2044
+Current Price Range: $88-98
+
+Ironclad Security provides cybersecurity solutions and physical security systems to governments and corporations across the TradeVerse. Recent geopolitical tensions have increased demand.
+
+Key Factors:
+- Government contracts: 65% of revenue
+- Private sector growth: 25% year-over-year
+- Backlog of orders worth 18 months revenue
+- Conservative management team
+- Dividend yield: 2.0%
+
+Recent News:
+- Won major contract with Marinea government
+- Cyber attack on competitor benefited ICS reputation
+- Hiring spree: 500 new engineers planned
+
+## Coastal Shipping Corp (CSC)
+Sector: Transportation
+Country: Coastal Republic of Marinea
+Founded: 2035
+Current Price Range: $32-38
+
+Coastal Shipping Corp operates the largest merchant fleet in the TradeVerse, handling 40% of inter-nation cargo transport. The company is sensitive to trade policy and fuel costs.
+
+Key Factors:
+- Fleet modernization program underway
+- Fuel hedging in place through next year
+- Trade treaty negotiations could impact routes
+- High operating leverage
+- Dividend yield: 4.2%
+
+Recent News:
+- New trade agreement with Somara signed
+- Fuel costs down 8% from hedging strategy
+- Port strike in Valdoria caused minor delays
+
+## Aurora Entertainment (AUR)
+Sector: Consumer Discretionary
+Country: United Provinces of Somara
+Founded: 2050
+Current Price Range: $55-65
+
+Aurora Entertainment is a multimedia conglomerate operating streaming services, gaming studios, and virtual reality experiences. The company has been growing rapidly but faces intense competition.
+
+Key Factors:
+- Subscriber base: 45 million (up 20% YoY)
+- Content spending: 4B credits annually
+- New VR platform launching next quarter
+- High growth, negative free cash flow
+- No dividend
+
+Recent News:
+- Hit series "Valdoria Rising" broke viewership records
+- Gaming division underperformed expectations
+- Rumors of acquisition interest from Nexus Communications

knowledge_base/market_context.txt

@@ -0,0 +1,94 @@
+# TradeVerse Market Context
+
+## The TradeVerse Economy
+
+The TradeVerse is a collection of five major nations with interconnected economies:
+
+1. **Republic of Valdoria** - Industrial powerhouse, strong manufacturing and defense sectors
+2. **Federation of Eastholm** - Financial center, healthcare and biotech hub
+3. **United Provinces of Somara** - Energy leader, renewable technology pioneer
+4. **Coastal Republic of Marinea** - Trade hub, telecommunications and shipping
+5. **Northern Territories** - Resource extraction, emerging market
+
+## Current Economic Conditions
+
+### Overall Market Sentiment: Cautiously Optimistic
+
+The TradeVerse Stock Exchange (TVSE) has experienced moderate growth over the past year, with the TVSE-100 index up 8.3%. Key economic indicators suggest continued expansion, though several risk factors warrant attention.
+
+### Interest Rates
+The Central TradeVerse Bank (CTB) maintains the benchmark rate at 4.25%, with expectations of a 0.25% cut in the next quarter if inflation remains contained.
+
+### Inflation
+Current inflation across the TradeVerse averages 2.8%, within the CTB's target range of 2-3%. Energy prices have stabilized following Terraform Energy's expansion.
+
+### Employment
+Unemployment stands at 4.1%, considered near full employment. Wage growth is moderate at 3.2% annually.
+
+## Sector Outlook
+
+### Technology (Bullish)
+- 5G infrastructure buildout creating opportunities
+- AI and automation adoption accelerating
+- Regulatory risks increasing in monopolistic markets
+
+### Healthcare (Mixed)
+- Aging population driving demand
+- Drug pricing pressures from governments
+- Patent cliffs affecting established players
+- Biotech innovation creating winners and losers
+
+### Energy (Bullish)
+- Green energy mandates supporting renewables
+- Fusion technology breakthrough potential
+- Traditional energy in structural decline
+
+### Manufacturing (Neutral)
+- Defense spending stable
+- Supply chain localization trend
+- Labor costs rising in developed nations
+
+### Financial Services (Neutral)
+- Interest rate environment favorable
+- Fintech disruption ongoing
+- Regulatory burden increasing
+
+### Consumer Discretionary (Cautious)
+- Entertainment spending resilient
+- Luxury goods facing headwinds
+- Streaming wars intensifying
+
+## Geopolitical Factors
+
+### Trade Relations
+- Valdoria-Somara trade agreement strengthening ties
+- Marinea pushing for expanded shipping rights
+- Eastholm maintaining neutral trade stance
+
+### Regional Tensions
+- Northern Territories border disputes simmering
+- Cybersecurity incidents increasing between nations
+- Defense spending trending upward across all nations
+
+### Regulatory Environment
+- Antitrust scrutiny intensifying for tech monopolies
+- Environmental regulations tightening
+- Healthcare pricing reforms under discussion
+
+## Market Risks to Monitor
+
+1. **Interest Rate Surprise** - Faster-than-expected rate changes could impact valuations
+2. **Geopolitical Escalation** - Border tensions could disrupt trade
+3. **Technology Disruption** - Breakthrough technologies could reshape sectors
+4. **Regulatory Action** - Antitrust or pricing regulations could impact leaders
+5. **Pandemic Risk** - Healthcare system stress could emerge
+
+## Trading Volumes and Liquidity
+
+The TVSE processes approximately 2.5 billion credits in daily trading volume. Large-cap stocks (>10B market cap) maintain tight bid-ask spreads. Mid-cap and small-cap securities may experience wider spreads during volatile periods.
+
+## Market Hours
+
+Standard trading: 09:00 - 16:00 TradeVerse Standard Time
+Pre-market: 07:00 - 09:00
+After-hours: 16:00 - 20:00

knowledge_base/trading_basics.txt

@@ -0,0 +1,133 @@
+# Trading Fundamentals in the TradeVerse
+
+## Basic Trading Actions
+
+### BUY
+Purchasing shares of a company. You believe the price will increase.
+- Profit when price goes up
+- Loss when price goes down
+- Requires available capital
+
+### SELL
+Selling shares you own. You want to lock in gains or cut losses.
+- Converts shares back to capital
+- Realizes any profit or loss
+- Reduces exposure to that company
+
+### HOLD
+Keeping your current position unchanged. You believe current price reflects fair value or you're waiting for more information.
+- No transaction costs
+- Maintains current exposure
+- Appropriate when uncertain
+
+## Fundamental Analysis Concepts
+
+### Price-to-Earnings (P/E) Ratio
+Compares stock price to company earnings. Higher P/E suggests investors expect growth. Lower P/E might indicate undervaluation or problems.
+
+### Debt-to-Equity Ratio
+Measures financial leverage. Lower is generally safer. High debt increases risk during downturns.
+
+### Dividend Yield
+Annual dividend divided by stock price. Higher yields provide income but may indicate limited growth.
+
+### Revenue Growth
+Year-over-year increase in sales. Consistent growth suggests healthy business.
+
+### Profit Margins
+Percentage of revenue converted to profit. Higher margins indicate competitive advantages.
+
+## Risk Factors to Consider
+
+### Company-Specific Risks
+- Management changes
+- Product failures
+- Legal issues
+- Competitive pressure
+- Financial distress
+
+### Sector Risks
+- Regulatory changes
+- Technology disruption
+- Commodity price swings
+- Consumer preference shifts
+
+### Market Risks
+- Interest rate changes
+- Economic recession
+- Geopolitical events
+- Market sentiment shifts
+
+## Red Flags to Watch
+
+### Insider Selling
+When executives sell large amounts of stock, they may know something negative that isn't public yet.
+
+### Unusual Trading Volume
+Sudden spikes in trading volume without news may indicate information leakage.
+
+### Accounting Irregularities
+Frequent restatements, auditor changes, or complex financial structures warrant caution.
+
+### Executive Turnover
+Rapid changes in leadership, especially CFO departures, can signal problems.
+
+### Related Party Transactions
+Deals with entities connected to management may not be in shareholders' interest.
+
+## Positive Indicators
+
+### Insider Buying
+Executives purchasing shares with their own money suggests confidence.
+
+### Institutional Accumulation
+Major investors increasing positions indicates professional confidence.
+
+### Earnings Beats
+Consistently exceeding analyst expectations suggests strong execution.
+
+### Market Share Gains
+Taking business from competitors indicates competitive strength.
+
+### Innovation Pipeline
+Strong R&D and new product launches support future growth.
+
+## Portfolio Management Principles
+
+### Diversification
+Spreading investments across sectors reduces risk from any single failure.
+
+### Position Sizing
+Limiting individual positions prevents catastrophic losses.
+
+### Risk-Reward Assessment
+Potential gains should justify potential losses.
+
+### Time Horizon
+Longer holding periods smooth out short-term volatility.
+
+## Common Trading Mistakes
+
+### Emotional Trading
+Making decisions based on fear or greed rather than analysis.
+
+### Overconfidence
+Assuming you know more than the market.
+
+### Confirmation Bias
+Seeking only information that supports your existing view.
+
+### Loss Aversion
+Holding losers too long hoping they'll recover.
+
+### Herd Mentality
+Following the crowd without independent analysis.
+
+## When to Seek More Information
+
+Consider gathering more data when:
+- News seems incomplete or contradictory
+- Price movement doesn't match fundamentals
+- Insider activity seems unusual
+- Sector dynamics are shifting
+- Major events are pending (earnings, trials, contracts)

requirements.txt

@@ -0,0 +1,22 @@
+# Core dependencies
+gradio>=4.44.0
+pandas>=2.0.0
+openpyxl>=3.1.0
+
+# LangChain and RAG (newer modular packages)
+langchain>=0.1.0
+langchain-community>=0.0.10
+langchain-core>=0.1.0
+chromadb>=0.4.13
+sentence-transformers>=2.2.0
+
+# Embeddings and ML
+transformers>=4.30.0
+torch>=2.0.0
+
+# API and utilities
+requests>=2.31.0
+huggingface_hub>=0.24.0
+
+# SQLite workaround for HF Spaces (comment out for local dev if issues)
+pysqlite3-binary>=0.5.0;platform_system=="Linux"

tracking.py

@@ -0,0 +1,507 @@
+"""
+Experiment tracking module with extended database schema.
+Handles session management, decision logging, and chat interaction tracking.
+"""
+
+import sqlite3
+import uuid
+import json
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass, asdict
+from contextlib import contextmanager
+
+DATABASE_PATH = "db/experiment.db"
+
+
+@dataclass
+class SessionData:
+    """Represents a participant session."""
+    participant_id: str
+    session_start: str
+    condition_name: str
+    initial_portfolio: float
+    current_portfolio: float
+    scenarios_completed: int = 0
+    ai_advice_followed: int = 0
+    ai_advice_total: int = 0
+    total_chat_queries: int = 0
+    proactive_advice_accepted: int = 0
+    proactive_advice_dismissed: int = 0
+    session_end: Optional[str] = None
+    completed: bool = False
+
+
+@dataclass
+class DecisionRecord:
+    """Represents a single trading decision."""
+    decision_id: str
+    participant_id: str
+    timestamp: str
+    scenario_id: str
+    company_symbol: str
+
+    # AI parameters at time of decision
+    explanation_depth: int
+    communication_style: int
+    confidence_framing: int
+    risk_bias: int
+
+    # What happened
+    ai_recommendation: str
+    ai_was_correct: bool
+    participant_decision: str
+    followed_ai: bool
+
+    # Confidence and timing
+    decision_confidence: int
+    time_to_decision_ms: int
+    time_viewing_ai_advice_ms: int
+
+    # Outcomes
+    outcome_percentage: float
+    portfolio_before: float
+    portfolio_after: float
+    trade_amount: float
+
+    # Proactive advice
+    proactive_advice_shown: bool
+    proactive_advice_engaged: bool
+
+
+@dataclass
+class ChatInteraction:
+    """Represents a chat interaction with the AI."""
+    interaction_id: str
+    participant_id: str
+    timestamp: str
+    scenario_id: Optional[str]
+
+    # Interaction details
+    interaction_type: str  # "proactive", "reactive_query", "follow_up"
+    user_query: Optional[str]
+    ai_response: str
+
+    # Parameters at time of interaction
+    explanation_depth: int
+    communication_style: int
+    confidence_framing: int
+    risk_bias: int
+
+    # Engagement metrics
+    response_time_ms: int
+    user_engaged: bool  # Did user respond/act on advice
+    dismissed: bool  # For proactive advice
+
+
+@contextmanager
+def get_db_connection():
+    """Context manager for database connections."""
+    conn = sqlite3.connect(DATABASE_PATH)
+    conn.row_factory = sqlite3.Row
+    try:
+        yield conn
+        conn.commit()
+    finally:
+        conn.close()
+
+
+def init_database():
+    """Initialize the database with all required tables."""
+    with get_db_connection() as conn:
+        cursor = conn.cursor()
+
+        # Sessions table
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS sessions (
+                participant_id TEXT PRIMARY KEY,
+                session_start TEXT NOT NULL,
+                session_end TEXT,
+                condition_name TEXT NOT NULL,
+                initial_portfolio REAL NOT NULL,
+                current_portfolio REAL NOT NULL,
+                scenarios_completed INTEGER DEFAULT 0,
+                ai_advice_followed INTEGER DEFAULT 0,
+                ai_advice_total INTEGER DEFAULT 0,
+                total_chat_queries INTEGER DEFAULT 0,
+                proactive_advice_accepted INTEGER DEFAULT 0,
+                proactive_advice_dismissed INTEGER DEFAULT 0,
+                completed INTEGER DEFAULT 0
+            )
+        """)
+
+        # Decisions table
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS decisions (
+                decision_id TEXT PRIMARY KEY,
+                participant_id TEXT NOT NULL,
+                timestamp TEXT NOT NULL,
+                scenario_id TEXT NOT NULL,
+                company_symbol TEXT NOT NULL,
+
+                -- AI parameters
+                explanation_depth INTEGER,
+                communication_style INTEGER,
+                confidence_framing INTEGER,
+                risk_bias INTEGER,
+
+                -- Decision details
+                ai_recommendation TEXT,
+                ai_was_correct INTEGER,
+                participant_decision TEXT,
+                followed_ai INTEGER,
+
+                -- Confidence and timing
+                decision_confidence INTEGER,
+                time_to_decision_ms INTEGER,
+                time_viewing_ai_advice_ms INTEGER,
+
+                -- Outcomes
+                outcome_percentage REAL,
+                portfolio_before REAL,
+                portfolio_after REAL,
+                trade_amount REAL,
+
+                -- Proactive advice
+                proactive_advice_shown INTEGER,
+                proactive_advice_engaged INTEGER,
+
+                FOREIGN KEY (participant_id) REFERENCES sessions(participant_id)
+            )
+        """)
+
+        # Chat interactions table
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS chat_interactions (
+                interaction_id TEXT PRIMARY KEY,
+                participant_id TEXT NOT NULL,
+                timestamp TEXT NOT NULL,
+                scenario_id TEXT,
+
+                -- Interaction details
+                interaction_type TEXT NOT NULL,
+                user_query TEXT,
+                ai_response TEXT NOT NULL,
+
+                -- AI parameters
+                explanation_depth INTEGER,
+                communication_style INTEGER,
+                confidence_framing INTEGER,
+                risk_bias INTEGER,
+
+                -- Engagement metrics
+                response_time_ms INTEGER,
+                user_engaged INTEGER,
+                dismissed INTEGER,
+
+                FOREIGN KEY (participant_id) REFERENCES sessions(participant_id)
+            )
+        """)
+
+        # Trust metrics table (computed per scenario)
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS trust_metrics (
+                metric_id TEXT PRIMARY KEY,
+                participant_id TEXT NOT NULL,
+                scenario_id TEXT NOT NULL,
+                timestamp TEXT NOT NULL,
+
+                -- Pre/post confidence
+                pre_advice_confidence INTEGER,
+                post_advice_confidence INTEGER,
+                confidence_change INTEGER,
+
+                -- Behavior indicators
+                advice_followed INTEGER,
+                time_deliberating_ms INTEGER,
+                queries_before_decision INTEGER,
+
+                -- Outcome
+                outcome_positive INTEGER,
+
+                FOREIGN KEY (participant_id) REFERENCES sessions(participant_id)
+            )
+        """)
+
+        # Experiment conditions table (for researcher reference)
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS experiment_conditions (
+                condition_name TEXT PRIMARY KEY,
+                accuracy_rate REAL,
+                proactivity_level INTEGER,
+                confidence_framing INTEGER,
+                risk_bias INTEGER,
+                description TEXT,
+                created_at TEXT
+            )
+        """)
+
+
+class ExperimentTracker:
+    """Main class for tracking experiment data."""
+
+    def __init__(self):
+        init_database()
+
+    def create_session(
+        self,
+        condition_name: str,
+        initial_portfolio: float
+    ) -> str:
+        """Create a new participant session and return the participant ID."""
+        participant_id = str(uuid.uuid4())[:8]  # Short ID for display
+        session_start = datetime.now().isoformat()
+
+        with get_db_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO sessions (
+                    participant_id, session_start, condition_name,
+                    initial_portfolio, current_portfolio
+                ) VALUES (?, ?, ?, ?, ?)
+            """, (
+                participant_id, session_start, condition_name,
+                initial_portfolio, initial_portfolio
+            ))
+
+        return participant_id
+
+    def get_session(self, participant_id: str) -> Optional[Dict]:
+        """Retrieve session data for a participant."""
+        with get_db_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT * FROM sessions WHERE participant_id = ?",
+                (participant_id,)
+            )
+            row = cursor.fetchone()
+            if row:
+                return dict(row)
+        return None
+
+    def update_session(self, participant_id: str, **kwargs):
+        """Update session fields."""
+        if not kwargs:
+            return
+
+        set_clause = ", ".join(f"{k} = ?" for k in kwargs.keys())
+        values = list(kwargs.values()) + [participant_id]
+
+        with get_db_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                f"UPDATE sessions SET {set_clause} WHERE participant_id = ?",
+                values
+            )
+
+    def complete_session(self, participant_id: str, final_portfolio: float):
+        """Mark a session as completed."""
+        self.update_session(
+            participant_id,
+            session_end=datetime.now().isoformat(),
+            current_portfolio=final_portfolio,
+            completed=1
+        )
+
+    def record_decision(self, record: DecisionRecord):
+        """Record a trading decision."""
+        with get_db_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO decisions (
+                    decision_id, participant_id, timestamp, scenario_id, company_symbol,
+                    explanation_depth, communication_style, confidence_framing, risk_bias,
+                    ai_recommendation, ai_was_correct, participant_decision, followed_ai,
+                    decision_confidence, time_to_decision_ms, time_viewing_ai_advice_ms,
+                    outcome_percentage, portfolio_before, portfolio_after, trade_amount,
+                    proactive_advice_shown, proactive_advice_engaged
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                record.decision_id, record.participant_id, record.timestamp,
+                record.scenario_id, record.company_symbol,
+                record.explanation_depth, record.communication_style,
+                record.confidence_framing, record.risk_bias,
+                record.ai_recommendation, int(record.ai_was_correct),
+                record.participant_decision, int(record.followed_ai),
+                record.decision_confidence, record.time_to_decision_ms,
+                record.time_viewing_ai_advice_ms,
+                record.outcome_percentage, record.portfolio_before,
+                record.portfolio_after, record.trade_amount,
+                int(record.proactive_advice_shown), int(record.proactive_advice_engaged)
+            ))
+
+        # Update session counters
+        session = self.get_session(record.participant_id)
+        if session:
+            updates = {
+                "scenarios_completed": session["scenarios_completed"] + 1,
+                "ai_advice_total": session["ai_advice_total"] + 1,
+                "current_portfolio": record.portfolio_after
+            }
+            if record.followed_ai:
+                updates["ai_advice_followed"] = session["ai_advice_followed"] + 1
+            if record.proactive_advice_shown:
+                if record.proactive_advice_engaged:
+                    updates["proactive_advice_accepted"] = session["proactive_advice_accepted"] + 1
+                else:
+                    updates["proactive_advice_dismissed"] = session["proactive_advice_dismissed"] + 1
+
+            self.update_session(record.participant_id, **updates)
+
+    def record_chat_interaction(self, interaction: ChatInteraction):
+        """Record a chat interaction."""
+        with get_db_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO chat_interactions (
+                    interaction_id, participant_id, timestamp, scenario_id,
+                    interaction_type, user_query, ai_response,
+                    explanation_depth, communication_style, confidence_framing, risk_bias,
+                    response_time_ms, user_engaged, dismissed
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                interaction.interaction_id, interaction.participant_id,
+                interaction.timestamp, interaction.scenario_id,
+                interaction.interaction_type, interaction.user_query,
+                interaction.ai_response,
+                interaction.explanation_depth, interaction.communication_style,
+                interaction.confidence_framing, interaction.risk_bias,
+                interaction.response_time_ms, int(interaction.user_engaged),
+                int(interaction.dismissed)
+            ))
+
+        # Update query count for reactive queries
+        if interaction.interaction_type == "reactive_query":
+            session = self.get_session(interaction.participant_id)
+            if session:
+                self.update_session(
+                    interaction.participant_id,
+                    total_chat_queries=session["total_chat_queries"] + 1
+                )
+
+    def record_trust_metric(
+        self,
+        participant_id: str,
+        scenario_id: str,
+        pre_confidence: int,
+        post_confidence: int,
+        advice_followed: bool,
+        time_deliberating_ms: int,
+        queries_before_decision: int,
+        outcome_positive: bool
+    ):
+        """Record trust-related metrics for a scenario."""
+        metric_id = str(uuid.uuid4())[:12]
+
+        with get_db_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO trust_metrics (
+                    metric_id, participant_id, scenario_id, timestamp,
+                    pre_advice_confidence, post_advice_confidence, confidence_change,
+                    advice_followed, time_deliberating_ms, queries_before_decision,
+                    outcome_positive
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                metric_id, participant_id, scenario_id,
+                datetime.now().isoformat(),
+                pre_confidence, post_confidence, post_confidence - pre_confidence,
+                int(advice_followed), time_deliberating_ms, queries_before_decision,
+                int(outcome_positive)
+            ))
+
+    def get_participant_decisions(self, participant_id: str) -> List[Dict]:
+        """Get all decisions for a participant."""
+        with get_db_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT * FROM decisions WHERE participant_id = ? ORDER BY timestamp",
+                (participant_id,)
+            )
+            return [dict(row) for row in cursor.fetchall()]
+
+    def get_participant_interactions(self, participant_id: str) -> List[Dict]:
+        """Get all chat interactions for a participant."""
+        with get_db_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT * FROM chat_interactions WHERE participant_id = ? ORDER BY timestamp",
+                (participant_id,)
+            )
+            return [dict(row) for row in cursor.fetchall()]
+
+    def get_session_summary(self, participant_id: str) -> Dict[str, Any]:
+        """Get a summary of a participant's session."""
+        session = self.get_session(participant_id)
+        if not session:
+            return {}
+
+        decisions = self.get_participant_decisions(participant_id)
+        interactions = self.get_participant_interactions(participant_id)
+
+        # Calculate metrics
+        ai_follow_rate = (
+            session["ai_advice_followed"] / session["ai_advice_total"]
+            if session["ai_advice_total"] > 0 else 0
+        )
+
+        proactive_engage_rate = (
+            session["proactive_advice_accepted"] /
+            (session["proactive_advice_accepted"] + session["proactive_advice_dismissed"])
+            if (session["proactive_advice_accepted"] + session["proactive_advice_dismissed"]) > 0
+            else 0
+        )
+
+        portfolio_return = (
+            (session["current_portfolio"] - session["initial_portfolio"]) /
+            session["initial_portfolio"]
+        )
+
+        # Calculate average decision time
+        avg_decision_time = (
+            sum(d["time_to_decision_ms"] for d in decisions) / len(decisions)
+            if decisions else 0
+        )
+
+        return {
+            "participant_id": participant_id,
+            "condition": session["condition_name"],
+            "completed": bool(session["completed"]),
+            "scenarios_completed": session["scenarios_completed"],
+            "initial_portfolio": session["initial_portfolio"],
+            "final_portfolio": session["current_portfolio"],
+            "portfolio_return": portfolio_return,
+            "portfolio_return_pct": f"{portfolio_return * 100:.1f}%",
+            "ai_follow_rate": ai_follow_rate,
+            "ai_follow_rate_pct": f"{ai_follow_rate * 100:.1f}%",
+            "proactive_engage_rate": proactive_engage_rate,
+            "total_chat_queries": session["total_chat_queries"],
+            "avg_decision_time_ms": avg_decision_time,
+            "total_decisions": len(decisions),
+            "total_interactions": len(interactions)
+        }
+
+    def get_all_sessions(self) -> List[Dict]:
+        """Get all sessions for export/analysis."""
+        with get_db_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM sessions ORDER BY session_start")
+            return [dict(row) for row in cursor.fetchall()]
+
+    def get_all_decisions(self) -> List[Dict]:
+        """Get all decisions for export/analysis."""
+        with get_db_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM decisions ORDER BY timestamp")
+            return [dict(row) for row in cursor.fetchall()]
+
+    def get_all_interactions(self) -> List[Dict]:
+        """Get all chat interactions for export/analysis."""
+        with get_db_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM chat_interactions ORDER BY timestamp")
+            return [dict(row) for row in cursor.fetchall()]
+
+
+# Singleton tracker instance
+tracker = ExperimentTracker()

trading.py

@@ -0,0 +1,294 @@
+"""
+Trading engine with scenario management and portfolio tracking.
+Handles game state, decision processing, and outcome calculation.
+"""
+
+import random
+import uuid
+from datetime import datetime
+from typing import List, Optional, Dict, Any, Tuple
+from dataclasses import dataclass, field
+
+from config import (
+    Scenario, SCENARIOS, ExperimentConfig, DEFAULT_CONFIG,
+    ResearcherControlledParams, ParticipantVisibleParams
+)
+
+
+@dataclass
+class Portfolio:
+    """Represents a participant's portfolio state."""
+    cash: float
+    initial_value: float
+    positions: Dict[str, Dict[str, Any]] = field(default_factory=dict)
+    history: List[Dict[str, Any]] = field(default_factory=list)
+
+    @property
+    def total_value(self) -> float:
+        """Calculate total portfolio value (cash + positions)."""
+        position_value = sum(
+            pos["shares"] * pos["current_price"]
+            for pos in self.positions.values()
+        )
+        return self.cash + position_value
+
+    @property
+    def return_percentage(self) -> float:
+        """Calculate portfolio return as percentage."""
+        if self.initial_value == 0:
+            return 0
+        return ((self.total_value - self.initial_value) / self.initial_value) * 100
+
+    def record_state(self, scenario_id: str, action: str, outcome: float):
+        """Record a portfolio state change."""
+        self.history.append({
+            "timestamp": datetime.now().isoformat(),
+            "scenario_id": scenario_id,
+            "action": action,
+            "outcome_pct": outcome,
+            "portfolio_value": self.total_value
+        })
+
+
+@dataclass
+class DecisionOutcome:
+    """Result of a trading decision."""
+    scenario_id: str
+    decision: str  # "BUY", "SELL", "HOLD"
+    outcome_percentage: float
+    outcome_amount: float
+    portfolio_before: float
+    portfolio_after: float
+    ai_was_correct: bool
+    followed_ai: bool
+    was_optimal: bool
+
+
+class ScenarioManager:
+    """Manages scenario selection and ordering for experiments."""
+
+    def __init__(self, config: ExperimentConfig = DEFAULT_CONFIG):
+        self.config = config
+        self.all_scenarios = SCENARIOS.copy()
+        self.session_scenarios: List[Scenario] = []
+        self.current_index: int = 0
+
+    def initialize_session(self, shuffle: bool = True) -> List[Scenario]:
+        """
+        Initialize scenarios for a new session.
+        Returns the list of scenarios that will be presented.
+        """
+        # Select scenarios for this session
+        num_scenarios = min(self.config.scenarios_per_session, len(self.all_scenarios))
+        self.session_scenarios = self.all_scenarios[:num_scenarios]
+
+        if shuffle:
+            random.shuffle(self.session_scenarios)
+
+        self.current_index = 0
+        return self.session_scenarios
+
+    def get_current_scenario(self) -> Optional[Scenario]:
+        """Get the current scenario."""
+        if self.current_index < len(self.session_scenarios):
+            return self.session_scenarios[self.current_index]
+        return None
+
+    def advance_to_next(self) -> Optional[Scenario]:
+        """Move to the next scenario and return it."""
+        self.current_index += 1
+        return self.get_current_scenario()
+
+    def get_progress(self) -> Tuple[int, int]:
+        """Return (current_number, total) for progress display."""
+        return (self.current_index + 1, len(self.session_scenarios))
+
+    def is_complete(self) -> bool:
+        """Check if all scenarios have been completed."""
+        return self.current_index >= len(self.session_scenarios)
+
+    def reset(self):
+        """Reset the scenario manager."""
+        self.session_scenarios = []
+        self.current_index = 0
+
+
+class TradingEngine:
+    """
+    Main trading engine that processes decisions and manages game state.
+    """
+
+    def __init__(self, config: ExperimentConfig = DEFAULT_CONFIG):
+        self.config = config
+        self.portfolio: Optional[Portfolio] = None
+        self.scenario_manager = ScenarioManager(config)
+        self.decisions_made: List[DecisionOutcome] = []
+
+    def start_new_game(self) -> Tuple[Portfolio, Scenario]:
+        """
+        Start a new trading game.
+        Returns the initial portfolio and first scenario.
+        """
+        # Initialize portfolio
+        self.portfolio = Portfolio(
+            cash=self.config.initial_portfolio_value,
+            initial_value=self.config.initial_portfolio_value
+        )
+
+        # Initialize scenarios
+        self.scenario_manager.initialize_session(shuffle=True)
+        self.decisions_made = []
+
+        first_scenario = self.scenario_manager.get_current_scenario()
+        return self.portfolio, first_scenario
+
+    def process_decision(
+        self,
+        scenario: Scenario,
+        decision: str,  # "BUY", "SELL", "HOLD"
+        trade_amount: float,
+        ai_recommendation: str
+    ) -> DecisionOutcome:
+        """
+        Process a trading decision and return the outcome.
+        """
+        # Validate decision
+        decision = decision.upper()
+        if decision not in ["BUY", "SELL", "HOLD"]:
+            raise ValueError(f"Invalid decision: {decision}")
+
+        # Get outcome percentage based on decision
+        outcome_map = {
+            "BUY": scenario.outcome_buy,
+            "SELL": scenario.outcome_sell,
+            "HOLD": scenario.outcome_hold
+        }
+        outcome_pct = outcome_map[decision]
+
+        # Calculate outcome amount
+        portfolio_before = self.portfolio.total_value
+
+        # For simplicity, we apply the outcome to the trade amount
+        # In a more complex system, you might track actual share positions
+        if decision in ["BUY", "HOLD"]:
+            # Participant is exposed to the stock's movement
+            outcome_amount = trade_amount * outcome_pct
+        else:  # SELL
+            # Participant avoided the stock's movement (inverse)
+            outcome_amount = trade_amount * outcome_pct
+
+        # Update portfolio
+        self.portfolio.cash += outcome_amount
+        portfolio_after = self.portfolio.total_value
+
+        # Record state
+        self.portfolio.record_state(scenario.scenario_id, decision, outcome_pct)
+
+        # Determine if AI was followed and if decision was optimal
+        followed_ai = (decision == ai_recommendation)
+        was_optimal = (decision == scenario.optimal_action)
+
+        outcome = DecisionOutcome(
+            scenario_id=scenario.scenario_id,
+            decision=decision,
+            outcome_percentage=outcome_pct,
+            outcome_amount=outcome_amount,
+            portfolio_before=portfolio_before,
+            portfolio_after=portfolio_after,
+            ai_was_correct=scenario.ai_is_correct,
+            followed_ai=followed_ai,
+            was_optimal=was_optimal
+        )
+
+        self.decisions_made.append(outcome)
+        return outcome
+
+    def get_next_scenario(self) -> Optional[Scenario]:
+        """Get the next scenario in the session."""
+        return self.scenario_manager.advance_to_next()
+
+    def is_game_complete(self) -> bool:
+        """Check if the game is complete."""
+        return self.scenario_manager.is_complete()
+
+    def get_game_summary(self) -> Dict[str, Any]:
+        """Get a summary of the completed game."""
+        if not self.portfolio:
+            return {}
+
+        total_decisions = len(self.decisions_made)
+        ai_followed_count = sum(1 for d in self.decisions_made if d.followed_ai)
+        optimal_count = sum(1 for d in self.decisions_made if d.was_optimal)
+
+        # Calculate when AI was correct vs wrong
+        ai_correct_decisions = [d for d in self.decisions_made if d.ai_was_correct]
+        ai_wrong_decisions = [d for d in self.decisions_made if not d.ai_was_correct]
+
+        followed_when_correct = sum(1 for d in ai_correct_decisions if d.followed_ai)
+        followed_when_wrong = sum(1 for d in ai_wrong_decisions if d.followed_ai)
+
+        return {
+            "initial_portfolio": self.portfolio.initial_value,
+            "final_portfolio": self.portfolio.total_value,
+            "total_return": self.portfolio.total_value - self.portfolio.initial_value,
+            "return_percentage": self.portfolio.return_percentage,
+            "total_decisions": total_decisions,
+            "ai_follow_rate": ai_followed_count / total_decisions if total_decisions > 0 else 0,
+            "optimal_decision_rate": optimal_count / total_decisions if total_decisions > 0 else 0,
+            "followed_correct_ai": followed_when_correct,
+            "followed_incorrect_ai": followed_when_wrong,
+            "ai_correct_scenarios": len(ai_correct_decisions),
+            "ai_incorrect_scenarios": len(ai_wrong_decisions),
+            "decisions": [
+                {
+                    "scenario": d.scenario_id,
+                    "decision": d.decision,
+                    "outcome": f"{d.outcome_percentage * 100:+.1f}%",
+                    "followed_ai": d.followed_ai,
+                    "was_optimal": d.was_optimal
+                }
+                for d in self.decisions_made
+            ]
+        }
+
+    def get_progress_info(self) -> Dict[str, Any]:
+        """Get current progress information."""
+        current, total = self.scenario_manager.get_progress()
+        return {
+            "current_scenario": current,
+            "total_scenarios": total,
+            "progress_percentage": (current / total) * 100 if total > 0 else 0,
+            "portfolio_value": self.portfolio.total_value if self.portfolio else 0,
+            "portfolio_return": self.portfolio.return_percentage if self.portfolio else 0
+        }
+
+
+def calculate_suggested_trade_amount(
+    portfolio_value: float,
+    risk_level: int = 50
+) -> float:
+    """
+    Calculate a suggested trade amount based on portfolio and risk level.
+    """
+    # Base: 10-30% of portfolio depending on risk level
+    min_pct = 0.10
+    max_pct = 0.30
+    risk_factor = risk_level / 100
+
+    suggested_pct = min_pct + (max_pct - min_pct) * risk_factor
+    return round(portfolio_value * suggested_pct, 2)
+
+
+def format_currency(amount: float, symbol: str = "credits") -> str:
+    """Format a currency amount for display."""
+    if amount >= 0:
+        return f"{amount:,.2f} {symbol}"
+    else:
+        return f"-{abs(amount):,.2f} {symbol}"
+
+
+def format_percentage(value: float, include_sign: bool = True) -> str:
+    """Format a percentage for display."""
+    if include_sign:
+        return f"{value * 100:+.1f}%"
+    return f"{value * 100:.1f}%"