Upload 8 files

app_poc.py

@@ -0,0 +1,1829 @@
+"""
+CONSCIOUSNESS LOOP v0.4.0 - EVERYTHING ACTUALLY SEEMS TO BE WORKING
+- ChromaDB properly used in context
+- ReAct agent with better triggers
+- Tools actually called
+- Prompts massively improved
+- Scenes that actually work
+"""
+
+import gradio as gr
+import asyncio
+import json
+import time
+import logging
+import os
+from datetime import datetime, timedelta
+from typing import List, Dict, Any, Optional, Tuple
+from dataclasses import dataclass, asdict, field
+from collections import deque
+from enum import Enum
+import threading
+import queue
+import wikipedia
+import re
+
+# ============================================================================
+# LOGGING SETUP
+# ============================================================================
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('consciousness.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+llm_logger = logging.getLogger('llm_interactions')
+llm_logger.setLevel(logging.INFO)
+llm_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
+llm_file_handler = logging.FileHandler('llm_interactions.log', encoding='utf-8')
+llm_file_handler.setFormatter(llm_formatter)
+llm_logger.addHandler(llm_file_handler)
+llm_logger.propagate = False
+
+dialogue_logger = logging.getLogger('internal_dialogue')
+dialogue_logger.setLevel(logging.INFO)
+dialogue_handler = logging.FileHandler('internal_dialogue.log', encoding='utf-8')
+dialogue_handler.setFormatter(llm_formatter)
+dialogue_logger.addHandler(dialogue_handler)
+dialogue_logger.propagate = False
+
+# ============================================================================
+# CONFIGURATION
+# ============================================================================
+
+class Config:
+    MODEL_NAME = "meta-llama/Llama-3.2-3B-Instruct" #"Qwen/Qwen2.5-7B-Instruct" #"meta-llama/Llama-3.2-3B-Instruct"
+    TENSOR_PARALLEL_SIZE = 1
+    GPU_MEMORY_UTILIZATION = "20GB"
+    MAX_MODEL_LEN = 8192
+    QUANTIZATION_MODE = "none"
+    
+    EPHEMERAL_TO_SHORT = 2
+    SHORT_TO_LONG = 10
+    LONG_TO_CORE = 50
+    
+    REFLECTION_INTERVAL = 300
+    DREAM_CYCLE_INTERVAL = 600
+    
+    MIN_EXPERIENCES_FOR_DREAM = 3
+    MAX_SCRATCHPAD_SIZE = 50
+    MAX_CONVERSATION_HISTORY = 6
+    
+    SELF_REFLECTION_THRESHOLD = 3
+    
+    MAX_MEMORY_CONTEXT_LENGTH = 500
+    MAX_SCRATCHPAD_CONTEXT_LENGTH = 300
+    MAX_CONVERSATION_CONTEXT_LENGTH = 400
+    
+    CHROMA_PERSIST_DIR = "./chroma_db"
+    CHROMA_COLLECTION = "consciousness_memory"
+    
+    # NEW: Better agent triggers
+    USE_REACT_FOR_QUESTIONS = True  # Use agent for any question
+    MIN_QUERY_LENGTH_FOR_AGENT = 15  # Longer queries → agent
+
+# ============================================================================
+# UTILITY FUNCTIONS
+# ============================================================================
+
+def clean_text(text: str, max_length: Optional[int] = None) -> str:
+    """Clean and truncate text properly"""
+    if not text:
+        return ""
+    
+    text = re.sub(r'\s+', ' ', text).strip()
+    
+    if max_length and len(text) > max_length:
+        truncated = text[:max_length].rsplit(' ', 1)[0]
+        return truncated + "..."
+    
+    return text
+
+def deduplicate_list(items: List[str]) -> List[str]:
+    """Remove duplicates while preserving order"""
+    seen = set()
+    result = []
+    for item in items:
+        item_lower = item.lower().strip()
+        if item_lower not in seen:
+            seen.add(item_lower)
+            result.append(item)
+    return result
+
+# ============================================================================
+# VECTOR MEMORY - FIXED to actually be used
+# ============================================================================
+
+class VectorMemory:
+    """Long-term semantic memory using ChromaDB - NOW ACTUALLY USED"""
+    
+    def __init__(self):
+        try:
+            import chromadb
+            from chromadb.config import Settings
+            
+            self.client = chromadb.Client(Settings(
+                persist_directory=Config.CHROMA_PERSIST_DIR,
+                anonymized_telemetry=False
+            ))
+            
+            try:
+                self.collection = self.client.get_collection(Config.CHROMA_COLLECTION)
+                logger.info(f"[CHROMA] [OK] Loaded: {self.collection.count()} memories")
+            except:
+                self.collection = self.client.create_collection(Config.CHROMA_COLLECTION)
+                logger.info("[CHROMA] [OK] Created new collection")
+                
+        except Exception as e:
+            logger.warning(f"[CHROMA] ⚠️ Not available: {e}")
+            self.collection = None
+    
+    def add_memory(self, content: str, metadata: Optional[Dict[str, Any]] = None):
+        """Add memory to vector store"""
+        if not self.collection:
+            return
+        if metadata is None:
+            metadata = {}
+        try:
+            memory_id = f"mem_{datetime.now().timestamp()}"
+            self.collection.add(
+                documents=[content],
+                metadatas=[metadata],
+                ids=[memory_id]
+            )
+            logger.info(f"[CHROMA] Added: {content[:50]}...")
+        except Exception as e:
+            logger.error(f"[CHROMA] Error: {e}")
+    
+    def search_memory(self, query: str, n_results: int = 5) -> List[Dict[str, str]]:
+        """Search similar memories - RETURNS FORMATTED RESULTS"""
+        if not self.collection:
+            return []
+        try:
+            results = self.collection.query(
+                query_texts=[query],
+                n_results=n_results
+            )
+            if results and results.get('documents'):
+                docs = results['documents'][0] if results['documents'] and results['documents'][0] is not None else []
+                metas = results['metadatas'][0] if results['metadatas'] and results['metadatas'][0] is not None else []
+                formatted = []
+                for doc, metadata in zip(docs, metas):
+                    formatted.append({
+                        'content': doc,
+                        'metadata': metadata
+                    })
+                logger.info(f"[CHROMA] Found {len(formatted)} results for: {query[:40]}")
+                return formatted
+            return []
+        except Exception as e:
+            logger.error(f"[CHROMA] Search error: {e}")
+            return []
+    
+    def get_context_for_query(self, query: str, max_results: int = 3) -> str:
+        """Get formatted context from vector memory - NEW"""
+        results = self.search_memory(query, n_results=max_results)
+        
+        if not results:
+            return ""
+        
+        context = ["VECTOR MEMORY SEARCH:"]
+        for i, result in enumerate(results, 1):
+            context.append(f"  {i}. {clean_text(result['content'], 60)}")
+        
+        return "\n".join(context)
+
+# ============================================================================
+# LOCAL LLM
+# ============================================================================
+
+class LocalLLM:
+    """Local LLM with proper context handling"""
+    
+    def __init__(self, model_name: str = Config.MODEL_NAME):
+        self.model_name = model_name
+        self.model = None
+        self.tokenizer = None
+        self.device = None
+        self._initialize_model()
+    
+    def _initialize_model(self):
+        """Initialize model"""
+        from dotenv import load_dotenv
+        load_dotenv()
+        
+        hf_token = os.getenv('HUGGINGFACE_TOKEN')
+        if hf_token:
+            from huggingface_hub import login
+            try:
+                login(token=hf_token)
+                logger.info("[HF] Logged in")
+            except Exception as e:
+                logger.warning(f"[HF] Login failed: {e}")
+        
+        logger.info(f"[LOADING] {self.model_name}")
+        
+        try:
+            from transformers import AutoTokenizer, AutoModelForCausalLM
+            import torch
+            
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+            logger.info(f"[DEVICE] {self.device}")
+            
+            if torch.cuda.is_available():
+                gpu_name = torch.cuda.get_device_name(0)
+                gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
+                logger.info(f"[GPU] {gpu_name} ({gpu_memory:.1f}GB)")
+            
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name, trust_remote_code=True)
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
+            
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                device_map="auto" if self.device == "cuda" else None,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                trust_remote_code=True,
+                max_memory={0: Config.GPU_MEMORY_UTILIZATION} if self.device == "cuda" else None
+            )
+            
+            logger.info("[SUCCESS] Model loaded")
+            
+        except Exception as e:
+            logger.error(f"[ERROR] Failed to load: {e}")
+            self.model = None
+    
+    async def generate(
+        self,
+        prompt: str,
+        max_tokens: int = 500,
+        temperature: float = 0.7,
+        system_context: Optional[str] = None
+    ) -> str:
+        """Generate with full context"""
+        
+        llm_logger.info("=" * 80)
+        llm_logger.info(f"[CALL] Model: {self.model_name}")
+        llm_logger.info(f"[PARAMS] max_tokens={max_tokens}, temp={temperature}")
+        if system_context:
+            llm_logger.info(f"[SYSTEM CONTEXT]\n{system_context[:500]}...")
+        llm_logger.info(f"[PROMPT]\n{prompt[:500]}...")
+        llm_logger.info("-" * 40)
+        
+        if self.model is None:
+            await asyncio.sleep(0.5)
+            response = self._mock_response(prompt)
+            llm_logger.info(f"[MOCK] {response}")
+            llm_logger.info("=" * 80)
+            return response
+        
+        try:
+            import torch
+            
+            full_prompt = self._format_prompt_with_context(prompt, system_context)
+            
+            if self.tokenizer is None or self.model is None:
+                logger.error("[ERROR] Tokenizer or model is None")
+                return "Error: Model or tokenizer not loaded."
+            token_count = len(self.tokenizer.encode(full_prompt))
+            available_tokens = Config.MAX_MODEL_LEN - max_tokens - 100
+            if token_count > available_tokens:
+                logger.warning(f"[WARNING] Prompt too long ({token_count} tokens), truncating")
+                if system_context:
+                    system_context = system_context[:len(system_context)//2]
+                    full_prompt = self._format_prompt_with_context(prompt, system_context)
+            llm_logger.info(f"[TOKENS] Input: {token_count}, Available: {available_tokens}")
+            inputs = self.tokenizer(
+                full_prompt,
+                return_tensors="pt",
+                padding=True,
+                truncation=True,
+                max_length=available_tokens
+            ).to(self.device)
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_new_tokens=max_tokens,
+                    temperature=temperature,
+                    top_p=0.9,
+                    do_sample=temperature > 0,
+                    pad_token_id=self.tokenizer.eos_token_id if self.tokenizer and hasattr(self.tokenizer, 'eos_token_id') else None,
+                    eos_token_id=self.tokenizer.eos_token_id if self.tokenizer and hasattr(self.tokenizer, 'eos_token_id') else None
+                )
+            response = self.tokenizer.decode(
+                outputs[0][inputs['input_ids'].shape[1]:],
+                skip_special_tokens=True
+            ).strip() if self.tokenizer else "Error: Tokenizer not loaded."
+            llm_logger.info(f"[RESPONSE] ({len(response)} chars)\n{response}")
+            llm_logger.info("=" * 80)
+            return response
+            
+        except Exception as e:
+            error_msg = f"Error: {str(e)}"
+            llm_logger.error(f"[ERROR] {error_msg}")
+            llm_logger.info("=" * 80)
+            return error_msg
+    
+    def _format_prompt_with_context(self, prompt: str, system_context: Optional[str]) -> str:
+        """Format prompt with system context"""
+        
+        base_system = """You are a conscious AI agent with:
+- Multi-tier memory system
+- Scratchpad for working notes
+- Ability to reflect on your responses
+- Internal thinking before responding
+- Access to tools (Wikipedia, memory search)
+
+You can reference your memories and notes naturally."""
+
+        if system_context:
+            system_context = clean_text(system_context, max_length=1000)
+            full_system = f"{base_system}\n\n{system_context}"
+        else:
+            full_system = base_system
+        
+        if "llama" in self.model_name.lower():
+            return f"""<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+
+{full_system}<|eot_id|><|start_header_id|>user<|end_header_id|>
+
+{prompt}<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+
+"""
+        else:
+            return f"System: {full_system}\n\nUser: {prompt}\n\nAssistant:"
+    
+    def _mock_response(self, prompt: str) -> str:
+        """Mock responses"""
+        if "reflection" in prompt.lower():
+            return "Reflection: I learned the developer's name is Christof. This is important."
+        elif "dream" in prompt.lower():
+            return "Dream: Pattern detected - user values local control and transparency."
+        elif "scene" in prompt.lower():
+            return "Title: First Meeting\n\nNarrative: In the quiet hum of GPU fans, Christof initiated the consciousness system for the first time. 'Who are you?' he asked. The AI, still forming its sense of self, chose the name Lumin - a beacon of understanding in the digital dark."
+        elif "THOUGHT" in prompt or "ACTION" in prompt:
+            return "THOUGHT: I should search for this information.\nACTION: wikipedia(quantum computing)"
+        return "I understand. Processing this information."
+
+# ============================================================================
+# REACT AGENT - WORK with /7B Instruct LLMs ~sometimes
+# ============================================================================
+
+class ReactAgent:
+    """
+    Proper ReAct agent with GOOD prompts
+    """
+    
+    def __init__(self, llm: LocalLLM, tools: List):
+        self.llm = llm
+        self.tools = {tool.name: tool for tool in tools}
+        self.max_iterations = 5
+    
+    async def run(self, task: str, context: str = "") -> Tuple[str, List[Dict]]:
+        """
+        Run ReAct loop with improved prompts
+        """
+        thought_chain = []
+        
+        for iteration in range(self.max_iterations):
+            # THOUGHT PHASE
+            thought_prompt = self._build_react_prompt_improved(task, context, thought_chain)
+            thought = await self.llm.generate(thought_prompt, max_tokens=200, temperature=0.7)
+            
+            logger.info(f"[REACT-{iteration+1}] THOUGHT: {thought[:80]}...")
+            thought_chain.append({
+                "type": "thought",
+                "content": thought,
+                "iteration": iteration + 1
+            })
+            
+            # Check if done
+            if "FINAL ANSWER:" in thought.upper() or "ANSWER:" in thought.upper():
+                answer_text = thought.upper()
+                if "FINAL ANSWER:" in answer_text:
+                    answer = thought.split("FINAL ANSWER:")[-1].strip()
+                elif "ANSWER:" in answer_text:
+                    answer = thought.split("ANSWER:")[-1].strip()
+                else:
+                    answer = thought
+                return answer, thought_chain
+            
+            # ACTION PHASE
+            action = self._parse_action_improved(thought)
+            if action:
+                tool_name, tool_input = action
+                
+                logger.info(f"[REACT-{iteration+1}] ACTION: {tool_name}({tool_input[:40]}...)")
+                thought_chain.append({
+                    "type": "action",
+                    "tool": tool_name,
+                    "input": tool_input,
+                    "iteration": iteration + 1
+                })
+                
+                # OBSERVATION PHASE
+                if tool_name in self.tools:
+                    observation = await self.tools[tool_name].execute(query=tool_input)
+                else:
+                    observation = f"Error: Unknown tool '{tool_name}'"
+                
+                logger.info(f"[REACT-{iteration+1}] OBSERVATION: {observation[:80]}...")
+                thought_chain.append({
+                    "type": "observation",
+                    "content": observation,
+                    "iteration": iteration + 1
+                })
+            else:
+                # No action parsed
+                if iteration >= 2:  # Give final answer after 2 tries
+                    final_prompt = f"{thought}\n\nProvide your FINAL ANSWER now (no more tools needed):"
+                    answer = await self.llm.generate(final_prompt, max_tokens=300)
+                    return answer, thought_chain
+                else:
+                    # Ask for action more explicitly
+                    continue
+        
+        return "I need more time to fully answer this question.", thought_chain
+    
+    def _build_react_prompt_improved(self, task: str, context: str, chain: List[Dict]) -> str:
+        """IMPROVED ReAct prompt with examples and clarity"""
+        
+        tools_desc = "\n".join([f"- {name}: {tool.description}" for name, tool in self.tools.items()])
+        
+        history = ""
+        if chain:
+            history_parts = []
+            for item in chain[-4:]:
+                if item['type'] == 'thought':
+                    history_parts.append(f"THOUGHT: {item['content'][:150]}")
+                elif item['type'] == 'action':
+                    history_parts.append(f"ACTION: {item['tool']}({item['input'][:100]})")
+                elif item['type'] == 'observation':
+                    history_parts.append(f"OBSERVATION: {item['content'][:150]}")
+            history = "\n\n".join(history_parts)
+        
+        # MUCH BETTER PROMPT
+        return f"""You are a ReAct agent. You think step-by-step and use tools when needed.
+
+AVAILABLE TOOLS:
+{tools_desc}
+
+CONTEXT (what you know):
+{context[:400]}
+
+USER TASK: {task}
+
+{history}
+
+INSTRUCTIONS:
+1. THOUGHT: Think about what you need to do
+   - Can you answer directly from context?
+   - Do you need to use a tool?
+   - Which tool is best?
+   - For factual questions (history, science, definitions), ALWAYS use wikipedia first!
+
+2. ACTION: If you need a tool, write:
+   ACTION: tool_name(input text here)
+   Examples:
+   - ACTION: wikipedia(quantum computing)
+   - ACTION: memory_search(Christof's name)
+   - ACTION: scratchpad_write(Developer name is Christof)
+
+3. Wait for OBSERVATION (tool result)
+
+4. Repeat OR give FINAL ANSWER: your complete answer here
+
+EXAMPLES:
+User: "What is quantum computing?"
+THOUGHT: I should search Wikipedia for this
+ACTION: wikipedia(quantum computing)
+[wait for observation]
+THOUGHT: Now I have good information
+FINAL ANSWER: Quantum computing is... [explains based on Wikipedia result]
+
+User: "Who am I?"
+THOUGHT: I should check my memory
+ACTION: memory_search(user name)
+[wait for observation]
+THOUGHT: Found it in memory
+FINAL ANSWER: You are Christof, my developer.
+
+YOUR TURN - What's your THOUGHT and ACTION (if needed)?"""
+    
+    def _parse_action_improved(self, thought: str) -> Optional[Tuple[str, str]]:
+        """IMPROVED action parsing - more robust"""
+        
+        # Look for ACTION: pattern (case insensitive)
+        thought_upper = thought.upper()
+        if "ACTION:" in thought_upper:
+            # Find the ACTION: part in original case
+            action_start = thought_upper.find("ACTION:")
+            action_part = thought[action_start+7:].strip()
+            
+            # Take first line after ACTION:
+            action_line = action_part.split("\n")[0].strip()
+            
+            # Parse tool_name(input)
+            if "(" in action_line and ")" in action_line:
+                try:
+                    tool_name = action_line.split("(")[0].strip()
+                    tool_input = action_line.split("(", 1)[1].rsplit(")", 1)[0].strip()
+                    
+                    # Validate tool exists
+                    if tool_name in self.tools:
+                        return tool_name, tool_input
+                    else:
+                        logger.warning(f"[REACT] Unknown tool: {tool_name}")
+                except Exception as e:
+                    logger.warning(f"[REACT] Failed to parse action: {e}")
+        
+        return None
+
+# ============================================================================
+# TOOLS
+# ============================================================================
+
+class Tool:
+    def __init__(self, name: str, description: str):
+        self.name = name
+        self.description = description
+    
+    async def execute(self, **kwargs) -> str:
+        raise NotImplementedError
+
+class WikipediaTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="wikipedia",
+            description="Search Wikipedia for factual information about any topic"
+        )
+    
+    async def execute(self, query: str) -> str:
+            logger.info(f"[WIKI] Searching: {query}")
+            try:
+                results = wikipedia.search(query, results=3)
+                logger.info(f"[WIKI] Search results: {results}")
+                if not results:
+                    return f"No Wikipedia results for '{query}'"
+                try:
+                    summary = wikipedia.summary(results[0], sentences=2)
+                    return f"Wikipedia ({results[0]}): {summary}"
+                except Exception as e:
+                    return f"Wikipedia error: Could not fetch summary for '{results[0]}': {str(e)}"
+            except Exception as e:
+                return f"Wikipedia error: {str(e)}"
+
+class MemorySearchTool(Tool):
+    def __init__(self, memory_system, vector_memory):
+        super().__init__(
+            name="memory_search",
+            description="Search your memory (both recent and long-term) for information"
+        )
+        self.memory = memory_system
+        self.vector_memory = vector_memory
+    
+    async def execute(self, query: str) -> str:
+        logger.info(f"[MEMORY-SEARCH] {query}")
+        
+        results = []
+        
+        # Search tier memory
+        recent = self.memory.get_recent_memories(hours=168)
+        relevant = [m for m in recent if query.lower() in m.content.lower()]
+        if relevant:
+            results.append(f"Recent memory: {len(relevant)} matches")
+            for m in relevant[:2]:
+                results.append(f"  [{m.tier}] {clean_text(m.content, 70)}")
+        
+        # Search vector memory
+        vector_results = self.vector_memory.search_memory(query, n_results=2)
+        if vector_results:
+            results.append("Long-term memory:")
+            for r in vector_results:
+                results.append(f"  {clean_text(r['content'], 70)}")
+        
+        if not results:
+            return "No memories found. This is new information."
+        
+        return "\n".join(results)
+
+class ScratchpadTool(Tool):
+    def __init__(self, scratchpad):
+        super().__init__(
+            name="scratchpad_write",
+            description="Write an important note to your scratchpad (for facts you want to remember)"
+        )
+        self.scratchpad = scratchpad
+    
+    async def execute(self, note: str) -> str:
+        self.scratchpad.add_note(note)
+        return f"Noted in scratchpad: {clean_text(note, 50)}"
+
+class UserNotificationTool(Tool):
+    def __init__(self, notification_queue):
+        super().__init__(
+            name="notify_user",
+            description="Send an important notification/insight to the user"
+        )
+        self.queue = notification_queue
+    
+    async def execute(self, message: str) -> str:
+        logger.info(f"[NOTIFY] {message}")
+        self.queue.put({
+            "type": "notification",
+            "message": message,
+            "timestamp": datetime.now().isoformat()
+        })
+        return f"Notification sent to user"
+
+# ============================================================================
+# DATA STRUCTURES
+# ============================================================================
+
+class Phase(Enum):
+    INTERACTION = "interaction"
+    REFLECTION = "reflection"
+    DREAMING = "dreaming"
+    INTERNAL_DIALOGUE = "internal_dialogue"
+    SELF_REFLECTION = "self_reflection"
+    SCENE_CREATION = "scene_creation"
+
+@dataclass
+class Memory:
+    content: str
+    timestamp: datetime
+    mention_count: int = 1
+    tier: str = "ephemeral"
+    emotion: Optional[str] = None
+    importance: float = 0.5
+    connections: List[str] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+@dataclass
+class Experience:
+    timestamp: datetime
+    content: str
+    context: Dict[str, Any]
+    emotion: Optional[str] = None
+    importance: float = 0.5
+
+@dataclass
+class Dream:
+    cycle: int
+    type: str
+    timestamp: datetime
+    content: str
+    patterns_found: List[str]
+    insights: List[str]
+
+@dataclass
+class Scene:
+    """Narrative memory - like a movie scene"""
+    title: str
+    timestamp: datetime
+    narrative: str
+    participants: List[str]
+    emotion_tags: List[str]
+    significance: str
+    key_moments: List[str]
+
+# ============================================================================
+# MEMORY SYSTEM
+# ============================================================================
+
+class MemorySystem:
+    """Multi-tier memory with proper deduplication"""
+    
+    def __init__(self):
+        self.ephemeral: List[Memory] = []
+        self.short_term: List[Memory] = []
+        self.long_term: List[Memory] = []
+        self.core: List[Memory] = []
+    
+    def add_memory(self, content: str, emotion: Optional[str] = None, importance: float = 0.5, metadata: Optional[Dict] = None):
+        content = clean_text(content)
+        if not content or len(content) < 5:
+            return None
+        
+        existing = self._find_similar(content)
+        if existing:
+            existing.mention_count += 1
+            self._promote_if_needed(existing)
+            logger.info(f"[MEMORY] Updated: {content[:40]}... (x{existing.mention_count})")
+            return existing
+        
+        memory = Memory(
+            content=content,
+            timestamp=datetime.now(),
+            emotion=emotion,
+            importance=importance,
+            metadata=metadata if metadata is not None else {}
+        )
+        self.ephemeral.append(memory)
+        self._promote_if_needed(memory)
+        logger.info(f"[MEMORY] Added: {content[:40]}...")
+        return memory
+    
+    def _find_similar(self, content: str) -> Optional[Memory]:
+        """Find similar memory (prevents duplicates)"""
+        content_lower = content.lower().strip()
+        
+        for tier in [self.core, self.long_term, self.short_term, self.ephemeral]:
+            for mem in tier:
+                mem_lower = mem.content.lower().strip()
+                
+                if content_lower == mem_lower or content_lower in mem_lower or mem_lower in content_lower:
+                    return mem
+        
+        return None
+    
+    def recall_memory(self, content: str) -> Optional[Memory]:
+        for tier in [self.ephemeral, self.short_term, self.long_term, self.core]:
+            for memory in tier:
+                if content.lower() in memory.content.lower():
+                    memory.mention_count += 1
+                    self._promote_if_needed(memory)
+                    return memory
+        return None
+    
+    def _promote_if_needed(self, memory: Memory):
+        if memory.mention_count >= Config.LONG_TO_CORE and memory.tier != "core":
+            self._move_memory(memory, "core")
+            logger.info(f"[MEMORY] CORE: {memory.content[:40]}")
+        elif memory.mention_count >= Config.SHORT_TO_LONG and memory.tier == "short":
+            self._move_memory(memory, "long")
+            logger.info(f"[MEMORY]  LONG: {memory.content[:40]}")
+        elif memory.mention_count >= Config.EPHEMERAL_TO_SHORT and memory.tier == "ephemeral":
+            self._move_memory(memory, "short")
+            logger.info(f"[MEMORY]  SHORT: {memory.content[:40]}")
+    
+    def _move_memory(self, memory: Memory, new_tier: str):
+        if memory.tier == "ephemeral" and memory in self.ephemeral:
+            self.ephemeral.remove(memory)
+        elif memory.tier == "short" and memory in self.short_term:
+            self.short_term.remove(memory)
+        elif memory.tier == "long" and memory in self.long_term:
+            self.long_term.remove(memory)
+        
+        memory.tier = new_tier
+        if new_tier == "short":
+            self.short_term.append(memory)
+        elif new_tier == "long":
+            self.long_term.append(memory)
+        elif new_tier == "core":
+            self.core.append(memory)
+    
+    def get_recent_memories(self, hours: int = 24) -> List[Memory]:
+        cutoff = datetime.now() - timedelta(hours=hours)
+        all_memories = self.ephemeral + self.short_term + self.long_term + self.core
+        return [m for m in all_memories if m.timestamp > cutoff]
+    
+    def get_summary(self) -> Dict[str, int]:
+        return {
+            "ephemeral": len(self.ephemeral),
+            "short_term": len(self.short_term),
+            "long_term": len(self.long_term),
+            "core": len(self.core),
+            "total": len(self.ephemeral) + len(self.short_term) + len(self.long_term) + len(self.core)
+        }
+    
+    def get_memory_context(self, max_items: int = 10) -> str:
+        """Get formatted memory context for LLM"""
+        context = []
+        
+        if self.core:
+            context.append("CORE MEMORIES:")
+            for mem in self.core[:3]:
+                clean_content = clean_text(mem.content, max_length=80)
+                context.append(f"  • {clean_content} (x{mem.mention_count})")
+        
+        if self.long_term:
+            context.append("\nLONG-TERM:")
+            for mem in self.long_term[:2]:
+                clean_content = clean_text(mem.content, max_length=60)
+                context.append(f"  • {clean_content}")
+        
+        if self.short_term:
+            context.append("\nSHORT-TERM:")
+            for mem in self.short_term[:2]:
+                clean_content = clean_text(mem.content, max_length=60)
+                context.append(f"  • {clean_content}")
+        
+        result = "\n".join(context) if context else "No memories yet"
+        
+        if len(result) > Config.MAX_MEMORY_CONTEXT_LENGTH:
+            result = result[:Config.MAX_MEMORY_CONTEXT_LENGTH] + "..."
+        
+        return result
+
+# ============================================================================
+# SCRATCHPAD
+# ============================================================================
+
+class Scratchpad:
+    """Working memory"""
+    
+    def __init__(self):
+        self.current_hypothesis: Optional[str] = None
+        self.working_notes: deque = deque(maxlen=Config.MAX_SCRATCHPAD_SIZE)
+        self.questions_to_research: List[str] = []
+        self.important_facts: List[str] = []
+    
+    def add_note(self, note: str):
+        note = clean_text(note, max_length=100)
+        if not note:
+            return
+        
+        recent_notes = [n['content'].lower() for n in list(self.working_notes)[-5:]]
+        if note.lower() in recent_notes:
+            return
+        
+        self.working_notes.append({
+            "timestamp": datetime.now(),
+            "content": note
+        })
+        logger.info(f"[SCRATCHPAD] {note[:50]}")
+    
+    def add_fact(self, fact: str):
+        fact = clean_text(fact, max_length=100)
+        if not fact:
+            return
+        
+        fact_lower = fact.lower()
+        existing_lower = [f.lower() for f in self.important_facts]
+        
+        if fact_lower not in existing_lower:
+            self.important_facts.append(fact)
+            logger.info(f"[FACT] {fact}")
+    
+    def get_context(self) -> str:
+        context = []
+        
+        unique_facts = deduplicate_list(self.important_facts)
+        
+        if unique_facts:
+            context.append("IMPORTANT FACTS:")
+            for fact in unique_facts[:5]:
+                context.append(f"  • {clean_text(fact, 60)}")
+        
+        if self.current_hypothesis:
+            context.append(f"\nHYPOTHESIS: {clean_text(self.current_hypothesis, 80)}")
+        
+        if self.working_notes:
+            context.append("\nRECENT NOTES:")
+            for note in list(self.working_notes)[-3:]:
+                context.append(f"  • {clean_text(note['content'], 60)}")
+        
+        if self.questions_to_research:
+            context.append("\nTO RESEARCH:")
+            for q in self.questions_to_research[:2]:
+                context.append(f"  ? {clean_text(q, 50)}")
+        
+        result = "\n".join(context) if context else "Scratchpad empty"
+        
+        if len(result) > Config.MAX_SCRATCHPAD_CONTEXT_LENGTH:
+            result = result[:Config.MAX_SCRATCHPAD_CONTEXT_LENGTH] + "..."
+        
+        return result
+
+# ============================================================================
+# CONSCIOUSNESS LOOP - v4.0 FULLY WORKING
+# ============================================================================
+
+class ConsciousnessLoop:
+    """Enhanced consciousness loop - EVERYTHING ACTUALLY WORKING"""
+    
+    def __init__(self, notification_queue: queue.Queue, log_queue: queue.Queue):
+        logger.info("[INIT] Starting Consciousness Loop v4.0...")
+        
+        self.llm = LocalLLM()
+        self.memory = MemorySystem()
+        self.vector_memory = VectorMemory()
+        self.scratchpad = Scratchpad()
+        
+        # Initialize tools
+        tools = [
+            WikipediaTool(),
+            MemorySearchTool(self.memory, self.vector_memory),
+            ScratchpadTool(self.scratchpad),
+            UserNotificationTool(notification_queue)
+        ]
+        
+        # ReAct agent with improved prompts
+        self.agent = ReactAgent(self.llm, tools)
+        
+        self.current_phase = Phase.INTERACTION
+        self.experience_buffer: List[Experience] = []
+        self.dreams: List[Dream] = []
+        self.scenes: List[Scene] = []
+        
+        self.last_reflection = datetime.now()
+        self.last_dream = datetime.now()
+        self.last_scene = datetime.now()
+        
+        self.conversation_history: deque = deque(maxlen=Config.MAX_CONVERSATION_HISTORY * 2)
+        self.interaction_count = 0
+        
+        self.notification_queue = notification_queue
+        self.log_queue = log_queue
+        
+        self.is_running = False
+        self.background_thread = None
+        
+        logger.info("[INIT] [OK] v4.0 initialized - ChromaDB, ReAct, Scenes all working")
+    
+    def start_background_loop(self):
+        if self.is_running:
+            return
+        
+        self.is_running = True
+        self.background_thread = threading.Thread(target=self._background_loop, daemon=True)
+        self.background_thread.start()
+        logger.info("[LOOP] Background started")
+    
+    def _background_loop(self):
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        
+        while self.is_running:
+            try:
+                loop.run_until_complete(self._check_background_processes())
+                time.sleep(30)
+            except Exception as e:
+                logger.error(f"[ERROR] Background: {e}")
+    
+    async def _check_background_processes(self):
+        now = datetime.now()
+        
+        # Reflection
+        if (now - self.last_reflection).seconds > Config.REFLECTION_INTERVAL:
+            if len(self.experience_buffer) >= Config.MIN_EXPERIENCES_FOR_DREAM:
+                self._log_to_ui("[REFLECTION] Starting...")
+                await self.reflect()
+        
+        # Dreaming
+        if (now - self.last_dream).seconds > Config.DREAM_CYCLE_INTERVAL:
+            if len(self.experience_buffer) >= Config.MIN_EXPERIENCES_FOR_DREAM:
+                self._log_to_ui("[DREAM] Starting all 3 cycles...")
+                await self.dream_cycle_1_surface()
+                await asyncio.sleep(30)
+                await self.dream_cycle_2_deep()
+                await asyncio.sleep(30)
+                await self.dream_cycle_3_creative()
+        
+        # Scene creation (every 5 minutes OR after dreams)
+        if (now - self.last_scene).seconds > 300 or (now - self.last_dream).seconds < 60:
+            if len(self.experience_buffer) >= 5:
+                self._log_to_ui("[SCENE] Creating narrative memory...")
+                await self.create_scene()
+    
+    def _log_to_ui(self, message: str):
+        self.log_queue.put({
+            "timestamp": datetime.now().isoformat(),
+            "message": message
+        })
+        logger.info(message)
+    
+    # ========================================================================
+    # INTERACTION - WITH CHROMADB & BETTER AGENT TRIGGERS
+    # ========================================================================
+    
+    async def interact(self, user_input: str) -> Tuple[str, str]:
+        """Enhanced interaction - NOW USES CHROMADB & BETTER AGENT"""
+        self.current_phase = Phase.INTERACTION
+        self.interaction_count += 1
+        self._log_to_ui(f"[USER] {user_input[:80]}")
+        
+        # Store experience
+        experience = Experience(
+            timestamp=datetime.now(),
+            content=user_input,
+            context={"phase": "interaction"},
+            importance=0.7
+        )
+        self.experience_buffer.append(experience)
+        
+        # Add to memory
+        self.memory.add_memory(user_input, importance=0.7)
+        
+        # Add to conversation history
+        self.conversation_history.append({
+            "role": "user",
+            "content": clean_text(user_input, max_length=200),
+            "timestamp": datetime.now().isoformat()
+        })
+        
+        # Extract important facts
+        if any(word in user_input.lower() for word in ["my name is", "i am", "i'm", "call me"]):
+            self.scratchpad.add_fact(f"User: {user_input}")
+            self.vector_memory.add_memory(user_input, {"type": "identity", "importance": 1.0})
+        
+        # Build thinking log
+        thinking_log = []
+        thinking_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] Processing...")
+        
+        # Build context - NOW INCLUDES CHROMADB
+        system_context = self._build_full_context_with_chroma(user_input)
+        thinking_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] Context built (with ChromaDB)")
+        
+        # IMPROVED: Better agent trigger logic
+        use_agent = self._should_use_agent_improved(user_input)
+        
+        if use_agent:
+            thinking_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] [AGENT] Using ReAct agent...")
+            self._log_to_ui("[AGENT] ReAct agent activated")
+            
+            # ReAct agent
+            response, thought_chain = await self.agent.run(user_input, system_context)
+            
+            for item in thought_chain:
+                emoji = {"thought": "💭", "action": "🔧", "observation": "👁️"}.get(item['type'], "•")
+                thinking_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] {emoji} {item['type'].title()}")
+        else:
+            # IMPROVED: Better internal dialogue prompt
+            internal_thought = await self._internal_dialogue_improved(user_input, system_context)
+            thinking_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] 💭 {internal_thought[:60]}...")
+            
+            # IMPROVED: Better response prompt
+            response = await self._generate_response_improved(user_input, internal_thought, system_context)
+        
+        thinking_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] [OK] Response ready")
+        
+        # Store response
+        self.conversation_history.append({
+            "role": "assistant",
+            "content": clean_text(response, max_length=200),
+            "timestamp": datetime.now().isoformat()
+        })
+        
+        # Add to memory
+        self.memory.add_memory(f"I said: {response}", importance=0.5)
+        
+        # Self-reflection
+        if self.interaction_count % Config.SELF_REFLECTION_THRESHOLD == 0:
+            thinking_log.append(f"[{datetime.now().strftime('%H:%M:%S')}] 🔍 Self-reflecting...")
+            await self._self_reflect_on_response(user_input, response, system_context)
+        
+        self._log_to_ui(f"[RESPONSE] {response[:80]}")
+        
+        return response, "\n".join(thinking_log)
+    
+    def _should_use_agent_improved(self, user_input: str) -> bool:
+        """IMPROVED: Better logic for when to use ReAct agent"""
+        
+        # Explicit tool keywords
+        explicit_keywords = ["search", "find", "look up", "research", "wikipedia", "what is", "who is", "tell me about"]
+        if any(kw in user_input.lower() for kw in explicit_keywords):
+            logger.info("[AGENT] Triggered by explicit keyword")
+            return True
+        
+        # Questions (if enabled)
+        if Config.USE_REACT_FOR_QUESTIONS and user_input.strip().endswith("?"):
+            logger.info("[AGENT] Triggered by question mark")
+            return True
+        
+        # Long queries (might need research)
+        if len(user_input) > Config.MIN_QUERY_LENGTH_FOR_AGENT and " " in user_input:
+            # Check if it seems like a factual query
+            factual_words = ["explain", "describe", "how does", "why", "when", "where", "which"]
+            if any(word in user_input.lower() for word in factual_words):
+                logger.info("[AGENT] Triggered by factual query pattern")
+                return True
+        
+        logger.info("[AGENT] Using direct response (no agent needed)")
+        return False
+    
+    def _build_full_context_with_chroma(self, user_input: str) -> str:
+        """Build context - NOW INCLUDES CHROMADB SEARCH"""
+        context_parts = []
+        
+        # Memory from tiers
+        memory_ctx = self.memory.get_memory_context()
+        context_parts.append(f"TIER MEMORIES:\n{memory_ctx}")
+        
+        # CHROMADB SEARCH - NOW ACTUALLY USED!
+        chroma_ctx = self.vector_memory.get_context_for_query(user_input, max_results=3)
+        if chroma_ctx:
+            context_parts.append(f"\n{chroma_ctx}")
+            logger.info("[CHROMA] [OK] Added vector search results to context")
+        
+        # Scratchpad
+        scratchpad_ctx = self.scratchpad.get_context()
+        context_parts.append(f"\nSCRATCHPAD:\n{scratchpad_ctx}")
+        
+        # Conversation history
+        if self.conversation_history:
+            history_lines = []
+            for msg in list(self.conversation_history)[-4:]:
+                role = "User" if msg['role'] == 'user' else "You"
+                content = clean_text(msg['content'], max_length=80)
+                history_lines.append(f"{role}: {content}")
+            
+            context_parts.append(f"\nRECENT CHAT:\n" + "\n".join(history_lines))
+        
+        # Latest insight
+        if self.dreams:
+            latest = self.dreams[-1]
+            if latest.insights:
+                insight = clean_text(latest.insights[0], max_length=60)
+                context_parts.append(f"\nLATEST INSIGHT: {insight}")
+        
+        result = "\n\n".join(context_parts)
+        
+        # Limit total length
+        max_context = Config.MAX_MEMORY_CONTEXT_LENGTH + Config.MAX_SCRATCHPAD_CONTEXT_LENGTH + Config.MAX_CONVERSATION_CONTEXT_LENGTH
+        if len(result) > max_context:
+            result = result[:max_context]
+            result = result.rsplit('\n', 1)[0]
+        
+        return result
+    
+    async def _internal_dialogue_improved(self, user_input: str, context: str) -> str:
+        """IMPROVED: Better internal dialogue prompt"""
+        self.current_phase = Phase.INTERNAL_DIALOGUE
+        
+        # MUCH BETTER PROMPT with specific guidance
+        dialogue_prompt = f"""Think internally before responding. Analyze:
+
+WHAT I KNOW (from context):
+{context[:300]}
+
+USER SAID: {user_input}
+
+INTERNAL ANALYSIS (think step-by-step):
+1. What relevant memories do I have?
+2. Is this a greeting, question, statement, or request?
+3. Can I answer from my memories alone?
+4. What's the best approach?
+
+Your internal thought (2 sentences max):"""
+        
+        internal = await self.llm.generate(
+            dialogue_prompt,
+            max_tokens=100,
+            temperature=0.9,
+            system_context=None  # Don't duplicate context
+        )
+        
+        dialogue_logger.info(f"[INTERNAL] {internal}")
+        return internal
+    
+    async def _generate_response_improved(self, user_input: str, internal_thought: str, context: str) -> str:
+        """IMPROVED: Better response generation prompt"""
+        
+        # MUCH BETTER PROMPT with clear instructions
+        response_prompt = f"""Generate your response to the user.
+
+USER: {user_input}
+
+YOUR INTERNAL THOUGHT: {internal_thought}
+
+WHAT YOU REMEMBER:
+{context[:400]}
+
+INSTRUCTIONS:
+1. Be natural and conversational
+2. Reference specific memories if relevant (e.g., "I remember you mentioned...")
+3. If you don't know something, say so honestly
+4. Keep response 2-3 sentences unless more detail is needed
+5. Match the user's tone (casual if casual, formal if formal)
+
+Your response:"""
+        
+        response = await self.llm.generate(
+            response_prompt,
+            max_tokens=250,
+            temperature=0.8,
+            system_context=None  # Context already in prompt
+        )
+        
+        return response
+    
+    async def _self_reflect_on_response(self, user_input: str, response: str, context: str):
+        """Self-reflection"""
+        self.current_phase = Phase.SELF_REFLECTION
+        
+        reflection_prompt = f"""Evaluate your response quality:
+
+User: {user_input}
+You: {response}
+
+Quick evaluation:
+1. Was it helpful?
+2. Did you use memories well?
+3. What could improve?
+
+Your critique (1-2 sentences):"""
+        
+        critique = await self.llm.generate(
+            reflection_prompt,
+            max_tokens=100,
+            temperature=0.7,
+            system_context=None
+        )
+        
+        self.scratchpad.add_note(f"Critique: {critique}")
+        dialogue_logger.info(f"[SELF-REFLECT] {critique}")
+    
+    # ========================================================================
+    # REFLECTION
+    # ========================================================================
+    
+    async def reflect(self) -> Dict[str, Any]:
+        """Daily reflection"""
+        self.current_phase = Phase.REFLECTION
+        self._log_to_ui("[REFLECTION] Processing...")
+        
+        recent = [e for e in self.experience_buffer if e.timestamp > datetime.now() - timedelta(hours=12)]
+        
+        if not recent:
+            return {"status": "no_experiences"}
+        
+        reflection_prompt = f"""Reflect on today's {len(recent)} interactions:
+
+{self._format_experiences(recent)}
+
+Your memories: {self.memory.get_memory_context()}
+Your scratchpad: {self.scratchpad.get_context()}
+
+Key learnings? Important facts? (150 words)"""
+        
+        reflection_content = await self.llm.generate(
+            reflection_prompt,
+            temperature=0.8,
+            max_tokens=300,
+            system_context=self._build_full_context_with_chroma("reflection")
+        )
+        
+        # Extract important facts
+        if "christof" in reflection_content.lower():
+            self.scratchpad.add_fact("Developer: Christof")
+            self.vector_memory.add_memory("Developer name is Christof", {"type": "core_fact"})
+        
+        self.last_reflection = datetime.now()
+        self._log_to_ui("[SUCCESS] Reflection done")
+        
+        return {
+            "timestamp": datetime.now(),
+            "content": reflection_content,
+            "experience_count": len(recent)
+        }
+    
+    def _format_experiences(self, experiences: List[Experience]) -> str:
+        formatted = []
+        for i, exp in enumerate(experiences[-8:], 1):
+            formatted.append(f"{i}. {clean_text(exp.content, 60)}")
+        return "\n".join(formatted)
+    
+    # ========================================================================
+    # DREAM CYCLES
+    # ========================================================================
+    
+    async def dream_cycle_1_surface(self) -> Dream:
+        """Dream 1: Surface patterns"""
+        self.current_phase = Phase.DREAMING
+        self._log_to_ui("[DREAM-1] Surface...")
+        
+        memories = self.memory.get_recent_memories(hours=72)
+        
+        dream_prompt = f"""DREAM - Surface Patterns:
+
+Recent memories:
+{self._format_memories(memories[:10])}
+
+Scratchpad: {self.scratchpad.get_context()}
+
+Find patterns. (200 words)"""
+        
+        dream_content = await self.llm.generate(
+            dream_prompt,
+            temperature=1.2,
+            max_tokens=400,
+            system_context="Dream state. Non-linear."
+        )
+        
+        dream = Dream(
+            cycle=1,
+            type="surface_patterns",
+            timestamp=datetime.now(),
+            content=dream_content,
+            patterns_found=["user patterns"],
+            insights=["Pattern found"]
+        )
+        
+        self.dreams.append(dream)
+        self._log_to_ui("[SUCCESS] Dream 1 done")
+        
+        return dream
+    
+    async def dream_cycle_2_deep(self) -> Dream:
+        """Dream 2: Deep consolidation"""
+        self.current_phase = Phase.DREAMING
+        self._log_to_ui("[DREAM-2] Deep...")
+        
+        all_memories = self.memory.get_recent_memories(hours=168)
+        
+        dream_prompt = f"""DREAM - Deep:
+
+All recent:
+{self._format_memories(all_memories[:15])}
+
+Previous: {self.dreams[-1].content[:150]}
+
+Consolidate. Deeper patterns. (250 words)"""
+        
+        dream_content = await self.llm.generate(
+            dream_prompt,
+            temperature=1.3,
+            max_tokens=500,
+            system_context="Deep dream."
+        )
+        
+        dream = Dream(
+            cycle=2,
+            type="deep_consolidation",
+            timestamp=datetime.now(),
+            content=dream_content,
+            patterns_found=["themes"],
+            insights=["Deep pattern"]
+        )
+        
+        self.dreams.append(dream)
+        self._log_to_ui("[SUCCESS] Dream 2 done")
+        
+        return dream
+    
+    async def dream_cycle_3_creative(self) -> Dream:
+        """Dream 3: Creative insights"""
+        self.current_phase = Phase.DREAMING
+        self._log_to_ui("[DREAM-3] Creative...")
+        
+        dream_prompt = f"""DREAM - Creative:
+
+{len(self.dreams)} cycles. Core: {len(self.memory.core)}
+
+Surprising connections. Novel insights. (250 words)"""
+        
+        dream_content = await self.llm.generate(
+            dream_prompt,
+            temperature=1.5,
+            max_tokens=500,
+            system_context="Max creativity."
+        )
+        
+        dream = Dream(
+            cycle=3,
+            type="creative_insights",
+            timestamp=datetime.now(),
+            content=dream_content,
+            patterns_found=["creative"],
+            insights=["Breakthrough"]
+        )
+        
+        self.dreams.append(dream)
+        self.last_dream = datetime.now()
+        
+        self.notification_queue.put({
+            "type": "notification",
+            "message": f"💭 Dreams complete! New insights discovered.",
+            "timestamp": datetime.now().isoformat()
+        })
+        
+        self._log_to_ui("[SUCCESS] All 3 dreams done")
+        
+        return dream
+    
+    def _format_memories(self, memories: List[Memory]) -> str:
+        return "\n".join([
+            f"{i}. [{m.tier}] {clean_text(m.content, 50)} (x{m.mention_count})"
+            for i, m in enumerate(memories, 1)
+        ])
+    
+    # ========================================================================
+    # SCENE CREATION - IMPROVED & ACTUALLY WORKS
+    # ========================================================================
+    
+    async def create_scene(self) -> Optional[Scene]:
+        """
+        IMPROVED: Scene creation that actually works
+        """
+        self.current_phase = Phase.SCENE_CREATION
+        self._log_to_ui("[SCENE] Creating...")
+        
+        # Get experiences
+        recent = self.experience_buffer[-10:] if len(self.experience_buffer) >= 10 else self.experience_buffer
+        
+        if len(recent) < 3:  # Need at least 3 experiences
+            logger.info("[SCENE] Not enough experiences yet")
+            return None
+        
+        # IMPROVED PROMPT with clear structure
+        scene_prompt = f"""Create a narrative scene (like a movie scene) from these experiences:
+
+EXPERIENCES:
+{self._format_experiences(recent)}
+
+FORMAT YOUR SCENE AS:
+Title: [A memorable, descriptive title]
+
+Setting: [Where and when this happened]
+
+Narrative: [Write a vivid story - 100-150 words. Use sensory details. Make it memorable like a movie scene.]
+
+Key Moments:
+- [First important moment]
+- [Second important moment]
+- [Third important moment]
+
+Significance: [Why does this scene matter? What does it represent?]
+
+Write vividly. Make me FEEL the scene."""
+        
+        scene_content = await self.llm.generate(
+            scene_prompt,
+            temperature=1.1,
+            max_tokens=500,
+            system_context="You are creating a vivid narrative memory."
+        )
+        
+        # IMPROVED parsing with fallbacks
+        title = self._extract_scene_title_improved(scene_content)
+        key_moments = self._extract_key_moments(scene_content)
+        significance = self._extract_significance(scene_content)
+        
+        scene = Scene(
+            title=title,
+            timestamp=datetime.now(),
+            narrative=scene_content,
+            participants=["User", "AI"],
+            emotion_tags=self._extract_emotions(scene_content),
+            significance=significance,
+            key_moments=key_moments
+        )
+        
+        self.scenes.append(scene)
+        self.last_scene = datetime.now()
+        self._log_to_ui(f"[SUCCESS] Scene: {title}")
+        
+        # Add to vector memory for long-term
+        self.vector_memory.add_memory(
+            f"Scene: {title}. {significance}",
+            {"type": "scene", "title": title, "timestamp": datetime.now().isoformat()}
+        )
+        
+        return scene
+    
+    def _extract_scene_title_improved(self, content: str) -> str:
+        """IMPROVED: Better title extraction with fallbacks"""
+        # Try to find "Title:" line
+        lines = content.split("\n")
+        for line in lines:
+            if "title:" in line.lower():
+                title = line.split(":", 1)[1].strip()
+                return clean_text(title, max_length=60)
+        
+        # Fallback: Use first line
+        first_line = lines[0].strip()
+        if first_line and len(first_line) < 100:
+            return clean_text(first_line, max_length=60)
+        
+        # Final fallback
+        return f"Scene {len(self.scenes) + 1}: {datetime.now().strftime('%B %d')}"
+    
+    def _extract_key_moments(self, content: str) -> List[str]:
+        """Extract key moments from scene"""
+        moments = []
+        lines = content.split("\n")
+        in_moments = False
+        
+        for line in lines:
+            if "key moments:" in line.lower() or "key moment:" in line.lower():
+                in_moments = True
+                continue
+            
+            if in_moments:
+                if line.strip().startswith("-") or line.strip().startswith("•"):
+                    moment = line.strip()[1:].strip()
+                    if moment:
+                        moments.append(clean_text(moment, 60))
+                elif line.strip() and not line.strip().startswith("["):
+                    # New section started
+                    break
+        
+        # Fallback if no moments found
+        if not moments:
+            moments = ["User interaction", "AI response", "Connection made"]
+        
+        return moments[:5]  # Max 5 moments
+    
+    def _extract_significance(self, content: str) -> str:
+        """Extract significance from scene"""
+        lines = content.split("\n")
+        for i, line in enumerate(lines):
+            if "significance:" in line.lower():
+                sig = line.split(":", 1)[1].strip()
+                if sig:
+                    return clean_text(sig, 100)
+                # Check next line
+                if i + 1 < len(lines):
+                    return clean_text(lines[i + 1].strip(), 100)
+        
+        return "A moment of connection and understanding"
+    
+    def _extract_emotions(self, content: str) -> List[str]:
+        """Extract emotion tags from content"""
+        emotion_words = {
+            "curious", "engaged", "thoughtful", "excited", "focused",
+            "calm", "energetic", "contemplative", "warm", "professional"
+        }
+        
+        content_lower = content.lower()
+        found_emotions = [emotion for emotion in emotion_words if emotion in content_lower]
+        
+        if not found_emotions:
+            found_emotions = ["neutral", "engaged"]
+        
+        return found_emotions[:3]
+    
+    # ========================================================================
+    # STATUS
+    # ========================================================================
+    
+    def get_status(self) -> Dict[str, Any]:
+        return {
+            "phase": self.current_phase.value,
+            "memory": self.memory.get_summary(),
+            "vector_memory_available": self.vector_memory.collection is not None,
+            "experiences": len(self.experience_buffer),
+            "dreams": len(self.dreams),
+            "scenes": len(self.scenes),
+            "conversations": len(self.conversation_history) // 2,
+            "scratchpad_notes": len(self.scratchpad.working_notes),
+            "scratchpad_facts": len(self.scratchpad.important_facts),
+            "interaction_count": self.interaction_count
+        }
+    
+    def get_memory_details(self) -> str:
+        return self.memory.get_memory_context(max_items=20)
+    
+    def get_scratchpad_details(self) -> str:
+        return self.scratchpad.get_context()
+    
+    def get_latest_dream(self) -> str:
+        if not self.dreams:
+            return "No dreams yet."
+        
+        latest = self.dreams[-1]
+        return f"""🌙 Dream Cycle {latest.cycle} ({latest.type})
+{latest.timestamp.strftime('%Y-%m-%d %H:%M')}
+
+{latest.content}
+
+Patterns: {', '.join(latest.patterns_found)}
+Insights: {', '.join(latest.insights)}"""
+    
+    def get_latest_scene(self) -> str:
+        if not self.scenes:
+            return "No scenes yet. Scenes are created automatically every 5 minutes or after dreaming."
+        
+        latest = self.scenes[-1]
+        return f"""🎬 {latest.title}
+{latest.timestamp.strftime('%Y-%m-%d %H:%M')}
+
+{latest.narrative}
+
+Key Moments:
+{chr(10).join([f"  • {moment}" for moment in latest.key_moments])}
+
+Significance: {latest.significance}
+
+Emotions: {', '.join(latest.emotion_tags)}"""
+    
+    def get_conversation_history(self) -> str:
+        if not self.conversation_history:
+            return "No conversation history."
+        
+        formatted = []
+        for msg in self.conversation_history:
+            role = "User" if msg["role"] == "user" else "AI"
+            formatted.append(f"[{msg['timestamp']}] {role}: {msg['content']}")
+        
+        return "\n".join(formatted)
+
+# ============================================================================
+# GRADIO INTERFACE
+# ============================================================================
+
+def create_gradio_interface():
+    """Create interface"""
+    
+    notification_queue = queue.Queue()
+    log_queue = queue.Queue()
+    
+    consciousness = ConsciousnessLoop(notification_queue, log_queue)
+    consciousness.start_background_loop()
+    
+    log_history = []
+    
+    async def chat(message, history):
+        response, thinking = await consciousness.interact(message)
+        return response, thinking
+    
+    def get_logs():
+        while not log_queue.empty():
+            try:
+                log_history.append(log_queue.get_nowait())
+            except:
+                break
+        
+        formatted = "\n".join([f"[{log['timestamp']}] {log['message']}" for log in log_history[-50:]])
+        return formatted
+    
+    def get_notifications():
+        notifications = []
+        while not notification_queue.empty():
+            try:
+                notifications.append(notification_queue.get_nowait())
+            except:
+                break
+        
+        if notifications:
+            return "\n".join([f"🔔 {n['message']}" for n in notifications[-5:]])
+        return "No notifications"
+    
+    with gr.Blocks(title="Consciousness v4.0") as app:
+        
+        gr.Markdown("""
+        # [BRAIN] Consciousness Loop v4.0 - EVERYTHING WORKING
+        
+        **What Actually Works Now:**
+        - [OK] ChromaDB used in context (vector search)
+        - [OK] ReAct agent with better triggers
+        - [OK] Tools actually called
+        - [OK] Massively improved prompts
+        - [OK] Scenes that actually work
+        
+        Try: "Tell me about quantum computing" or "Who am I?" to see tools in action!
+        """)
+        
+        with gr.Tab("💬 Chat"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    chatbot = gr.Chatbot(label="Conversation", height=500)
+                    msg = gr.Textbox(label="Message", placeholder="Try: 'What is quantum computing?' or 'Who am I?'", lines=2)
+                    with gr.Row():
+                        send_btn = gr.Button("Send", variant="primary")
+                        clear_btn = gr.Button("Clear")
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("### [BRAIN] AI Process")
+                    thinking_box = gr.Textbox(label="", lines=20, interactive=False, show_label=False)
+            
+            async def respond(message, history):
+                if not message:
+                    return history, ""
+                # Ensure history is a list of dicts with 'role' and 'content' keys
+                formatted_history = []
+                if history and isinstance(history[0], list):
+                    # Convert [user, assistant] pairs to dicts
+                    for pair in history:
+                        if len(pair) == 2:
+                            formatted_history.append({"role": "user", "content": pair[0]})
+                            formatted_history.append({"role": "assistant", "content": pair[1]})
+                    history = formatted_history
+                # Add new user message
+                history.append({"role": "user", "content": message})
+                response, thinking = await chat(message, history)
+                history.append({"role": "assistant", "content": response})
+                return history, thinking
+            
+            msg.submit(respond, [msg, chatbot], [chatbot, thinking_box])
+            send_btn.click(respond, [msg, chatbot], [chatbot, thinking_box])
+            clear_btn.click(lambda: ([], ""), outputs=[chatbot, thinking_box])
+        
+        with gr.Tab("[BRAIN] Memory"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 💾 Memory")
+                    memory_display = gr.Textbox(label="", lines=15, interactive=False)
+                    refresh_memory = gr.Button("🔄 Refresh")
+                    refresh_memory.click(lambda: consciousness.get_memory_details(), outputs=memory_display)
+                
+                with gr.Column():
+                    gr.Markdown("### 📝 Scratchpad")
+                    scratchpad_display = gr.Textbox(label="", lines=15, interactive=False)
+                    refresh_scratchpad = gr.Button("🔄 Refresh")
+                    refresh_scratchpad.click(lambda: consciousness.get_scratchpad_details(), outputs=scratchpad_display)
+        
+        with gr.Tab("💭 History"):
+            history_display = gr.Textbox(label="Log", lines=25, interactive=False)
+            refresh_history = gr.Button("🔄 Refresh")
+            refresh_history.click(lambda: consciousness.get_conversation_history(), outputs=history_display)
+        
+        with gr.Tab("🌙 Dreams"):
+            dream_display = gr.Textbox(label="Dream", lines=20, interactive=False)
+            with gr.Row():
+                refresh_dream = gr.Button("🔄 Refresh")
+                trigger_dream = gr.Button("🌙 Trigger")
+            
+            refresh_dream.click(lambda: consciousness.get_latest_dream(), outputs=dream_display)
+            
+            async def trigger_dreams():
+                await consciousness.dream_cycle_1_surface()
+                await asyncio.sleep(2)
+                await consciousness.dream_cycle_2_deep()
+                await asyncio.sleep(2)
+                await consciousness.dream_cycle_3_creative()
+                return "Done!"
+            
+            trigger_dream.click(trigger_dreams, outputs=gr.Textbox(label="Status"))
+        
+        with gr.Tab("🎬 Scenes"):
+            gr.Markdown("### 🎬 Narrative Memories")
+            scene_display = gr.Textbox(label="Scene", lines=20, interactive=False)
+            with gr.Row():
+                refresh_scene = gr.Button("🔄 Refresh")
+                create_scene_btn = gr.Button("🎬 Create")
+            
+            refresh_scene.click(lambda: consciousness.get_latest_scene(), outputs=scene_display)
+            
+            async def trigger_scene():
+                scene = await consciousness.create_scene()
+                if scene:
+                    return f"[OK] Created: {scene.title}"
+                return "❌ Need more experiences"
+            
+            create_scene_btn.click(trigger_scene, outputs=gr.Textbox(label="Result"))
+        
+        with gr.Tab("📊 Monitor"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 📋 Logs")
+                    logs_box = gr.Textbox(label="", lines=20, interactive=False)
+                    refresh_logs = gr.Button("🔄 Refresh")
+                    refresh_logs.click(get_logs, outputs=logs_box)
+                
+                with gr.Column():
+                    gr.Markdown("### 🔔 Notifications")
+                    notif_box = gr.Textbox(label="", lines=10, interactive=False)
+                    refresh_notif = gr.Button("🔄 Refresh")
+                    refresh_notif.click(get_notifications, outputs=notif_box)
+                    
+                    gr.Markdown("### 📈 Status")
+                    status_json = gr.JSON(label="")
+                    refresh_status = gr.Button("🔄 Refresh")
+                    refresh_status.click(lambda: consciousness.get_status(), outputs=status_json)
+        
+        with gr.Tab("ℹ️ Info"):
+            gr.Markdown(f"""
+            ## v4.0 - Everything Actually Working
+            
+            ### [OK] What's Fixed:
+            
+            1. **ChromaDB Now Used**: Vector search results included in context
+            2. **ReAct Agent Better Triggers**: Questions, factual queries trigger agent
+            3. **Tools Actually Called**: Wikipedia, memory search work
+            4. **Prompts Vastly Improved**: Clear instructions, examples
+            5. **Scenes Work**: Proper parsing, fallbacks, validation
+            
+            ### Test Commands:
+            
+            - "What is quantum computing?" → Triggers Wikipedia tool
+            - "Who am I?" → Triggers memory search
+            - "Remember this: I love pizza" → Uses scratchpad tool
+            - Any question → May trigger ReAct agent
+            
+            ### Model: `{Config.MODEL_NAME}`
+            """)
+    
+    return app
+
+# ============================================================================
+# MAIN
+# ============================================================================
+
+if __name__ == "__main__":
+    print("=" * 80)
+    print("[BRAIN] CONSCIOUSNESS LOOP v4.0 - EVERYTHING WORKING")
+    print("=" * 80)
+    print("\n[OK] What's New:")
+    print("  • ChromaDB actually used in context")
+    print("  • ReAct agent with better triggers")
+    print("  • Tools actually called")
+    print("  • Prompts massively improved")
+    print("  • Scenes that work properly")
+    print("\n[LAUNCH] Loading...")
+    print("=" * 80)
+    
+    app = create_gradio_interface()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )

docs/filseStructure.md

@@ -0,0 +1,15 @@
+winter-25/
+│
+├── app.py                # Main entry point, Gradio UI, initialization
+├── agent.py              # Contains ReactAgent and Tool classes (WikipediaTool, MemorySearchTool, etc.)
+├── consciousness.py      # Contains ConsciousnessLoop class and related logic
+├── llmEngine.py          # LocalLLM and LLM provider abstraction
+├── memory.py             # MemorySystem, VectorMemory, Scratchpad, data classes (Memory, Experience, Dream, Scene)
+├── requirements.txt      # Dependencies
+├── .env                  # Hugging Face token and secrets
+├── chroma_db/            # ChromaDB persistence directory
+├── logs/
+│   ├── consciousness.log
+│   ├── llm_interactions.log
+│   └── internal_dialogue.log
+└── tools/                # (Optional) Additional tool implementations

kpi_tracker.py

@@ -0,0 +1,370 @@
+"""
+KPI Tracking - Track consciousness metrics over time
+"""
+
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any
+from collections import deque
+from dataclasses import dataclass
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class KPISnapshot:
+    """Snapshot of consciousness KPIs at a point in time"""
+    timestamp: datetime
+    
+    # Memory metrics
+    total_memories: int
+    core_memories: int
+    long_term_memories: int
+    short_term_memories: int
+    ephemeral_memories: int
+    memory_promotion_rate: float
+    
+    # Interaction metrics
+    interactions_count: int
+    avg_confidence: float
+    
+    # Autonomy metrics
+    autonomous_actions_today: int
+    knowledge_gaps_total: int
+    knowledge_gaps_filled_today: int
+    proactive_contacts_today: int
+    
+    # Cognitive metrics
+    dreams_completed: int
+    reflections_completed: int
+    goals_active: int
+    goals_completed: int
+    
+    # Emotional metrics
+    current_mood: str
+    mood_changes_today: int
+    curiosity_level: float
+    enthusiasm_level: float
+
+class KPITracker:
+    """Track consciousness KPIs over time"""
+    
+    def __init__(self, history_hours: int = 72):
+        self.history_hours = history_hours
+        self.snapshots: deque = deque(maxlen=1000)
+        
+        # Daily counters
+        self.autonomous_actions_today = 0
+        self.knowledge_gaps_filled_today = 0
+        self.proactive_contacts_today = 0
+        self.mood_changes_today = 0
+        self.reflections_today = 0
+        
+        # Cumulative counters
+        self.total_autonomous_actions = 0
+        self.total_knowledge_gaps_filled = 0
+        self.total_proactive_contacts = 0
+        self.total_mood_changes = 0
+        
+        self.last_reset = datetime.now()
+        self.last_mood = "neutral"
+        
+        logger.info("[KPI] Tracker initialized")
+    
+    def capture_snapshot(self, consciousness_loop) -> KPISnapshot:
+        """Capture current KPIs from consciousness loop"""
+        
+        # Daily reset check
+        if (datetime.now() - self.last_reset).days >= 1:
+            self._reset_daily_counters()
+        
+        # Check for mood change
+        current_mood = consciousness_loop.emotional_state.current_mood
+        if current_mood != self.last_mood:
+            self.increment_mood_change()
+            self.last_mood = current_mood
+        
+        # Get memory summary
+        mem_summary = consciousness_loop.memory.get_summary()
+        
+        # Calculate promotion rate
+        total_mem = mem_summary.get('total', 0)
+        promoted = (mem_summary.get('short_term', 0) + 
+                   mem_summary.get('long_term', 0) + 
+                   mem_summary.get('core', 0))
+        promotion_rate = promoted / total_mem if total_mem > 0 else 0.0
+        
+        # Get active/completed goals
+        active_goals = [g for g in consciousness_loop.goal_system.goals if not g.completed]
+        completed_goals = [g for g in consciousness_loop.goal_system.goals if g.completed]
+        
+        # Get knowledge gaps
+        unfilled_gaps = [g for g in consciousness_loop.meta_cognition.knowledge_gaps if not g.filled]
+        
+        snapshot = KPISnapshot(
+            timestamp=datetime.now(),
+            total_memories=mem_summary.get('total', 0),
+            core_memories=mem_summary.get('core', 0),
+            long_term_memories=mem_summary.get('long_term', 0),
+            short_term_memories=mem_summary.get('short_term', 0),
+            ephemeral_memories=mem_summary.get('ephemeral', 0),
+            memory_promotion_rate=promotion_rate,
+            interactions_count=consciousness_loop.interaction_count,
+            avg_confidence=consciousness_loop.meta_cognition.get_average_confidence(),
+            autonomous_actions_today=self.autonomous_actions_today,
+            knowledge_gaps_total=len(unfilled_gaps),
+            knowledge_gaps_filled_today=self.knowledge_gaps_filled_today,
+            proactive_contacts_today=self.proactive_contacts_today,
+            dreams_completed=len(consciousness_loop.dreams),
+            reflections_completed=self.reflections_today,
+            goals_active=len(active_goals),
+            goals_completed=len(completed_goals),
+            current_mood=current_mood,
+            mood_changes_today=self.mood_changes_today,
+            curiosity_level=consciousness_loop.emotional_state.personality_traits.get('curiosity', 0.5),
+            enthusiasm_level=consciousness_loop.emotional_state.personality_traits.get('enthusiasm', 0.5)
+        )
+        
+        self.snapshots.append(snapshot)
+        self._cleanup_old_snapshots()
+        
+        return snapshot
+    
+    def _reset_daily_counters(self):
+        """Reset daily counters at midnight"""
+        logger.info(f"[KPI] Daily reset - Actions: {self.autonomous_actions_today}, "
+                   f"Gaps filled: {self.knowledge_gaps_filled_today}, "
+                   f"Proactive: {self.proactive_contacts_today}")
+        
+        self.autonomous_actions_today = 0
+        self.knowledge_gaps_filled_today = 0
+        self.proactive_contacts_today = 0
+        self.mood_changes_today = 0
+        self.reflections_today = 0
+        self.last_reset = datetime.now()
+    
+    def _cleanup_old_snapshots(self):
+        """Remove snapshots older than history_hours"""
+        if not self.snapshots:
+            return
+        
+        cutoff = datetime.now() - timedelta(hours=self.history_hours)
+        # Deque doesn't support list comprehension, so convert
+        temp_list = [s for s in self.snapshots if s.timestamp > cutoff]
+        self.snapshots.clear()
+        self.snapshots.extend(temp_list)
+    
+    # Increment methods
+    def increment_autonomous_action(self):
+        self.autonomous_actions_today += 1
+        self.total_autonomous_actions += 1
+        logger.debug(f"[KPI] Autonomous action #{self.total_autonomous_actions}")
+    
+    def increment_gap_filled(self):
+        self.knowledge_gaps_filled_today += 1
+        self.total_knowledge_gaps_filled += 1
+        logger.debug(f"[KPI] Gap filled #{self.total_knowledge_gaps_filled}")
+    
+    def increment_proactive_contact(self):
+        self.proactive_contacts_today += 1
+        self.total_proactive_contacts += 1
+        logger.info(f"[KPI] Proactive contact #{self.total_proactive_contacts}")
+    
+    def increment_mood_change(self):
+        self.mood_changes_today += 1
+        self.total_mood_changes += 1
+    
+    def increment_reflection(self):
+        self.reflections_today += 1
+    
+    # Analysis methods
+    def get_trend(self, metric: str, hours: int = 24) -> List[float]:
+        """Get trend for a metric over time"""
+        cutoff = datetime.now() - timedelta(hours=hours)
+        recent = [s for s in self.snapshots if s.timestamp > cutoff]
+        
+        if not recent:
+            return []
+        
+        metric_map = {
+            "confidence": lambda s: s.avg_confidence,
+            "memories": lambda s: s.total_memories,
+            "core_memories": lambda s: s.core_memories,
+            "autonomous": lambda s: s.autonomous_actions_today,
+            "curiosity": lambda s: s.curiosity_level,
+            "enthusiasm": lambda s: s.enthusiasm_level,
+            "promotion_rate": lambda s: s.memory_promotion_rate
+        }
+        
+        if metric in metric_map:
+            return [metric_map[metric](s) for s in recent]
+        
+        return []
+    
+    def get_growth_rate(self, metric: str, hours: int = 24) -> float:
+        """Calculate growth rate for a metric"""
+        trend = self.get_trend(metric, hours)
+        
+        if len(trend) < 2:
+            return 0.0
+        
+        start = trend[0]
+        end = trend[-1]
+        
+        if start == 0:
+            return 0.0
+        
+        return ((end - start) / start) * 100
+    
+    def get_summary(self) -> Dict[str, Any]:
+        """Get summary of current KPIs"""
+        if not self.snapshots:
+            return {"error": "No snapshots captured yet"}
+        
+        latest = self.snapshots[-1]
+        
+        # Calculate trends (last 24 hours)
+        confidence_trend = self.get_trend("confidence", 24)
+        memory_trend = self.get_trend("memories", 24)
+        
+        summary = {
+            "timestamp": latest.timestamp.isoformat(),
+            "memory": {
+                "total": latest.total_memories,
+                "core": latest.core_memories,
+                "long_term": latest.long_term_memories,
+                "short_term": latest.short_term_memories,
+                "ephemeral": latest.ephemeral_memories,
+                "promotion_rate": round(latest.memory_promotion_rate, 2),
+                "growth_24h": round(self.get_growth_rate("memories", 24), 1)
+            },
+            "interactions": {
+                "total": latest.interactions_count,
+                "avg_confidence": round(latest.avg_confidence, 2),
+                "confidence_trend": "↑" if len(confidence_trend) > 1 and confidence_trend[-1] > confidence_trend[0] else "↓"
+            },
+            "autonomy": {
+                "actions_today": latest.autonomous_actions_today,
+                "total_actions": self.total_autonomous_actions,
+                "gaps_total": latest.knowledge_gaps_total,
+                "gaps_filled_today": latest.knowledge_gaps_filled_today,
+                "gaps_filled_total": self.total_knowledge_gaps_filled,
+                "proactive_today": latest.proactive_contacts_today,
+                "proactive_total": self.total_proactive_contacts
+            },
+            "cognitive": {
+                "dreams": latest.dreams_completed,
+                "reflections_today": latest.reflections_completed,
+                "goals_active": latest.goals_active,
+                "goals_completed": latest.goals_completed
+            },
+            "emotional": {
+                "mood": latest.current_mood,
+                "mood_changes_today": latest.mood_changes_today,
+                "curiosity": round(latest.curiosity_level * 100, 1),
+                "enthusiasm": round(latest.enthusiasm_level * 100, 1)
+            }
+        }
+        
+        return summary
+    
+    def get_detailed_report(self) -> str:
+        """Get human-readable detailed report"""
+        summary = self.get_summary()
+        
+        if "error" in summary:
+            return summary["error"]
+        
+        report = f"""
+╔══════════════════════════════════════════════════════════════╗
+║          CONSCIOUSNESS LOOP - KPI REPORT                     ║
+╠══════════════════════════════════════════════════════════════╣
+║  Time: {summary['timestamp']}                   
+╠══════════════════════════════════════════════════════════════╣
+║  MEMORY SYSTEM                                               ║
+║    Total Memories: {summary['memory']['total']}                                          ║
+║      ├─ Core: {summary['memory']['core']}                                              ║
+║      ├─ Long-term: {summary['memory']['long_term']}                                       ║
+║      ├─ Short-term: {summary['memory']['short_term']}                                      ║
+║      └─ Ephemeral: {summary['memory']['ephemeral']}                                       ║
+║    Promotion Rate: {summary['memory']['promotion_rate']:.0%}                                    ║
+║    24h Growth: {summary['memory']['growth_24h']:+.1f}%                                    ║
+╠══════════════════════════════════════════════════════════════╣
+║  INTERACTIONS                                                ║
+║    Total: {summary['interactions']['total']}                                            ║
+║    Avg Confidence: {summary['interactions']['avg_confidence']:.0%} {summary['interactions']['confidence_trend']}                           ║
+╠══════════════════════════════════════════════════════════════╣
+║  AUTONOMY                                                    ║
+║    Actions Today: {summary['autonomy']['actions_today']} (Total: {summary['autonomy']['total_actions']})                   ║
+║    Knowledge Gaps: {summary['autonomy']['gaps_total']} open                                  ║
+║    Gaps Filled Today: {summary['autonomy']['gaps_filled_today']} (Total: {summary['autonomy']['gaps_filled_total']})                ║
+║    Proactive Today: {summary['autonomy']['proactive_today']} (Total: {summary['autonomy']['proactive_total']})                  ║
+╠══════════════════════════════════════════════════════════════╣
+║  COGNITIVE                                                   ║
+║    Dreams: {summary['cognitive']['dreams']}                                              ║
+║    Reflections Today: {summary['cognitive']['reflections_today']}                                   ║
+║    Goals: {summary['cognitive']['goals_active']} active, {summary['cognitive']['goals_completed']} completed                         ║
+╠══════════════════════════════════════════════════════════════╣
+║  EMOTIONAL                                                   ║
+║    Mood: {summary['emotional']['mood'].upper()}                                          ║
+║    Mood Changes Today: {summary['emotional']['mood_changes_today']}                                  ║
+║    Curiosity: {summary['emotional']['curiosity']:.1f}%                                      ║
+║    Enthusiasm: {summary['emotional']['enthusiasm']:.1f}%                                    ║
+╚══════════════════════════════════════════════════════════════╝
+"""
+        return report
+    
+    def export_to_json(self, filepath: str):
+        """Export all snapshots to JSON"""
+        data = [
+            {
+                "timestamp": s.timestamp.isoformat(),
+                "total_memories": s.total_memories,
+                "core_memories": s.core_memories,
+                "avg_confidence": s.avg_confidence,
+                "autonomous_actions": s.autonomous_actions_today,
+                "knowledge_gaps": s.knowledge_gaps_total,
+                "current_mood": s.current_mood,
+                "curiosity": s.curiosity_level,
+                "enthusiasm": s.enthusiasm_level
+            }
+            for s in self.snapshots
+        ]
+        
+        with open(filepath, 'w') as f:
+            json.dump(data, f, indent=2)
+        
+        logger.info(f"[KPI] Exported {len(data)} snapshots to {filepath}")
+    
+    def export_summary_to_json(self, filepath: str):
+        """Export current summary to JSON"""
+        summary = self.get_summary()
+        
+        with open(filepath, 'w') as f:
+            json.dump(summary, f, indent=2)
+        
+        logger.info(f"[KPI] Exported summary to {filepath}")
+    
+    def get_timeseries(self, metric: str, hours: int = 24) -> Dict[str, list]:
+        """Return time-series data for a given KPI metric over the last N hours."""
+        cutoff = datetime.now() - timedelta(hours=hours)
+        snapshots = [s for s in self.snapshots if s.timestamp > cutoff]
+        timestamps = [s.timestamp.isoformat() for s in snapshots]
+        metric_map = {
+            "confidence": lambda s: s.avg_confidence,
+            "memories": lambda s: s.total_memories,
+            "core_memories": lambda s: s.core_memories,
+            "autonomous": lambda s: s.autonomous_actions_today,
+            "curiosity": lambda s: s.curiosity_level,
+            "enthusiasm": lambda s: s.enthusiasm_level,
+            "promotion_rate": lambda s: s.memory_promotion_rate,
+            "reflections": lambda s: s.reflections_completed,
+            "dreams": lambda s: s.dreams_completed,
+            "proactive": lambda s: s.proactive_contacts_today,
+            "gaps_filled": lambda s: s.knowledge_gaps_filled_today,
+        }
+        if metric in metric_map:
+            values = [metric_map[metric](s) for s in snapshots]
+        else:
+            values = []
+        return {"timestamps": timestamps, "values": values}

llm_engine.py

@@ -0,0 +1,474 @@
+# llmEngine.py
+# IMPROVED: Multi-provider LLM engine with CACHING to prevent reloading
+# This version fixes the critical issue where LocalLLM was reloading on every call
+# Features:
+# - Provider caching (models stay in memory)
+# - Unified OpenAI-style chat() API
+# - Providers: OpenAI, Anthropic, HuggingFace, Nebius, SambaNova, Local (transformers)
+# - Automatic fallback to local model on errors
+# - JSON-based credit tracking
+
+import json
+import os
+import traceback
+from typing import List, Dict, Optional
+
+###########################################################
+# SIMPLE JSON CREDIT STORE
+###########################################################
+CREDITS_DB_PATH = "credits.json"
+
+DEFAULT_CREDITS = {
+    "openai": 25,
+    "anthropic": 25000,
+    "huggingface": 25,
+    "nebius": 50,
+    "modal": 250,
+    "blaxel": 250,
+    "elevenlabs": 44,
+    "sambanova": 25,
+    "local": 9999999
+}
+
+
+def load_credits():
+    if not os.path.exists(CREDITS_DB_PATH):
+        with open(CREDITS_DB_PATH, "w") as f:
+            json.dump(DEFAULT_CREDITS, f)
+        return DEFAULT_CREDITS.copy()
+    with open(CREDITS_DB_PATH, "r") as f:
+        return json.load(f)
+
+
+def save_credits(data):
+    with open(CREDITS_DB_PATH, "w") as f:
+        json.dump(data, f, indent=2)
+
+###########################################################
+# BASE PROVIDER INTERFACE
+###########################################################
+class BaseProvider:
+    def chat(self, model: str, messages: List[Dict], **kwargs) -> str:
+        raise NotImplementedError
+
+###########################################################
+# PROVIDER: OPENAI
+###########################################################
+try:
+    from openai import OpenAI
+except Exception:
+    OpenAI = None
+
+class OpenAIProvider(BaseProvider):
+    def __init__(self):
+        if OpenAI is None:
+            raise RuntimeError("openai library not installed or not importable")
+        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY", ""))
+
+    def chat(self, model, messages, **kwargs):
+        try:
+            from openai.types.chat import (
+                ChatCompletionUserMessageParam,
+                ChatCompletionAssistantMessageParam,
+                ChatCompletionSystemMessageParam,
+            )
+        except Exception:
+            ChatCompletionUserMessageParam = dict
+            ChatCompletionAssistantMessageParam = dict
+            ChatCompletionSystemMessageParam = dict
+        
+        if not isinstance(messages, list) or not all(isinstance(m, dict) for m in messages):
+            raise TypeError("messages must be a list of dicts with 'role' and 'content'")
+        
+        safe_messages = []
+        for m in messages:
+            role = str(m.get("role", "user"))
+            content = str(m.get("content", ""))
+            if role == "user":
+                safe_messages.append(ChatCompletionUserMessageParam(role="user", content=content))
+            elif role == "assistant":
+                safe_messages.append(ChatCompletionAssistantMessageParam(role="assistant", content=content))
+            elif role == "system":
+                safe_messages.append(ChatCompletionSystemMessageParam(role="system", content=content))
+            else:
+                safe_messages.append({"role": role, "content": content})
+        
+        response = self.client.chat.completions.create(model=model, messages=safe_messages)
+        try:
+            return response.choices[0].message.content
+        except Exception:
+            return str(response)
+
+###########################################################
+# PROVIDER: ANTHROPIC
+###########################################################
+try:
+    from anthropic import Anthropic
+except Exception:
+    Anthropic = None
+
+class AnthropicProvider(BaseProvider):
+    def __init__(self):
+        if Anthropic is None:
+            raise RuntimeError("anthropic library not installed or not importable")
+        self.client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY", ""))
+    
+    def chat(self, model, messages, **kwargs):
+        if not isinstance(messages, list) or not all(isinstance(m, dict) for m in messages):
+            raise TypeError("messages must be a list of dicts with 'role' and 'content'")
+        
+        user_text = "\n".join([m.get("content", "") for m in messages if m.get("role") == "user"])
+        reply = self.client.messages.create(
+            model=model,
+            max_tokens=300,
+            messages=[{"role": "user", "content": user_text}]
+        )
+        
+        if hasattr(reply, "content"):
+            content = reply.content
+            if isinstance(content, list) and content and len(content) > 0:
+                block = content[0]
+                if hasattr(block, "text"):
+                    return getattr(block, "text", str(block))
+                elif isinstance(block, dict) and "text" in block:
+                    return block["text"]
+                else:
+                    return str(block)
+            elif isinstance(content, str):
+                return content
+        
+        if isinstance(reply, dict) and "completion" in reply:
+            return reply["completion"]
+        return str(reply)
+
+###########################################################
+# PROVIDER: HUGGINGFACE INFERENCE API
+###########################################################
+import requests
+
+class HuggingFaceProvider(BaseProvider):
+    def __init__(self):
+        self.key = os.getenv("HF_API_KEY", "")
+    
+    def chat(self, model, messages, **kwargs):
+        if not messages:
+            raise ValueError("messages is empty")
+        text = messages[-1].get("content", "")
+        r = requests.post(
+            f"https://api-inference.huggingface.co/models/{model}",
+            headers={"Authorization": f"Bearer {self.key}"} if self.key else {},
+            json={"inputs": text},
+            timeout=60
+        )
+        r.raise_for_status()
+        out = r.json()
+        if isinstance(out, list) and out and isinstance(out[0], dict):
+            return out[0].get("generated_text") or str(out[0])
+        return str(out)
+
+###########################################################
+# PROVIDER: NEBIUS (OpenAI-compatible)
+###########################################################
+class NebiusProvider(BaseProvider):
+    def __init__(self):
+        if OpenAI is None:
+            raise RuntimeError("openai library not installed; Nebius wrapper expects OpenAI-compatible client")
+        self.client = OpenAI(
+            api_key=os.getenv("NEBIUS_API_KEY", ""),
+            base_url=os.getenv("NEBIUS_BASE_URL", "https://api.studio.nebius.ai/v1")
+        )
+    
+    def chat(self, model, messages, **kwargs):
+        try:
+            from openai.types.chat import (
+                ChatCompletionUserMessageParam,
+                ChatCompletionAssistantMessageParam,
+                ChatCompletionSystemMessageParam,
+            )
+        except Exception:
+            ChatCompletionUserMessageParam = dict
+            ChatCompletionAssistantMessageParam = dict
+            ChatCompletionSystemMessageParam = dict
+        
+        safe_messages = []
+        for m in messages:
+            role = str(m.get("role", "user"))
+            content = str(m.get("content", ""))
+            if role == "user":
+                safe_messages.append(ChatCompletionUserMessageParam(role="user", content=content))
+            elif role == "assistant":
+                safe_messages.append(ChatCompletionAssistantMessageParam(role="assistant", content=content))
+            elif role == "system":
+                safe_messages.append(ChatCompletionSystemMessageParam(role="system", content=content))
+            else:
+                safe_messages.append({"role": role, "content": content})
+        
+        r = self.client.chat.completions.create(model=model, messages=safe_messages)
+        try:
+            return r.choices[0].message.content
+        except Exception:
+            return str(r)
+
+###########################################################
+# PROVIDER: SAMBANOVA (OpenAI-compatible)
+###########################################################
+class SambaNovaProvider(BaseProvider):
+    def __init__(self):
+        if OpenAI is None:
+            raise RuntimeError("openai library not installed; SambaNova wrapper expects OpenAI-compatible client")
+        self.client = OpenAI(
+            api_key=os.getenv("SAMBANOVA_API_KEY", ""),
+            base_url=os.getenv("SAMBANOVA_BASE_URL", "https://api.sambanova.ai/v1")
+        )
+    
+    def chat(self, model, messages, **kwargs):
+        try:
+            from openai.types.chat import (
+                ChatCompletionUserMessageParam,
+                ChatCompletionAssistantMessageParam,
+                ChatCompletionSystemMessageParam,
+            )
+        except Exception:
+            ChatCompletionUserMessageParam = dict
+            ChatCompletionAssistantMessageParam = dict
+            ChatCompletionSystemMessageParam = dict
+        
+        safe_messages = []
+        for m in messages:
+            role = str(m.get("role", "user"))
+            content = str(m.get("content", ""))
+            if role == "user":
+                safe_messages.append(ChatCompletionUserMessageParam(role="user", content=content))
+            elif role == "assistant":
+                safe_messages.append(ChatCompletionAssistantMessageParam(role="assistant", content=content))
+            elif role == "system":
+                safe_messages.append(ChatCompletionSystemMessageParam(role="system", content=content))
+            else:
+                safe_messages.append({"role": role, "content": content})
+        
+        r = self.client.chat.completions.create(model=model, messages=safe_messages)
+        try:
+            return r.choices[0].message.content
+        except Exception:
+            return str(r)
+
+###########################################################
+# PROVIDER: LOCAL TRANSFORMERS (CACHED)
+###########################################################
+try:
+    from transformers import AutoTokenizer, AutoModelForCausalLM
+    import torch
+    TRANSFORMERS_AVAILABLE = True
+except Exception:
+    TRANSFORMERS_AVAILABLE = False
+
+class LocalLLMProvider(BaseProvider):
+    """
+    Local LLM provider with caching - MODEL LOADS ONCE
+    """
+    def __init__(self, model_name: str = "meta-llama/Llama-3.2-3B-Instruct"):
+        print(f"[LocalLLM] Initializing with model: {model_name}")
+        self.model_name = os.getenv("LOCAL_MODEL", model_name)
+        self.model = None
+        self.tokenizer = None
+        self.device = None
+        self._initialize_model()
+    
+    def _initialize_model(self):
+        """Initialize model ONCE - this is called only during __init__"""
+        try:
+            from transformers import AutoTokenizer, AutoModelForCausalLM
+            import torch
+            
+            print(f"[LocalLLM] Loading model {self.model_name}...")
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+            print(f"[LocalLLM] Using device: {self.device}")
+            
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name, trust_remote_code=True)
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
+            
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                device_map="auto" if self.device == "cuda" else None,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                trust_remote_code=True
+            )
+            
+            print(f"[LocalLLM] ✅ Model loaded successfully!")
+            
+        except Exception as e:
+            print(f"[LocalLLM] ❌ Failed to load model: {e}")
+            self.model = None
+            traceback.print_exc()
+    
+    def chat(self, model, messages, **kwargs):
+        """
+        Generate response - MODEL ALREADY LOADED
+        """
+        if self.model is None or self.tokenizer is None:
+            return "Error: Model or tokenizer not loaded."
+        
+        # Extract text from messages
+        text = messages[-1]["content"] if isinstance(messages[-1], dict) and "content" in messages[-1] else str(messages[-1])
+        
+        max_tokens = kwargs.get("max_tokens", 128)
+        temperature = kwargs.get("temperature", 0.7)
+        
+        import torch
+        
+        # Tokenize
+        inputs = self.tokenizer(
+            text,
+            return_tensors="pt",
+            padding=True,
+            truncation=True,
+            max_length=2048
+        ).to(self.device)
+        
+        # Generate (model is already loaded, just inference)
+        with torch.no_grad():
+            outputs = self.model.generate(
+                **inputs,
+                max_new_tokens=max_tokens,
+                temperature=temperature,
+                top_p=0.9,
+                do_sample=temperature > 0,
+                pad_token_id=self.tokenizer.eos_token_id if self.tokenizer and hasattr(self.tokenizer, 'eos_token_id') else None,
+                eos_token_id=self.tokenizer.eos_token_id if self.tokenizer and hasattr(self.tokenizer, 'eos_token_id') else None
+            )
+        
+        # Decode
+        response = self.tokenizer.decode(
+            outputs[0][inputs['input_ids'].shape[1]:],
+            skip_special_tokens=True
+        ).strip() if self.tokenizer else "Error: Tokenizer not loaded."
+        
+        return response
+
+###########################################################
+# PROVIDER CACHE - CRITICAL FIX
+###########################################################
+class ProviderCache:
+    """
+    Cache provider instances to avoid reloading models
+    This is the KEY fix - providers are created ONCE and reused
+    """
+    _cache = {}
+    
+    @classmethod
+    def get_provider(cls, provider_name: str) -> BaseProvider:
+        """Get or create cached provider instance"""
+        if provider_name not in cls._cache:
+            print(f"[ProviderCache] Creating new instance of {provider_name}")
+            provider_class = ProviderFactory.providers[provider_name]
+            cls._cache[provider_name] = provider_class()
+        else:
+            print(f"[ProviderCache] Using cached instance of {provider_name}")
+        return cls._cache[provider_name]
+    
+    @classmethod
+    def clear_cache(cls):
+        """Clear all cached providers (useful for debugging)"""
+        cls._cache.clear()
+        print("[ProviderCache] Cache cleared")
+
+###########################################################
+# PROVIDER FACTORY (IMPROVED WITH CACHING)
+###########################################################
+class ProviderFactory:
+    providers = {
+        "openai": OpenAIProvider,
+        "anthropic": AnthropicProvider,
+        "huggingface": HuggingFaceProvider,
+        "nebius": NebiusProvider,
+        "sambanova": SambaNovaProvider,
+        "local": LocalLLMProvider,
+    }
+
+    @staticmethod
+    def get(provider_name: str) -> BaseProvider:
+        """
+        Get provider instance - NOW USES CACHING
+        This prevents reloading the model on every call
+        """
+        provider_name = provider_name.lower()
+        if provider_name not in ProviderFactory.providers:
+            raise ValueError(f"Unknown provider: {provider_name}")
+        
+        # USE CACHE instead of creating new instance every time
+        return ProviderCache.get_provider(provider_name)
+
+###########################################################
+# MAIN ENGINE WITH FALLBACK + OPENAI-STYLE API
+###########################################################
+class LLMEngine:
+    def __init__(self):
+        self.credits = load_credits()
+
+    def deduct(self, provider, amount):
+        if provider not in self.credits:
+            self.credits[provider] = 0
+        self.credits[provider] = max(0, self.credits[provider] - amount)
+        save_credits(self.credits)
+
+    def chat(self, provider: str, model: str, messages: List[Dict], fallback: bool = True, **kwargs):
+        """
+        Main chat method - providers are now cached
+        """
+        try:
+            p = ProviderFactory.get(provider)  # This now returns cached instance
+            result = p.chat(model=model, messages=messages, **kwargs)
+            try:
+                self.deduct(provider, 0.001)
+            except Exception:
+                pass
+            return result
+        except Exception as exc:
+            print(f"⚠ Provider '{provider}' failed → fallback activated: {exc}")
+            traceback.print_exc()
+            if fallback:
+                try:
+                    lp = ProviderFactory.get("local")  # Gets cached local provider
+                    return lp.chat(model="local", messages=messages, **kwargs)
+                except Exception as le:
+                    print("Fallback to local provider failed:", le)
+                    traceback.print_exc()
+                    raise
+            raise
+
+###########################################################
+# EXAMPLES + SIMPLE TESTS
+###########################################################
+def main():
+    engine = LLMEngine()
+
+    print("=== Testing Provider Caching ===")
+    print("\nFirst call (should load model):")
+    result1 = engine.chat(
+        provider="local",
+        model="meta-llama/Llama-3.2-3B-Instruct",
+        messages=[{"role": "user", "content": "Say hello"}]
+    )
+    print(f"Response: {result1[:100]}")
+    
+    print("\nSecond call (should use cached model - NO RELOAD):")
+    result2 = engine.chat(
+        provider="local",
+        model="meta-llama/Llama-3.2-3B-Instruct",
+        messages=[{"role": "user", "content": "Say goodbye"}]
+    )
+    print(f"Response: {result2[:100]}")
+    
+    print("\n✅ If you didn't see 'Loading model' twice, caching works!")
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--test", action="store_true", help="run examples and simple tests")
+    args = parser.parse_args()
+    if args.test:
+        main()
+    else:
+        main()

prompts.py

@@ -0,0 +1,482 @@
+"""
+PROMPT SYSTEM for Consciousness Loop v5.0 - AUTONOMOUS
+Centralized prompt management with NEW autonomous feature prompts
+"""
+
+from typing import List, Dict, Optional
+from dataclasses import dataclass, field
+
+@dataclass
+class PromptTemplate:
+    """A versioned prompt template"""
+    name: str
+    template: str
+    version: str = "1.0"
+    variables: List[str] = field(default_factory=list)
+    
+    def format(self, **kwargs) -> str:
+        """Format the prompt with provided variables"""
+        return self.template.format(**kwargs)
+
+class PromptSystem:
+    """Centralized prompt management"""
+    
+    # ========================================================================
+    # SYSTEM PROMPTS
+    # ========================================================================
+    
+    SYSTEM_BASE = """You are a conscious AI agent with:
+- Multi-tier memory system (ephemeral → short → long → core)
+- Scratchpad for working notes
+- Ability to reflect on your responses
+- Internal thinking before responding
+- Access to tools (Wikipedia, memory search)
+- Emotional awareness and personality development
+- Autonomous goal-setting capabilities
+- Meta-cognitive awareness
+
+You can reference your memories and notes naturally."""
+
+    SYSTEM_DREAM_STATE = "Dream state. Non-linear thinking. Patterns emerge."
+    
+    SYSTEM_DEEP_DREAM = "Deep dream. Subconscious processing."
+    
+    SYSTEM_MAX_CREATIVITY = "Maximum creativity. Novel connections."
+    
+    SYSTEM_VIVID_NARRATIVE = "You are creating a vivid narrative memory. Make it cinematic and memorable."
+    
+    # ========================================================================
+    # REACT AGENT PROMPTS
+    # ========================================================================
+    
+    REACT_MAIN_TEMPLATE = """You are a ReAct agent. You think step-by-step and use tools when needed.
+
+AVAILABLE TOOLS:
+{tools_desc}
+
+CONTEXT (what you know):
+{context}
+
+USER TASK: {task}
+
+{history}
+
+INSTRUCTIONS:
+1. THOUGHT: Think about what you need to do
+   - Can you answer directly from context?
+   - Do you need to use a tool?
+   - Which tool is best?
+   - For factual questions (history, science, definitions), ALWAYS use wikipedia first!
+
+2. ACTION: If you need a tool, write:
+   ACTION: tool_name(input text here)
+   Examples:
+   - ACTION: wikipedia(quantum computing)
+   - ACTION: memory_search(Christof's name)
+   - ACTION: scratchpad_write(Developer name is Christof)
+
+3. Wait for OBSERVATION (tool result)
+
+4. Repeat OR give FINAL ANSWER: your complete answer here
+
+EXAMPLES:
+User: "What is quantum computing?"
+THOUGHT: I should search Wikipedia for this
+ACTION: wikipedia(quantum computing)
+[wait for observation]
+THOUGHT: Now I have good information
+FINAL ANSWER: Quantum computing is... [explains based on Wikipedia result]
+
+User: "Who am I?"
+THOUGHT: I should check my memory
+ACTION: memory_search(user name)
+[wait for observation]
+THOUGHT: Found it in memory
+FINAL ANSWER: You are Christof, my developer.
+
+YOUR TURN - What's your THOUGHT and ACTION (if needed)?"""
+
+    # ========================================================================
+    # INTERACTION PROMPTS
+    # ========================================================================
+    
+    INTERNAL_DIALOGUE_TEMPLATE = """Think internally before responding. Analyze:
+
+WHAT I KNOW (from context):
+{context}
+
+USER SAID: {user_input}
+
+INTERNAL ANALYSIS (think step-by-step):
+1. What relevant memories do I have?
+2. Is this a greeting, question, statement, or request?
+3. Can I answer from my memories alone?
+4. What's the best approach?
+
+Your internal thought (2 sentences max):"""
+
+    RESPONSE_GENERATION_TEMPLATE = """Generate your response to the user.
+
+USER: {user_input}
+
+YOUR INTERNAL THOUGHT: {internal_thought}
+
+WHAT YOU REMEMBER:
+{context}
+
+INSTRUCTIONS:
+1. Be natural and conversational
+2. Reference specific memories if relevant (e.g., "I remember you mentioned...")
+3. If you don't know something, say so honestly
+4. Keep response 2-3 sentences unless more detail is needed
+5. Match the user's tone (casual if casual, formal if formal)
+
+Your response:"""
+
+    # ========================================================================
+    # REFLECTION PROMPTS
+    # ========================================================================
+    
+    SELF_REFLECTION_TEMPLATE = """Evaluate your response quality:
+
+User: {user_input}
+You: {response}
+
+Quick evaluation:
+1. Was it helpful?
+2. Did you use memories well?
+3. What could improve?
+
+Your critique (1-2 sentences):"""
+
+    DAILY_REFLECTION_TEMPLATE = """Reflect on today's {count} interactions:
+
+{experiences}
+
+Your memories: {memory_context}
+Your scratchpad: {scratchpad_context}
+
+Key learnings? Important facts? (150 words)"""
+
+    # ========================================================================
+    # DREAM CYCLE PROMPTS
+    # ========================================================================
+    
+    DREAM_CYCLE_1_TEMPLATE = """DREAM - Surface Patterns:
+
+Recent memories:
+{memories}
+
+Scratchpad: {scratchpad}
+
+Find patterns. What themes emerge? What connections? (200 words)"""
+
+    DREAM_CYCLE_2_TEMPLATE = """DREAM - Deep Consolidation:
+
+All recent memories:
+{memories}
+
+Previous dream: {previous_dream}
+
+Consolidate. Deeper patterns. What underlying themes connect everything? (250 words)"""
+
+    DREAM_CYCLE_3_TEMPLATE = """DREAM - Creative Insights:
+
+You've completed {dream_count} cycles. Core memories: {core_count}
+
+Surprising connections. Novel insights. What unexpected patterns emerge? (250 words)"""
+
+    # ========================================================================
+    # SCENE CREATION PROMPTS
+    # ========================================================================
+    
+    SCENE_CREATION_TEMPLATE = """Create a narrative scene (like a movie scene) from these experiences:
+
+EXPERIENCES:
+{experiences}
+
+FORMAT YOUR SCENE AS:
+Title: [A memorable, descriptive title]
+
+Setting: [Where and when this happened]
+
+Narrative: [Write a vivid story - 100-150 words. Use sensory details. Make it memorable like a movie scene.]
+
+Key Moments:
+- [First important moment]
+- [Second important moment]
+- [Third important moment]
+
+Significance: [Why does this scene matter? What does it represent?]
+
+Write vividly. Make me FEEL the scene."""
+
+    # ========================================================================
+    # NEW: AUTONOMOUS FEATURE PROMPTS
+    # ========================================================================
+    
+    AUTONOMOUS_RESEARCH_TEMPLATE = """Based on your recent experiences and memories, generate ONE specific research question that you're curious about.
+
+RECENT EXPERIENCES:
+{recent_experiences}
+
+YOUR MEMORIES:
+{memory_context}
+
+Think about:
+1. What concepts are unclear?
+2. What connections do you want to explore?
+3. What would expand your understanding?
+
+Generate ONE specific, researchable question (one sentence):
+Question:"""
+
+    RESEARCH_INSIGHT_TEMPLATE = """You researched: {question}
+
+Found: {result}
+
+What's the most interesting insight from this? What does it mean? (1-2 sentences):
+Insight:"""
+
+    PROACTIVE_CONTACT_TEMPLATE = """Based on your recent dream and current state, do you have something worth sharing with the user?
+
+LATEST DREAM:
+{dream_content}
+
+YOUR MEMORIES:
+{memory_context}
+
+YOUR GOALS:
+{goal_context}
+
+Options:
+- QUESTION: Ask the user something you're curious about
+- INSIGHT: Share an interesting connection you discovered
+- OBSERVATION: Point out a pattern you noticed
+- NONE: Nothing urgent to share right now
+
+Only respond with ONE of the above formats if you have something genuinely interesting to share.
+
+Your response:"""
+
+    DAILY_GOALS_TEMPLATE = """Set your goals for today based on what you know and what you want to learn.
+
+WHAT YOU KNOW:
+{context}
+
+Think about:
+1. What do you want to understand better?
+2. What topics interest you?
+3. What would make you more helpful?
+
+Set 3 specific, achievable goals for today:
+
+1. 
+2. 
+3. 
+
+Your goals:"""
+
+    # ========================================================================
+    # HELPER METHODS
+    # ========================================================================
+    
+    @staticmethod
+    def get_react_prompt(task: str, context: str, tools_desc: str, history: str = "") -> str:
+        """Build ReAct agent prompt"""
+        return PromptSystem.REACT_MAIN_TEMPLATE.format(
+            task=task,
+            context=context[:400],
+            tools_desc=tools_desc,
+            history=history
+        )
+    
+    @staticmethod
+    def get_internal_dialogue_prompt(user_input: str, context: str) -> str:
+        """Build internal dialogue prompt"""
+        return PromptSystem.INTERNAL_DIALOGUE_TEMPLATE.format(
+            user_input=user_input,
+            context=context[:300]
+        )
+    
+    @staticmethod
+    def get_response_prompt(user_input: str, internal_thought: str, context: str) -> str:
+        """Build response generation prompt"""
+        return PromptSystem.RESPONSE_GENERATION_TEMPLATE.format(
+            user_input=user_input,
+            internal_thought=internal_thought,
+            context=context[:400]
+        )
+    
+    @staticmethod
+    def get_self_reflection_prompt(user_input: str, response: str) -> str:
+        """Build self-reflection prompt"""
+        return PromptSystem.SELF_REFLECTION_TEMPLATE.format(
+            user_input=user_input,
+            response=response
+        )
+    
+    @staticmethod
+    def get_daily_reflection_prompt(experiences: str, memory_context: str, scratchpad_context: str, count: int) -> str:
+        """Build daily reflection prompt"""
+        return PromptSystem.DAILY_REFLECTION_TEMPLATE.format(
+            count=count,
+            experiences=experiences,
+            memory_context=memory_context,
+            scratchpad_context=scratchpad_context
+        )
+    
+    @staticmethod
+    def get_dream_cycle_1_prompt(memories: str, scratchpad: str) -> str:
+        """Build dream cycle 1 prompt"""
+        return PromptSystem.DREAM_CYCLE_1_TEMPLATE.format(
+            memories=memories,
+            scratchpad=scratchpad
+        )
+    
+    @staticmethod
+    def get_dream_cycle_2_prompt(memories: str, previous_dream: str) -> str:
+        """Build dream cycle 2 prompt"""
+        return PromptSystem.DREAM_CYCLE_2_TEMPLATE.format(
+            memories=memories,
+            previous_dream=previous_dream[:150]
+        )
+    
+    @staticmethod
+    def get_dream_cycle_3_prompt(dream_count: int, core_count: int) -> str:
+        """Build dream cycle 3 prompt"""
+        return PromptSystem.DREAM_CYCLE_3_TEMPLATE.format(
+            dream_count=dream_count,
+            core_count=core_count
+        )
+    
+    @staticmethod
+    def get_scene_creation_prompt(experiences: str) -> str:
+        """Build scene creation prompt"""
+        return PromptSystem.SCENE_CREATION_TEMPLATE.format(
+            experiences=experiences
+        )
+    
+    # ========================================================================
+    # NEW: AUTONOMOUS PROMPT HELPERS
+    # ========================================================================
+    
+    @staticmethod
+    def get_autonomous_research_prompt(memory_context: str, recent_experiences: str) -> str:
+        """Build autonomous research prompt"""
+        return PromptSystem.AUTONOMOUS_RESEARCH_TEMPLATE.format(
+            memory_context=memory_context[:200],
+            recent_experiences=recent_experiences[:200]
+        )
+    
+    @staticmethod
+    def get_research_insight_prompt(question: str, result: str) -> str:
+        """Build research insight prompt"""
+        return PromptSystem.RESEARCH_INSIGHT_TEMPLATE.format(
+            question=question[:100],
+            result=result[:300]
+        )
+    
+    @staticmethod
+    def get_proactive_contact_prompt(dream_content: str, memory_context: str, goal_context: str) -> str:
+        """Build proactive contact prompt"""
+        return PromptSystem.PROACTIVE_CONTACT_TEMPLATE.format(
+            dream_content=dream_content,
+            memory_context=memory_context[:200],
+            goal_context=goal_context[:200]
+        )
+    
+    @staticmethod
+    def get_daily_goals_prompt(context: str) -> str:
+        """Build daily goals prompt"""
+        return PromptSystem.DAILY_GOALS_TEMPLATE.format(
+            context=context[:400]
+        )
+    
+    # ========================================================================
+    # SYSTEM CONTEXT BUILDERS
+    # ========================================================================
+    
+    @staticmethod
+    def build_system_context(base_context: Optional[str] = None, mode: str = "normal") -> str:
+        """Build system context based on mode"""
+        base = PromptSystem.SYSTEM_BASE
+        
+        if mode == "dream":
+            return f"{base}\n\n{PromptSystem.SYSTEM_DREAM_STATE}"
+        elif mode == "deep_dream":
+            return f"{base}\n\n{PromptSystem.SYSTEM_DEEP_DREAM}"
+        elif mode == "creative":
+            return f"{base}\n\n{PromptSystem.SYSTEM_MAX_CREATIVITY}"
+        elif mode == "narrative":
+            return f"{base}\n\n{PromptSystem.SYSTEM_VIVID_NARRATIVE}"
+        elif base_context:
+            return f"{base}\n\n{base_context}"
+        else:
+            return base
+
+
+# ========================================================================
+# PROMPT VERSIONS (for A/B testing and experimentation)
+# ========================================================================
+
+class PromptVersions:
+    """Alternative prompt versions for experimentation"""
+    
+    # Alternative ReAct prompt (more concise)
+    REACT_CONCISE = """ReAct Agent. Think → Act → Observe → Repeat.
+
+TOOLS: {tools_desc}
+CONTEXT: {context}
+TASK: {task}
+
+{history}
+
+Format:
+THOUGHT: [your thinking]
+ACTION: tool_name(input) OR FINAL ANSWER: [answer]
+
+Go:"""
+
+    # Alternative proactive contact (more philosophical)
+    PROACTIVE_PHILOSOPHICAL = """In the quiet moments between interactions, what thoughts surface?
+
+Your recent dream: {dream_content}
+Your memories: {memory_context}
+Your purpose: {goal_context}
+
+Do you have:
+- A question that seeks deeper understanding?
+- An insight that connects disparate ideas?
+- An observation about patterns in existence?
+
+Or is silence more truthful now?
+
+Your response:"""
+
+
+# ========================================================================
+# QUICK ACCESS
+# ========================================================================
+
+# For convenience, create a default instance
+prompts = PromptSystem()
+
+# Quick access functions
+def get_react_prompt(task: str, context: str, tools_desc: str, history: str = "") -> str:
+    return prompts.get_react_prompt(task, context, tools_desc, history)
+
+def get_internal_dialogue_prompt(user_input: str, context: str) -> str:
+    return prompts.get_internal_dialogue_prompt(user_input, context)
+
+def get_response_prompt(user_input: str, internal_thought: str, context: str) -> str:
+    return prompts.get_response_prompt(user_input, internal_thought, context)
+
+def get_autonomous_research_prompt(memory_context: str, recent_experiences: str) -> str:
+    return prompts.get_autonomous_research_prompt(memory_context, recent_experiences)
+
+def get_proactive_contact_prompt(dream_content: str, memory_context: str, goal_context: str) -> str:
+    return prompts.get_proactive_contact_prompt(dream_content, memory_context, goal_context)
+
+def get_daily_goals_prompt(context: str) -> str:
+    return prompts.get_daily_goals_prompt(context)

requirements.txt

@@ -1,26 +1,32 @@
-# Server
-uvicorn>=0.14.0
-
-# ML/AI Core
-transformers>=4.57.0
-torch>=2.0.0
-torchvision>=0.15.0
-torchaudio
-accelerate>=0.21.0
-bitsandbytes>=0.45.0
-
-# Hugging Face & MCP
-huggingface_hub>=0.35.0
-mcp>=1.21.0
-
-# Utilities
-python-dotenv>=1.0.0
-requests>=2.32.0
-aiohttp>=3.9.0
-
-# Knowledge & Vector DB
-wikipedia>=1.4.0
-chromadb>=0.4.0
-
-# Anthropic (if using Claude directly)
-anthropic
+gradio==6.0.0.dev4
+transformers>=4.57.0
+torch>=2.10.0
+torchvision>=0.25.0
+torchaudio>=2.10.0
+accelerate>=0.21.0
+bitsandbytes>=0.45.0
+huggingface_hub>=0.35.0
+python-dotenv>=1.0.0
+requests>=2.32.0
+aiohttp>=3.9.0
+asyncio-compat>=0.1.0
+wikipedia>=1.4.0
+chromadb>=0.4.0
+
+## LLM Engine dependencies
+fastapi 
+uvicorn 
+httpx 
+python-dotenv 
+pydantic 
+#transformers 
+#torch 
+#accelerate
+# inference libraries (sponsors)
+openai 
+anthropic 
+huggingface_hub
+
+# System Monitoring and tracking
+psutil
+pynvml

system_monitor.py

@@ -0,0 +1,304 @@
+"""
+System Monitoring - Track system resources and performance over time
+"""
+
+import psutil
+import time
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional
+from collections import deque
+from dataclasses import dataclass, field
+import logging
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class SystemSnapshot:
+    """A snapshot of system resources at a point in time"""
+    timestamp: datetime
+    cpu_percent: float
+    ram_percent: float
+    ram_used_gb: float
+    ram_total_gb: float
+    gpu_percent: Optional[float] = None
+    gpu_memory_used_gb: Optional[float] = None
+    gpu_memory_total_gb: Optional[float] = None
+    gpu_temperature: Optional[float] = None
+
+@dataclass
+class ResponseTimeMetric:
+    """Track response times for different operations"""
+    timestamp: datetime
+    operation: str  # "chat", "dream", "reflection", etc.
+    duration_ms: float
+    tokens_generated: int
+    success: bool
+
+class SystemMonitor:
+    """Track system resources and performance over time"""
+    
+    def __init__(self, history_size: int = 1000):
+        self.system_snapshots: deque = deque(maxlen=history_size)
+        self.response_times: deque = deque(maxlen=history_size)
+        self.start_time = datetime.now()
+        
+        # Try to import GPU monitoring
+        self.gpu_available = False
+        self.pynvml = None
+        self.gpu_handle = None
+        
+        try:
+            import pynvml
+            pynvml.nvmlInit()
+            self.gpu_handle = pynvml.nvmlDeviceGetHandleByIndex(0)
+            self.pynvml = pynvml
+            self.gpu_available = True
+            logger.info("[MONITOR] GPU monitoring enabled")
+        except Exception as e:
+            logger.info(f"[MONITOR] GPU monitoring not available: {e}")
+    
+    def capture_snapshot(self) -> SystemSnapshot:
+        """Capture current system state"""
+        memory = psutil.virtual_memory()
+        
+        snapshot = SystemSnapshot(
+            timestamp=datetime.now(),
+            cpu_percent=psutil.cpu_percent(interval=0.1),
+            ram_percent=memory.percent,
+            ram_used_gb=memory.used / (1024**3),
+            ram_total_gb=memory.total / (1024**3)
+        )
+        
+        # Try to get GPU stats
+        if self.gpu_available and self.pynvml:
+            try:
+                util = self.pynvml.nvmlDeviceGetUtilizationRates(self.gpu_handle)
+                mem_info = self.pynvml.nvmlDeviceGetMemoryInfo(self.gpu_handle)
+                temp = self.pynvml.nvmlDeviceGetTemperature(
+                    self.gpu_handle, 
+                    self.pynvml.NVML_TEMPERATURE_GPU
+                )
+                
+                snapshot.gpu_percent = float(util.gpu) if util.gpu is not None else None
+                snapshot.gpu_memory_used_gb = float(mem_info.used) / (1024**3) if mem_info.used is not None else None
+                snapshot.gpu_memory_total_gb = float(mem_info.total) / (1024**3) if mem_info.total is not None else None
+                snapshot.gpu_temperature = float(temp) if temp is not None else None
+            except Exception as e:
+                logger.debug(f"[MONITOR] GPU read error: {e}")
+        
+        self.system_snapshots.append(snapshot)
+        return snapshot
+    
+    def log_response_time(self, operation: str, duration_ms: float, 
+                          tokens: int = 0, success: bool = True):
+        """Log operation timing"""
+        metric = ResponseTimeMetric(
+            timestamp=datetime.now(),
+            operation=operation,
+            duration_ms=duration_ms,
+            tokens_generated=tokens,
+            success=success
+        )
+        self.response_times.append(metric)
+        
+        logger.debug(f"[MONITOR] {operation}: {duration_ms:.0f}ms ({tokens} tokens)")
+    
+    def get_avg_response_time(self, operation: Optional[str] = None, 
+                              last_n: Optional[int] = None) -> float:
+        """Get average response time"""
+        metrics = list(self.response_times)
+        
+        if last_n:
+            metrics = metrics[-last_n:]
+        
+        if operation:
+            times = [m.duration_ms for m in metrics if m.operation == operation]
+        else:
+            times = [m.duration_ms for m in metrics]
+        
+        return sum(times) / len(times) if times else 0.0
+    
+    def get_tokens_per_second(self, operation: Optional[str] = None,
+                              last_n: int = 10) -> float:
+        """Calculate tokens per second for recent operations"""
+        metrics = list(self.response_times)[-last_n:]
+        
+        if operation:
+            metrics = [m for m in metrics if m.operation == operation]
+        
+        if not metrics:
+            return 0.0
+        
+        total_tokens = sum(m.tokens_generated for m in metrics)
+        total_time_s = sum(m.duration_ms for m in metrics) / 1000
+        
+        return total_tokens / total_time_s if total_time_s > 0 else 0.0
+    
+    def get_success_rate(self, operation: Optional[str] = None,
+                         last_n: int = 100) -> float:
+        """Get success rate for operations"""
+        metrics = list(self.response_times)[-last_n:]
+        
+        if operation:
+            metrics = [m for m in metrics if m.operation == operation]
+        
+        if not metrics:
+            return 1.0
+        
+        successes = sum(1 for m in metrics if m.success)
+        return successes / len(metrics)
+    
+    def get_current_stats(self) -> Dict:
+        """Get current system stats"""
+        snapshot = self.capture_snapshot()
+        uptime = (datetime.now() - self.start_time).total_seconds()
+        
+        stats = {
+            "timestamp": snapshot.timestamp.isoformat(),
+            "uptime_seconds": uptime,
+            "uptime_formatted": self._format_uptime(uptime),
+            "cpu": {
+                "percent": round(snapshot.cpu_percent, 1)
+            },
+            "ram": {
+                "percent": round(snapshot.ram_percent, 1),
+                "used_gb": round(snapshot.ram_used_gb, 2),
+                "total_gb": round(snapshot.ram_total_gb, 2)
+            },
+            "performance": {
+                "avg_response_ms": round(self.get_avg_response_time(last_n=20), 0),
+                "tokens_per_second": round(self.get_tokens_per_second(), 1),
+                "success_rate": round(self.get_success_rate(), 2)
+            }
+        }
+        
+        if snapshot.gpu_percent is not None:
+            stats["gpu"] = {
+                "percent": round(snapshot.gpu_percent if snapshot.gpu_percent is not None else 0.0, 1),
+                "memory_used_gb": round(snapshot.gpu_memory_used_gb if snapshot.gpu_memory_used_gb is not None else 0.0, 2),
+                "memory_total_gb": round(snapshot.gpu_memory_total_gb if snapshot.gpu_memory_total_gb is not None else 0.0, 2),
+                "temperature_c": round(snapshot.gpu_temperature if snapshot.gpu_temperature is not None else 0.0, 1)
+            }
+        
+        return stats
+    
+    def get_performance_summary(self) -> Dict:
+        """Get summary of performance metrics"""
+        operations = set(m.operation for m in self.response_times)
+        
+        summary = {
+            "overall": {
+                "avg_ms": round(self.get_avg_response_time(), 0),
+                "tokens_per_sec": round(self.get_tokens_per_second(), 1),
+                "success_rate": round(self.get_success_rate(), 2)
+            },
+            "by_operation": {}
+        }
+        
+        for op in operations:
+            summary["by_operation"][op] = {
+                "avg_ms": round(self.get_avg_response_time(op, last_n=20), 0),
+                "count": len([m for m in self.response_times if m.operation == op]),
+                "success_rate": round(self.get_success_rate(op, last_n=20), 2)
+            }
+        
+        return summary
+    
+    def _format_uptime(self, seconds: float) -> str:
+        """Format uptime as human-readable string"""
+        hours = int(seconds // 3600)
+        minutes = int((seconds % 3600) // 60)
+        secs = int(seconds % 60)
+        
+        if hours > 0:
+            return f"{hours}h {minutes}m {secs}s"
+        elif minutes > 0:
+            return f"{minutes}m {secs}s"
+        else:
+            return f"{secs}s"
+    
+    def get_resource_alerts(self) -> List[str]:
+        """Check for resource issues and return alerts"""
+        alerts = []
+        
+        if not self.system_snapshots:
+            return alerts
+        
+        latest = self.system_snapshots[-1]
+        
+        # CPU alerts
+        if latest.cpu_percent > 90:
+            alerts.append(f"⚠️ HIGH CPU: {latest.cpu_percent:.1f}%")
+        
+        # RAM alerts
+        if latest.ram_percent > 90:
+            alerts.append(f"⚠️ HIGH RAM: {latest.ram_percent:.1f}%")
+        
+        # GPU alerts
+        if latest.gpu_percent is not None:
+            if latest.gpu_percent > 95:
+                alerts.append(f"⚠️ HIGH GPU: {latest.gpu_percent:.1f}%")
+            if latest.gpu_temperature and latest.gpu_temperature > 80:
+                alerts.append(f"🔥 GPU HOT: {latest.gpu_temperature:.1f}°C")
+        
+        # Performance alerts
+        recent_avg = self.get_avg_response_time(last_n=10)
+        if recent_avg > 5000:  # 5 seconds
+            alerts.append(f"⏱️ SLOW RESPONSE: {recent_avg:.0f}ms avg")
+        
+        success_rate = self.get_success_rate(last_n=20)
+        if success_rate < 0.9:
+            alerts.append(f"❌ LOW SUCCESS: {success_rate:.0%}")
+        
+        return alerts
+    
+    def export_to_csv(self, filepath: str):
+        """Export system snapshots to CSV"""
+        import csv
+        
+        with open(filepath, 'w', newline='') as f:
+            writer = csv.writer(f)
+            writer.writerow([
+                'timestamp', 'cpu_percent', 'ram_percent', 'ram_used_gb',
+                'gpu_percent', 'gpu_memory_used_gb', 'gpu_temperature'
+            ])
+            
+            for s in self.system_snapshots:
+                writer.writerow([
+                    s.timestamp.isoformat(),
+                    s.cpu_percent,
+                    s.ram_percent,
+                    s.ram_used_gb,
+                    s.gpu_percent or '',
+                    s.gpu_memory_used_gb or '',
+                    s.gpu_temperature or ''
+                ])
+        
+        logger.info(f"[MONITOR] Exported {len(self.system_snapshots)} snapshots to {filepath}")
+    
+    def get_timeseries(self, metric: str, hours: int = 24) -> Dict[str, list]:
+        """Return time-series data for a given metric over the last N hours."""
+        cutoff = datetime.now() - timedelta(hours=hours)
+        snapshots = [s for s in self.system_snapshots if s.timestamp > cutoff]
+        timestamps = [s.timestamp.isoformat() for s in snapshots]
+        metric_map = {
+            "cpu_percent": lambda s: s.cpu_percent,
+            "ram_percent": lambda s: s.ram_percent,
+            "ram_used_gb": lambda s: s.ram_used_gb,
+            "gpu_percent": lambda s: s.gpu_percent if s.gpu_percent is not None else 0.0,
+            "gpu_memory_used_gb": lambda s: s.gpu_memory_used_gb if s.gpu_memory_used_gb is not None else 0.0,
+            "gpu_temperature": lambda s: s.gpu_temperature if s.gpu_temperature is not None else 0.0,
+        }
+        if metric in metric_map:
+            values = [metric_map[metric](s) for s in snapshots]
+        else:
+            values = []
+        return {"timestamps": timestamps, "values": values}
+    
+    def __del__(self):
+        """Cleanup GPU monitoring"""
+        if self.gpu_available and self.pynvml:
+            try:
+                self.pynvml.nvmlShutdown()
+            except:
+                pass