Upload 22 files

modules/__init__.py

@@ -0,0 +1,122 @@
+# type: ignore
+"""
+AKIRA V21 ULTIMATE - Módulos Core
+===============================
+Arquitetura modular para IA conversacional com análise emocional BART.
+Inclui aprendizado contínuo, escuta global e visão computacional.
+"""
+
+__version__ = "21.01.2025"
+__author__ = "Isaac Quarenta"
+
+# Exportações principais
+from .config import (
+    APP_NAME,
+    APP_VERSION,
+    DEBUG_MODE,
+    NLP_CONFIG,
+    SYSTEM_PROMPT,
+    PRIVILEGED_USERS,
+    EmotionAnalyzer,
+    MemoriaEmocional,
+    get_emotion_analyzer,
+    validate_config,
+    # NLP Avançado exports - CORRIGIDO
+    NLPAdvancedConfig,
+    AdvancedNLP,
+    get_advanced_nlp,
+)
+
+from .database import Database
+
+from .contexto import Contexto, criar_contexto
+
+# Import API com tratamento de erro
+try:
+    from .api import AkiraAPI, get_blueprint
+    API_AVAILABLE = True
+except ImportError as e:
+    print(f"Aviso: API não disponível - {e}")
+    API_AVAILABLE = False
+
+# Aprendizado contínuo - é um módulo opcional
+APRENDIZADO_CONTINUO_AVAILABLE = False
+try:
+    from .aprendizado_continuo import (
+        AprendizadoContinuo,
+        get_aprendizado_continuo,
+        processar_conversa_global,
+        ConversaGlobal,
+        APIContextScore,
+    )
+    APRENDIZADO_CONTINUO_AVAILABLE = True
+except ImportError as e:
+    print(f"Aviso: Aprendizado Continuo nao disponivel - {e}")
+
+# Visão Computacional - módulo opcional (requer OpenCV e Tesseract)
+COMPUTER_VISION_AVAILABLE = False
+try:
+    from .computervision import (
+        ComputerVision,
+        get_computer_vision,
+        VisionConfig,
+        ImageFeature,
+        analyze_image_from_base64,
+        analyze_image_file,
+    )
+    COMPUTER_VISION_AVAILABLE = True
+except ImportError as e:
+    print(f"Aviso: Visão Computacional não disponível - {e}")
+
+__all__ = [
+    # Config
+    "APP_NAME",
+    "APP_VERSION",
+    "DEBUG_MODE",
+    "NLP_CONFIG",
+    "SYSTEM_PROMPT",
+    "PRIVILEGED_USERS",
+    "EmotionAnalyzer",
+    "MemoriaEmocional",
+    "get_emotion_analyzer",
+    "validate_config",
+    # NLP Avançado
+    "NLPAdvancedConfig",
+    "AdvancedNLP",
+    "get_advanced_nlp",
+    # Database
+    "Database",
+    # Contexto
+    "Contexto",
+    "criar_contexto",
+    # API
+    "AkiraAPI",
+    "get_blueprint",
+    "API_AVAILABLE",
+    # Aprendizado Continuo
+    "APRENDIZADO_CONTINUO_AVAILABLE",
+    # Visão Computacional
+    "COMPUTER_VISION_AVAILABLE",
+]
+
+# Adiciona Aprendizado Continuo se disponível
+if APRENDIZADO_CONTINUO_AVAILABLE:
+    __all__.extend([
+        "AprendizadoContinuo",
+        "get_aprendizado_continuo",
+        "processar_conversa_global",
+        "ConversaGlobal",
+        "APIContextScore",
+    ])
+
+# Adiciona Visão Computacional se disponível
+if COMPUTER_VISION_AVAILABLE:
+    __all__.extend([
+        "ComputerVision",
+        "get_computer_vision",
+        "VisionConfig",
+        "ImageFeature",
+        "analyze_image_from_base64",
+        "analyze_image_file",
+    ])
+

modules/aprendizado_continuo.py

@@ -0,0 +1,153 @@
+# type: ignore
+"""
+Aprendizado contínuo simples para AKIRA V21
+- Registra todas as mensagens (PV/Grupo), replies e respostas geradas
+- Persiste em JSONL em data/continuous_learning.jsonl
+- Fornece contexto global resumido para alimentar o LLM quando solicitado
+- Sugere melhor API baseada em heurísticas leves
+"""
+import os
+import json
+import time
+import threading
+from pathlib import Path
+from typing import Optional, Dict, Any, List
+
+try:
+    import modules.config as config
+except ImportError:  # fallback relativo
+    import config
+
+DATA_DIR: Path = getattr(config, 'DATA_DIR', Path('./data'))
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+JSONL_PATH: Path = DATA_DIR / 'continuous_learning.jsonl'
+LOCK = threading.Lock()
+
+
+class AprendizadoContinuo:
+    def __init__(self, jsonl_path: Path):
+        self.path = jsonl_path
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        # índice leve em memória (opcional)
+        self._buffer: List[Dict[str, Any]] = []
+        self._buffer_limit = 2000
+
+    def _append_jsonl(self, row: Dict[str, Any]) -> None:
+        with LOCK:
+            with self.path.open('a', encoding='utf-8') as f:
+                f.write(json.dumps(row, ensure_ascii=False) + '\n')
+            self._buffer.append(row)
+            if len(self._buffer) > self._buffer_limit:
+                self._buffer = self._buffer[-self._buffer_limit:]
+
+    def _now_ts(self) -> float:
+        return time.time()
+
+    def processar_mensagem(
+        self,
+        mensagem: str,
+        usuario: str,
+        numero: str,
+        nome_usuario: Optional[str] = None,
+        tipo_conversa: str = 'pv',  # 'pv' ou 'grupo'
+        resposta_do_bot: bool = False,
+        resposta_gerada: Optional[str] = None,
+        is_reply: bool = False,
+        reply_to_bot: bool = False,
+        contexto_grupo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Registra evento para aprendizado contínuo e retorna análise leve."""
+        mensagem_norm = (mensagem or '').strip()
+        if not mensagem_norm:
+            return {'status': 'ignored', 'motivo': 'mensagem_vazia'}
+
+        row = {
+            'ts': self._now_ts(),
+            'usuario': usuario,
+            'numero': numero,
+            'nome_usuario': nome_usuario or usuario,
+            'tipo_conversa': tipo_conversa,
+            'mensagem': mensagem_norm[:4000],
+            'resposta_do_bot': bool(resposta_do_bot),
+            'resposta_gerada': (resposta_gerada or '')[:4000] if resposta_do_bot else None,
+            'is_reply': bool(is_reply),
+            'reply_to_bot': bool(reply_to_bot),
+            'contexto_grupo': contexto_grupo or '',
+        }
+        self._append_jsonl(row)
+
+        analise = {
+            'comprimento': len(mensagem_norm.split()),
+            'tem_link': ('http://' in mensagem_norm) or ('https://' in mensagem_norm),
+            'tem_interrogacao': '?' in mensagem_norm,
+        }
+
+        aprendizado = {'armazenado_em': str(self.path)}
+        return {'ok': True, 'analise': analise, 'aprendizado': aprendizado}
+
+    def obter_contexto_para_llm(self, topico: Optional[str] = None, limite: int = 10) -> List[str]:
+        """Retorna últimas N mensagens (opcionalmente filtradas por tópico simples)."""
+        linhas: List[str] = []
+        # Lê somente o necessário (últimas ~2000 linhas, se arquivo grande)
+        try:
+            if self.path.exists():
+                with self.path.open('r', encoding='utf-8') as f:
+                    for line in f:
+                        linhas.append(line)
+                # Limita memória
+                linhas = linhas[-2000:]
+        except Exception:
+            pass
+
+        registros: List[Dict[str, Any]] = []
+        for line in linhas[-500:]:  # parse apenas últimas 500
+            try:
+                registros.append(json.loads(line))
+            except Exception:
+                continue
+
+        # filtra
+        if topico:
+            t = topico.lower().strip()
+            registros = [r for r in registros if t in (r.get('mensagem', '').lower())]
+
+        # monta blocos curtos para contexto
+        blocos: List[str] = []
+        for r in registros[-limite:]:
+            autor = r.get('nome_usuario') or r.get('usuario')
+            msg = r.get('mensagem', '')
+            tipo = r.get('tipo_conversa', 'pv')
+            blocos.append(f"[{tipo}] {autor}: {msg}")
+        return blocos
+
+    def get_best_api_for_context(
+        self,
+        complexidade: float = 0.5,
+        emocao: str = 'neutral',
+        intencao: str = 'afirmacao',
+        tipo_conversa: str = 'pv',
+    ) -> str:
+        """Heurística simples para escolher melhor API."""
+        # Preferir Groq (rápido) para baixa complexidade; Gemini/Mistral para maior complexidade
+        if complexidade >= 0.7:
+            if getattr(config, 'MISTRAL_API_KEY', ''):
+                return 'mistral'
+            if getattr(config, 'GEMINI_API_KEY', ''):
+                return 'gemini'
+        # caso contrário
+        if getattr(config, 'GROQ_API_KEY', ''):
+            return 'groq'
+        if getattr(config, 'GROK_API_KEY', ''):
+            return 'grok'
+        return 'llama'
+
+
+_singleton: Optional[AprendizadoContinuo] = None
+
+
+def get_aprendizado_continuo() -> AprendizadoContinuo:
+    global _singleton
+    if _singleton is None:
+        _singleton = AprendizadoContinuo(JSONL_PATH)
+    return _singleton

modules/computervision.py

@@ -0,0 +1,370 @@
+# type: ignore
+"""
+modules/computervision.py
+================================================================================
+VISION AI MÓDULO - MULTIMODAL GEMINI + QR CODE + fallback OCR
+================================================================================
+Versão 3.0 - AKIRA "The Seer"
+
+Este módulo evoluiu de detecção de bordas para entendimento semântico.
+Pipeline de Processamento:
+  1. Gemini Vision (Multimodal): Descrição de cena, objetos, cores e contexto.
+  2. QR Code Scanner: Extração de dados de códigos QR.
+  3. OCR (Tesseract): Extração de texto (fallback para técnica/precisão).
+  4. CV2 Analytics: Contagem de formas e objetos (Haar Cascades).
+  5. RAG Visual: Armazena hashes de imagens conhecidas para lembrança rápida.
+
+Diferente da V2, este módulo não apenas "vê" pixels, ele "entende" a imagem.
+================================================================================
+"""
+
+import os
+import io
+import json
+import time
+import base64
+import hashlib
+import sqlite3
+from datetime import datetime
+from typing import Dict, Any, List, Optional, Tuple, Union
+from dataclasses import dataclass
+from loguru import logger
+
+try:
+    from .config import DB_PATH
+except (ImportError, ValueError):
+    try:
+        from modules.config import DB_PATH
+    except ImportError:
+        DB_PATH = "akira.db"
+
+
+# ============================================================
+# Imports Lazy para Performance
+# ============================================================
+_cv2 = None
+_np = None
+_pytesseract = None
+_PIL_Image = None
+_genai = None
+
+def _check_core_deps():
+    global _cv2, _np, _pytesseract, _PIL_Image, _genai
+    try:
+        import cv2 as cv
+        import numpy as np
+        import pytesseract as pt
+        from PIL import Image as PILImg
+        _cv2, _np, _pytesseract, _PIL_Image = cv, np, pt, PILImg
+        
+        # Google GenAI (nova API)
+        try:
+            import google.genai as genai_new
+            _genai = genai_new
+        except ImportError:
+            try:
+                import google.generativeai as genai_old
+                _genai = genai_old
+            except ImportError:
+                _genai = None
+                
+        return True
+    except Exception as e:
+        logger.warning(f"Visão parcial: {e}")
+        return False
+
+_DEPS_OK = _check_core_deps()
+
+# ============================================================
+# CONFIGURAÇÕES
+# ============================================================
+
+@dataclass
+class VisionConfig:
+    ocr_lang: str = "por+eng"
+    similarity_threshold: float = 0.88
+    max_image_res: int = 1200
+    enable_gemini: bool = True
+    enable_qr: bool = True
+    db_path: str = DB_PATH
+
+# ============================================================
+# CLASSE PRINCIPAL
+# ============================================================
+
+class ComputerVision:
+    """
+    Controlador de Visão Computacional de Nova Geração.
+    """
+
+    def __init__(self, config: Optional[VisionConfig] = None):
+        self.config = config or VisionConfig()
+        self.db_path = self.config.db_path
+        self._setup_db()
+        self._init_cascades()
+        
+        # API Key do Gemini (preferencialmente injetada via config)
+        self.api_key = os.getenv("GEMINI_API_KEY", "")
+
+    def _setup_db(self):
+        """Garante tabela de memória visual."""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            c = conn.cursor()
+            c.execute("""
+                CREATE TABLE IF NOT EXISTS image_memory (
+                    hash TEXT PRIMARY KEY,
+                    user_id TEXT,
+                    description TEXT,
+                    ocr_text TEXT,
+                    qr_data TEXT,
+                    metadata TEXT,
+                    timestamp DATETIME
+                )
+            """)
+            conn.commit()
+            conn.close()
+        except Exception as e:
+            logger.error(f"Erro DB Visão: {e}")
+
+    def _init_cascades(self):
+        """Carrega modelos Haar Cascades para detecção básica."""
+        if not _cv2: return
+        try:
+            self._face_cascade = _cv2.CascadeClassifier(_cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+        except:
+            self._face_cascade = None
+
+    # ==================================================================
+    # 🎯 PIPELINE PRINCIPAL
+    # ==================================================================
+
+    # ==================================================================
+    # PROCESSAMENTO
+    # ==================================================================
+
+    def analyze_image(self, input_data: Union[str, bytes], user_id: str = "anon") -> Dict[str, Any]:
+        """
+        Processa imagem através de todo o pipeline.
+        Aceita: Caminho de arquivo (str), Base64 (str) ou Bytes brutos (bytes).
+        """
+        if not input_data: return {"success": False, "error": "Entrada vazia"}
+        
+        img_bytes = None
+        
+        try:
+            # 1. Detecção e Normalização da Entrada
+            if isinstance(input_data, bytes):
+                img_bytes = input_data
+            elif isinstance(input_data, str):
+                # Caso A: Caminho de arquivo local
+                if os.path.isfile(input_data):
+                    with open(input_data, "rb") as f:
+                        img_bytes = f.read()
+                # Caso B: Base64
+                else:
+                    try:
+                        b64_str = input_data
+                        if "," in b64_str: b64_str = b64_str.split(",")[1]
+                        img_bytes = base64.b64decode(b64_str)
+                    except Exception:
+                        return {"success": False, "error": "String informada não é um caminho válido nem Base64 válido"}
+            
+            if not img_bytes:
+                return {"success": False, "error": "Falha ao extrair bytes da imagem"}
+
+            img_hash = hashlib.md5(img_bytes).hexdigest()
+            
+            # 2. Check Memória Visual (Cache BD)
+            cached = self._get_from_memory(img_hash)
+            if cached:
+                logger.info(f"🧠 Memória Visual recordada: {img_hash}")
+                cached["cached"] = True
+                return cached
+
+            # 3. Preparação para OCR e CV2
+            nparr = _np.frombuffer(img_bytes, _np.uint8)
+            img_cv = _cv2.imdecode(nparr, _cv2.IMREAD_COLOR)
+            pil_img = _PIL_Image.open(io.BytesIO(img_bytes))
+
+            # --- EXECUÇÃO DO PIPELINE ---
+            
+            # A. QR Code (Rápido)
+            qr_data = self._scan_qr(img_cv) if self.config.enable_qr else None
+            
+            # B. Gemini Vision (Semântico - O Coração)
+            descricao = ""
+            if self.config.enable_gemini and self.api_key:
+                descricao = self._gemini_visual_analyze(img_bytes)
+            
+            # C. OCR (Fallback/Técnico)
+            ocr_text = self._run_ocr(pil_img)
+            
+            # D. CV2 Analytics (Estatístico/Objetos)
+            analytics = self._run_cv2_analytics(img_cv)
+
+            # 4. Consolidação
+            result = {
+                "success": True,
+                "hash": img_hash,
+                "description": descricao or "Não foi possível descrever a imagem semanticamente.",
+                "ocr": ocr_text,
+                "qr": qr_data,
+                "objects": analytics.get("objects", []),
+                "details": {
+                    "faces": analytics.get("faces", 0),
+                    "resolution": f"{img_cv.shape[1]}x{img_cv.shape[0]}" if img_cv is not None else "N/A"
+                },
+                "timestamp": datetime.now().isoformat()
+            }
+
+            # 5. Salva na Memória
+            self._save_to_memory(result, user_id)
+
+            return result
+
+        except Exception as e:
+            logger.exception("Falha no pipeline de visão")
+            return {"success": False, "error": str(e)}
+
+    # ==================================================================
+    # 👁️ MOTORES ESPECÍFICOS
+    # ==================================================================
+
+    def _gemini_visual_analyze(self, img_bytes: bytes) -> str:
+        """Usa Google Gemini Multimodal para descrever a imagem."""
+        if not _genai or not self.api_key: return ""
+        
+        try:
+            # Detecta se é a API nova ou antiga
+            if hasattr(_genai, 'Client'):  # Nova API google.genai
+                client = _genai.Client(api_key=self.api_key)
+                # Otimizado para Gemini 2.0 Flash
+                model_id = "gemini-2.0-flash" if "2.0-flash" in os.getenv("GEMINI_MODEL", "") else "gemini-1.5-flash"
+                
+                # Detetar MimeType dinâmico
+                mime_type = "image/png" if img_bytes.startswith(b"\x89PNG") else "image/jpeg"
+                response = client.models.generate_content(
+                    model=model_id,
+                    contents=[
+                        "Descreva esta imagem detalhadamente para uma IA assistente. Fale sobre objetos, cores, ambiente e se houver pessoas, descreva suas expressões.",
+                        _genai.types.Part.from_bytes(data=img_bytes, mime_type=mime_type),
+                    ]
+                )
+                return response.text if response else ""
+            else:
+                # API antiga google.generativeai
+                _genai.configure(api_key=self.api_key)
+                model = _genai.GenerativeModel('gemini-1.5-flash')
+                response = model.generate_content([
+                    "Descreva esta imagem detalhadamente. Seja direto e informativo.",
+                    _PIL_Image.open(io.BytesIO(img_bytes))
+                ])
+                return response.text if response else ""
+        except Exception as e:
+            logger.warning(f"Gemini Vision falhou: {e}")
+            return ""
+
+    def _scan_qr(self, img_cv) -> Optional[str]:
+        """Detecta e decodifica QR Code."""
+        if not _cv2 or img_cv is None: return None
+        try:
+            detector = _cv2.QRCodeDetector()
+            data, _, _ = detector.detectAndDecode(img_cv)
+            return data if data else None
+        except:
+            return None
+
+    def _run_ocr(self, pil_img) -> str:
+        """Extrai texto da imagem via Tesseract."""
+        if not _pytesseract: return ""
+        try:
+            return _pytesseract.image_to_string(pil_img, lang=self.config.ocr_lang).strip()
+        except:
+            return ""
+
+    def _run_cv2_analytics(self, img_cv) -> Dict[str, Any]:
+        """Detecta faces e extrai metadados visuais básicos."""
+        res = {"faces": 0, "objects": []}
+        if not _cv2 or img_cv is None: return res
+        
+        try:
+            gray = _cv2.cvtColor(img_cv, _cv2.COLOR_BGR2GRAY)
+            # Faces
+            if self._face_cascade:
+                faces = self._face_cascade.detectMultiScale(gray, 1.1, 4)
+                res["faces"] = len(faces)
+                if len(faces) > 0: res["objects"].append("pessoa/rosto")
+            
+            # Brilho médio
+            avg_color = _np.mean(img_cv, axis=(0, 1))
+            res["avg_color_bgr"] = avg_color.tolist()
+            
+        except: pass
+        return res
+
+    # ==================================================================
+    # 🗄️ PERSISTÊNCIA (MEMÓRIA VISUAL)
+    # ==================================================================
+
+    def _get_from_memory(self, img_hash: str) -> Optional[Dict]:
+        try:
+            conn = sqlite3.connect(self.db_path)
+            conn.row_factory = sqlite3.Row
+            c = conn.cursor()
+            c.execute("SELECT * FROM image_memory WHERE hash = ?", (img_hash,))
+            row = c.fetchone()
+            conn.close()
+            
+            if row:
+                res = dict(row)
+                return {
+                    "success": True,
+                    "hash": res["hash"],
+                    "description": res["description"],
+                    "ocr": res["ocr_text"],
+                    "qr": res["qr_data"],
+                    "timestamp": res["timestamp"],
+                    "from_memory": True
+                }
+        except: pass
+        return None
+
+    def _save_to_memory(self, result: Dict, user_id: str):
+        try:
+            conn = sqlite3.connect(self.db_path)
+            c = conn.cursor()
+            c.execute("""
+                INSERT OR REPLACE INTO image_memory 
+                (hash, user_id, description, ocr_text, qr_data, metadata, timestamp)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+            """, (
+                result["hash"],
+                user_id,
+                result["description"],
+                result["ocr"],
+                result["qr"],
+                json.dumps(result.get("details", {})),
+                result["timestamp"]
+            ))
+            conn.commit()
+            conn.close()
+        except Exception as e:
+            logger.debug(f"Erro ao salvar memória visual: {e}")
+
+# ============================================================
+# SINGLETON EXPORT
+# ============================================================
+
+_vision_instance = None
+
+def get_computer_vision(config=None) -> ComputerVision:
+    global _vision_instance
+    if _vision_instance is None:
+        _vision_instance = ComputerVision(config)
+    return _vision_instance
+
+def analyze_image_base64(b64_str: str, user_id: str = "anon") -> Dict[str, Any]:
+    return get_computer_vision().analyze_image(b64_str, user_id)
+
+__all__ = ["ComputerVision", "get_computer_vision", "analyze_image_base64"]

modules/context_builder.py

@@ -0,0 +1,607 @@
+# type: ignore
+"""
+================================================================================
+AKIRA V21 ULTIMATE - CONTEXT BUILDER MODULE
+================================================================================
+Constrói prompts otimizados para LLM combinando:
+- Memória de curto prazo (100 mensagens)
+- Contexto de reply (prioritário)
+- Memória vetorial (fatos aprendidos)
+- Contexto emocional
+- Sistema adaptativo baseado em tamanho da pergunta
+
+Features:
+- Hierarquia correta de contexto (reply > curto prazo > vetorial)
+- Token budgeting inteligente
+- Ajuste adaptativo para perguntas curtas
+- Suporte a múltiplos provedores LLM
+================================================================================
+"""
+
+import os
+import sys
+import time
+import json
+import logging
+from typing import Optional, Dict, Any, List, Tuple
+from dataclasses import dataclass
+
+# Imports robustos com fallback - CORRIGIDO para usar modules.
+try:
+    from . import config
+    from .context_isolation import ContextIsolationManager, ConversationContext
+    from .short_term_memory import ShortTermMemory, MessageWithContext
+    from .reply_context_handler import ReplyContextHandler, ProcessedReplyContext
+    CONTEXT_BUILDER_AVAILABLE = True
+except ImportError:
+    try:
+        import modules.config as config
+        from modules.context_isolation import ContextIsolationManager, ConversationContext
+        from modules.short_term_memory import ShortTermMemory, MessageWithContext
+        from modules.reply_context_handler import ReplyContextHandler, ProcessedReplyContext
+        CONTEXT_BUILDER_AVAILABLE = True
+    except ImportError:
+        CONTEXT_BUILDER_AVAILABLE = False
+        config = None
+
+logger = logging.getLogger(__name__)
+
+# ============================================================
+# CONFIGURAÇÃO
+# ============================================================
+
+# Token budgets para diferentes componentes
+TOKEN_BUDGET_SYSTEM: int = 1500
+TOKEN_BUDGET_REPLY: int = 800  # Para contexto de reply
+TOKEN_BUDGET_SHORT_TERM: int = 4000  # Para memória de curto prazo
+TOKEN_BUDGET_VECTOR: int = 1000  # Para memória vetorial
+TOKEN_BUDGET_TOTAL: int = 8000  # Total disponível para contexto
+
+# Limiares para perguntas curtas
+SHORT_QUESTION_THRESHOLD: int = 5  # palavras
+
+
+@dataclass
+class PromptBuildResult:
+    """
+    Resultado da construção do prompt.
+    
+    Attributes:
+        system_prompt: Prompt do sistema (sem modificação)
+        full_prompt: Prompt completo com contexto
+        context_sections: Seções de contexto incluídas
+        token_counts: Contagem de tokens por seção
+        warnings: Avisos sobre limitações
+        should_use_vector_memory: Se deve usar memória vetorial
+        should_prioritize_reply: Se reply deve ser priorizado
+    """
+    system_prompt: str = ""
+    full_prompt: str = ""
+    context_sections: Dict[str, str] = None
+    token_counts: Dict[str, int] = None
+    warnings: List[str] = None
+    should_use_vector_memory: bool = True
+    should_prioritize_reply: bool = False
+    
+    def __post_init__(self):
+        if self.context_sections is None:
+            self.context_sections = {}
+        if self.token_counts is None:
+            self.token_counts = {}
+        if self.warnings is None:
+            self.warnings = []
+
+
+# ============================================================
+# FUNÇÕES AUXILIARES
+# ============================================================
+
+def estimar_tokens(texto: str) -> int:
+    """Estima tokens em um texto (aproximação para português)."""
+    if not texto:
+        return 0
+    # Média de 4 caracteres por token em português
+    return max(1, len(texto) // 4)
+
+
+def truncar_para_tokens(texto: str, max_tokens: int) -> str:
+    """Trunca texto para caber no limite de tokens."""
+    if not texto or max_tokens <= 0:
+        return ""
+    
+    tokens = texto.split()
+    if len(tokens) <= max_tokens:
+        return texto
+    
+    return " ".join(tokens[:max_tokens])
+
+
+def is_pergunta_curta(texto: str) -> bool:
+    """Verifica se é uma pergunta curta."""
+    if not texto:
+        return False
+    return len(texto.split()) <= SHORT_QUESTION_THRESHOLD
+
+
+def calcular_peso_contexto(
+    mensagem: str,
+    reply_context: Optional[ProcessedReplyContext] = None
+) -> float:
+    """
+    Calcula peso do contexto baseado no tamanho da mensagem e reply.
+    
+    Args:
+        mensagem: Mensagem do usuário
+        reply_context: Contexto de reply (opcional)
+        
+    Returns:
+        Float entre 0.5 e 1.0 representando peso do contexto geral
+    """
+    word_count = len(mensagem.split())
+    
+    # Pergunta muito curta = menos contexto geral necessário
+    if word_count <= 2:
+        return 0.5
+    
+    # Pergunta curta = contexto moderado
+    if word_count <= SHORT_QUESTION_THRESHOLD:
+        return 0.7
+    
+    # Pergunta normal = contexto completo
+    return 1.0
+
+
+# ============================================================
+# CLASSE PRINCIPAL
+# ============================================================
+
+class ContextBuilder:
+    """
+    Construtor de prompts otimizados para LLM.
+    
+    Hierarquia de contexto:
+    1. System prompt (fixo)
+    2. Reply context (prioritário se existir)
+    3. Short-term memory (100 msgs sliding window)
+    4. Vector memory (fatos aprendidos)
+    5. User message (última)
+    
+    Adaptação para perguntas curtas:
+    - Pergunta curta + reply: reply tem 100%, contexto geral 50%
+    - Pergunta curta sem reply: contexto geral 70%
+    - Pergunta normal: contexto geral 100%
+    """
+    
+    def __init__(self, config_module=None):
+        """
+        Inicializa o builder.
+        
+        Args:
+            config_module: Módulo de configuração (usa config se None)
+        """
+        self.config = config_module or config
+        self.isolation_manager = None
+        self._initialized = False
+        
+        if CONTEXT_BUILDER_AVAILABLE:
+            try:
+                self.isolation_manager = ContextIsolationManager()
+                self._initialized = True
+            except Exception as e:
+                logger.warning(f"ContextBuilder: falha ao init isolation: {e}")
+    
+    def _ensure_initialized(self):
+        """Garante inicialização."""
+        if not self._initialized and CONTEXT_BUILDER_AVAILABLE:
+            try:
+                self.isolation_manager = ContextIsolationManager()
+                self._initialized = True
+            except:
+                pass
+    
+    def build_prompt(
+        self,
+        user_message: str,
+        conversation_id: str,
+        system_prompt: str = None,
+        reply_context: Optional[ProcessedReplyContext] = None,
+        short_term_memory: Optional[ShortTermMemory] = None,
+        vector_memory_info: Optional[List[Dict[str, Any]]] = None,
+        emocao_atual: str = "neutral",
+        incluir_memoria_vetorial: bool = True,
+        max_tokens_contexto: int = TOKEN_BUDGET_TOTAL
+    ) -> PromptBuildResult:
+        """
+        Constrói prompt completo para LLM.
+        
+        Args:
+            user_message: Mensagem do usuário
+            conversation_id: ID da conversa isolada
+            system_prompt: Prompt do sistema (usa config se None)
+            reply_context: Contexto de reply (opcional)
+            short_term_memory: Memória de curto prazo (opcional)
+            vector_memory_info: Fatos da memória vetorial (opcional)
+            emocao_atual: Emoção atual do usuário
+            incluir_memoria_vetorial: Se deve incluir memória vetorial
+            max_tokens_contexto: Máximo de tokens para contexto
+            
+        Returns:
+            PromptBuildResult com prompt completo
+        """
+        result = PromptBuildResult()
+        
+        # Get system prompt
+        system_prompt = system_prompt or getattr(self.config, 'SYSTEM_PROMPT', '')
+        result.system_prompt = system_prompt
+        
+        # Inicializa seções
+        sections = {
+            "system": system_prompt,
+            "reply_context": "",
+            "short_term_context": "",
+            "vector_memory": "",
+            "emotional_context": "",
+            "user_message": user_message
+        }
+        
+        # Contadores de tokens
+        tokens = {
+            "system": estimar_tokens(system_prompt),
+            "reply": 0,
+            "short_term": 0,
+            "vector": 0,
+            "emotional": 0,
+            "user": estimar_tokens(user_message)
+        }
+        
+        # Remaining budget after system and user
+        remaining_budget = max_tokens_contexto - tokens["system"] - tokens["user"]
+        
+        # ===== 1. REPLY CONTEXT (PRIORITÁRIO!) =====
+        if reply_context and reply_context.is_reply:
+            result.should_prioritize_reply = True
+            
+            # Para perguntas curtas com reply, mais tokens para reply
+            if is_pergunta_curta(user_message):
+                reply_budget = min(TOKEN_BUDGET_REPLY * 1.5, int(remaining_budget * 0.35))
+                remaining_budget -= reply_budget
+            else:
+                reply_budget = min(TOKEN_BUDGET_REPLY, int(remaining_budget * 0.25))
+                remaining_budget -= reply_budget
+            
+            # Constrói section do reply
+            reply_section = self._build_reply_section(reply_context, user_message)
+            reply_section = truncar_para_tokens(reply_section, reply_budget)
+            
+            sections["reply_context"] = reply_section
+            tokens["reply"] = estimar_tokens(reply_section)
+        
+        # ===== 2. SHORT-TERM MEMORY =====
+        if short_term_memory:
+            # Calcula peso baseado em tamanho da pergunta
+            peso_contexto = calcular_peso_contexto(user_message, reply_context)
+            stm_budget = min(
+                int(TOKEN_BUDGET_SHORT_TERM * peso_contexto),
+                int(remaining_budget * 0.7)
+            )
+            
+            stm_section = self._build_short_term_section(
+                short_term_memory, 
+                reply_context,
+                stm_budget
+            )
+            
+            sections["short_term_context"] = stm_section
+            tokens["short_term"] = estimar_tokens(stm_section)
+            remaining_budget -= tokens["short_term"]
+        
+        # ===== 3. VECTOR MEMORY =====
+        if incluir_memoria_vetorial and vector_memory_info:
+            vector_budget = min(TOKEN_BUDGET_VECTOR, int(remaining_budget * 0.3))
+            
+            vector_section = self._build_vector_section(vector_memory_info, vector_budget)
+            
+            sections["vector_memory"] = vector_section
+            tokens["vector"] = estimar_tokens(vector_section)
+            remaining_budget -= tokens["vector"]
+        
+        # ===== 4. EMOTIONAL CONTEXT =====
+        emotional_section = self._build_emotional_section(emocao_atual)
+        sections["emotional_context"] = emotional_section
+        tokens["emotional"] = estimar_tokens(emotional_section)
+        
+        # ===== 5. MONTA PROMPT COMPLETO =====
+        prompt_parts = []
+        
+        # System
+        if sections["system"]:
+            prompt_parts.append(f"[SYSTEM]\n{sections['system']}\n[/SYSTEM]\n")
+        
+        # Emotional context (apenas se não neutral)
+        if sections["emotional_context"]:
+            prompt_parts.append(f"[EMOÇÃO ATUAL]\n{sections['emotional_context']}\n")
+        
+        # Reply context (prioritário!)
+        if sections["reply_context"]:
+            prompt_parts.append(f"[REPLY PRIORITÁRIO]\n{sections['reply_context']}\n")
+        
+        # Short-term context
+        if sections["short_term_context"]:
+            prompt_parts.append(f"[CONTEXTO RECENTE]\n{sections['short_term_context']}\n")
+        
+        # Vector memory
+        if sections["vector_memory"]:
+            prompt_parts.append(f"[MEMÓRIA APRENDIDA]\n{sections['vector_memory']}\n")
+        
+        # User message
+        prompt_parts.append(f"[MENSAGEM]\n{user_message}\n")
+        
+        result.full_prompt = "\n".join(prompt_parts)
+        result.context_sections = sections
+        result.token_counts = tokens
+        
+        # Warnings se orçamento estourado
+        total_tokens = sum(tokens.values())
+        if total_tokens > max_tokens_contexto:
+            result.warnings.append(f"Contexto grande: {total_tokens} tokens (limite: {max_tokens_contexto})")
+        
+        return result
+    
+    def _build_reply_section(
+        self,
+        reply_context: ProcessedReplyContext,
+        user_message: str
+    ) -> str:
+        """Constrói seção de reply priorizado."""
+        parts = []
+        
+        # Cabeçalho de prioridade
+        if reply_context.priority_level >= 4:  # CRÍTICO
+            parts.append("⚠️⚠️⚠️ REPLY CRÍTICO - PERGUNTA CURTA ⚠️⚠️⚠️")
+        elif reply_context.priority_level == 3:  # REPLY TO BOT
+            parts.append("⚠️ REPLY DIRETO AO BOT")
+        else:
+            parts.append("📎 REPLY")
+        
+        # Autor
+        if reply_context.reply_to_bot:
+            parts.append("Você está sendo diretamente mencionado!")
+        else:
+            parts.append(f"Respondendo a: {reply_context.quoted_author_name}")
+        
+        # Mensagem citada
+        if reply_context.mensagem_citada:
+            cited = reply_context.mensagem_citada[:300]
+            parts.append(f"\nMsg citada:\n{cited}")
+        
+        # Contexto hint
+        if reply_context.context_hint and reply_context.context_hint != "contexto_geral":
+            parts.append(f"\nContexto: {reply_context.context_hint}")
+        
+        return "\n".join(parts)
+    
+    def _build_short_term_section(
+        self,
+        short_term_memory: ShortTermMemory,
+        reply_context: Optional[ProcessedReplyContext] = None,
+        max_tokens: int = TOKEN_BUDGET_SHORT_TERM
+    ) -> str:
+        """Constrói seção de memória de curto prazo."""
+        # Obtém mensagens do contexto
+        messages = short_term_memory.get_context_window(
+            include_replies=True,
+            prioritize_replies=True,
+            max_tokens=max_tokens
+        )
+        
+        if not messages:
+            return ""
+        
+        parts = []
+        parts.append("(últimas mensagens - replies priorizados)")
+        
+        # Limita a quantidade para caber no orçamento
+        included_count = 0
+        current_tokens = 0
+        
+        for msg in messages:
+            msg_tokens = estimar_tokens(msg.content)
+            if current_tokens + msg_tokens > max_tokens:
+                break
+            
+            # Formata mensagem
+            role = "🤖" if msg.role == "assistant" else "👤"
+            content_preview = msg.content[:100] + ("..." if len(msg.content) > 100 else "")
+            
+            if msg.is_reply:
+                parts.append(f"{role} [REPLY] {content_preview}")
+            else:
+                parts.append(f"{role} {content_preview}")
+            
+            current_tokens += msg_tokens
+            included_count += 1
+        
+        if not parts:
+            return ""
+        
+        return "\n".join(parts)
+    
+    def _build_vector_section(
+        self,
+        vector_info: List[Dict[str, Any]],
+        max_tokens: int = TOKEN_BUDGET_VECTOR
+    ) -> str:
+        """Constrói seção de memória vetorial."""
+        if not vector_info:
+            return ""
+        
+        parts = []
+        parts.append("(fatos aprendidos nesta conversa)")
+        
+        current_tokens = 0
+        
+        for item in vector_info[:10]:  # Limita a 10 itens
+            text = item.get("text", "") or item.get("mensagem", "")
+            if not text:
+                continue
+            
+            text_preview = text[:80] + ("..." if len(text) > 80 else "")
+            current_tokens += estimar_tokens(text)
+            
+            if current_tokens > max_tokens:
+                break
+            
+            parts.append(f"• {text_preview}")
+        
+        if len(parts) == 1:
+            return ""
+        
+        return "\n".join(parts)
+    
+    def _build_emotional_section(self, emocao: str) -> str:
+        """Constrói seção de contexto emocional."""
+        if emocao in ["neutral", "neutro"]:
+            return ""
+        
+        emocoes_descritas = {
+            "joy": "usuário parece feliz/contento",
+            "felicidade": "usuário parece feliz/contento",
+            "tristeza": "usuário parece triste",
+            "triste": "usuário parece triste",
+            "raiva": "usuário parece irritado/raivoso",
+            "raivoso": "usuário parece irritado/raivoso",
+            "amor": "usuário demonstra afeto",
+            "medo": "usuário parece preocupado/assustado",
+            "surpresa": "usuário parece surpreso",
+            "surpreso": "usuário parece surpreso"
+        }
+        
+        descricao = emocoes_descritas.get(emocao.lower(), f"usuário parece {emocao}")
+        return f"Tom emocional: {descricao}"
+    
+    # ============================================================
+    # HELPERS PARA API
+    # ============================================================
+    
+    def build_history_for_llm(
+        self,
+        short_term_memory: ShortTermMemory,
+        reply_context: Optional[ProcessedReplyContext] = None,
+        max_tokens: int = TOKEN_BUDGET_SHORT_TERM
+    ) -> List[Dict[str, str]]:
+        """
+        Constrói histórico formatado para LLM.
+        
+        Args:
+            short_term_memory: Memória de curto prazo
+            reply_context: Contexto de reply (opcional)
+            max_tokens: Máximo de tokens
+            
+        Returns:
+            Lista de dicts com role e content
+        """
+        # Garante que reply_context está priorizado
+        if reply_context and reply_context.is_reply:
+            # Cria mensagem artificial para o reply
+            reply_entry = {
+                "role": "user",
+                "content": f"[REPLY] {reply_context.get_reply_summary_for_llm(reply_context)}"
+            }
+            
+            # Obtém resto do histórico
+            history = short_term_memory.get_messages_for_llm(
+                reply_context=None,  # Já adicionado
+                max_tokens=max_tokens - estimar_tokens(reply_entry["content"])
+            )
+            
+            # Insere reply no início
+            return [reply_entry] + history
+        
+        return short_term_memory.get_messages_for_llm(max_tokens=max_tokens)
+    
+    def estimate_prompt_tokens(
+        self,
+        user_message: str,
+        reply_context: Optional[ProcessedReplyContext] = None,
+        historico_size: int = 0
+    ) -> int:
+        """
+        Estima tokens totais do prompt.
+        
+        Args:
+            user_message: Mensagem do usuário
+            reply_context: Contexto de reply
+            historico_size: Tamanho do histórico em mensagens
+            
+        Returns:
+            Estimativa de tokens
+        """
+        system_tokens = TOKEN_BUDGET_SYSTEM
+        
+        reply_tokens = 0
+        if reply_context and reply_context.is_reply:
+            reply_tokens = TOKEN_BUDGET_REPLY
+        
+        history_tokens = historico_size * 50  # Aproximação
+        
+        return system_tokens + reply_tokens + history_tokens + estimar_tokens(user_message)
+    
+    def get_conversation_context(
+        self,
+        numero_usuario: str,
+        tipo_conversa: str,
+        grupo_id: Optional[str] = None
+    ) -> Tuple[Optional[ConversationContext], ShortTermMemory]:
+        """
+        Obtém contexto isolado e memória de curto prazo.
+        
+        Args:
+            numero_usuario: Número do usuário
+            tipo_conversa: "pv" ou "grupo"
+            grupo_id: ID do grupo
+            
+        Returns:
+            Tupla (ConversationContext, ShortTermMemory)
+        """
+        self._ensure_initialized()
+        
+        if not self.isolation_manager:
+            return None, ShortTermMemory()
+        
+        context = self.isolation_manager.get_or_create_context(
+            numero_usuario, tipo_conversa, grupo_id
+        )
+        
+        # Carrega short-term memory do contexto
+        stm_data = context.short_memory if context else None
+        stm = ShortTermMemory(
+            conversation_id=context.context_id if context else "",
+            context_data={"messages": stm_data} if stm_data else None
+        )
+        
+        return context, stm
+    
+    def __repr__(self) -> str:
+        """Representação textual."""
+        return f"ContextBuilder(initialized={self._initialized})"
+
+
+# ============================================================
+# FUNÇÕES DE FÁBRICA
+# ============================================================
+
+def criar_context_builder(config_module=None) -> ContextBuilder:
+    """
+    Factory function para criar ContextBuilder.
+    
+    Args:
+        config_module: Módulo de configuração (opcional)
+        
+    Returns:
+        ContextBuilder instance
+    """
+    return ContextBuilder(config_module)
+
+
+# type: ignore
+

modules/context_isolation.py

@@ -0,0 +1,568 @@
+# type: ignore
+"""
+================================================================================
+AKIRA V21 ULTIMATE - CONTEXT ISOLATION MODULE
+================================================================================
+Sistema de isolamento de contexto entre conversas (PV e Grupos).
+Garante que contexto de um grupo não vaze para outro ou para PVs.
+
+Features:
+- Context ID único por combinação (usuário + tipo + grupo)
+- Salt criptográfico para prevenir guessing
+- CRUD completo para contextos isolados
+- Integração com Database para persistência
+- Suporte a migração de dados existentes
+================================================================================
+"""
+
+import os
+import sys
+import hashlib
+import time
+import json
+import logging
+from pathlib import Path
+from typing import Optional, Dict, Any, List, Tuple
+from dataclasses import dataclass, field, asdict
+from datetime import datetime
+
+# Imports robustos com fallback - CORRIGIDO para usar modules.
+try:
+    import modules.config as config
+    from .database import Database
+    CONTEXT_ISOLATION_AVAILABLE = True
+except ImportError:
+    try:
+        from . import config
+        from .database import Database
+        CONTEXT_ISOLATION_AVAILABLE = True
+    except ImportError:
+        CONTEXT_ISOLATION_AVAILABLE = False
+        config = None
+        Database = None
+
+logger = logging.getLogger(__name__)
+
+# ============================================================
+# CONFIGURAÇÃO DE ISOLAMENTO
+# ============================================================
+
+# Salt para geração de context_id (muda a cada deployment)
+CONTEXT_SALT: str = os.getenv("CONTEXT_SALT", "AKIRA_V21_CONTEXT_ISOLATION_v1")
+
+# Versão do esquema de isolamento (para migrações)
+SCHEMA_VERSION: int = 1
+
+
+@dataclass
+class ConversationContext:
+    """
+    Contexto isolado para uma conversa específica (PV ou Grupo).
+    
+    Attributes:
+        context_id: Identificador único (hash de tipo + numero + grupo)
+        numero_usuario: Número do usuário
+        grupo_id: ID do grupo (None para PV)
+        tipo_conversa: "pv" ou "grupo"
+        short_memory: Lista de mensagens de curto prazo (max 100)
+        estado_emocional: Estado emocional atual
+        nivel_intimidade: Nível de intimidade (1-3)
+        created_at: Timestamp de criação
+        last_interaction: Timestamp da última interação
+        metadata: Metadados adicionais
+    """
+    context_id: str
+    numero_usuario: str
+    grupo_id: Optional[str] = None
+    tipo_conversa: str = "pv"
+    short_memory: List[Dict[str, Any]] = field(default_factory=list)
+    estado_emocional: str = "neutral"
+    nivel_intimidade: int = 1
+    created_at: float = field(default_factory=time.time)
+    last_interaction: float = field(default_factory=time.time)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Converte para dicionário serializável."""
+        return asdict(self)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'ConversationContext':
+        """Cria instância a partir de dicionário."""
+        return cls(**data)
+    
+    @property
+    def is_grupo(self) -> bool:
+        """Retorna True se for conversa em grupo."""
+        return self.tipo_conversa == "grupo"
+    
+    @property
+    def display_name(self) -> str:
+        """Nome de exibição do contexto."""
+        if self.is_grupo:
+            return f"Grupo {self.grupo_id or 'desconhecido'}"
+        return f"PV {self.numero_usuario}"
+
+
+# ============================================================
+# FUNÇÕES DE GERAÇÃO DE CONTEXT ID
+# ============================================================
+
+def generate_context_id(
+    numero_usuario: str,
+    tipo_conversa: str,
+    grupo_id: Optional[str] = None
+) -> str:
+    """
+    Gera ID único e criptográfico para uma conversa.
+    
+    Args:
+        numero_usuario: Número de telefone do usuário
+        tipo_conversa: "pv" ou "grupo"
+        grupo_id: ID do grupo (opcional)
+        
+    Returns:
+        String de 64 caracteres (SHA256 hash)
+    """
+    # Limpa inputs
+    numero_clean = ''.join(filter(str.isdigit, str(numero_usuario))) or "unknown"
+    tipo_clean = str(tipo_conversa).lower().strip()
+    grupo_clean = ''.join(filter(str.isdigit, str(grupo_id))) if grupo_id else "pv"
+    
+    # Monta raw string
+    raw = f"{CONTEXT_SALT}:{tipo_clean}:{numero_clean}:{grupo_clean}:{int(time.time() // 86400)}"
+    
+    # Gera hash
+    hash_obj = hashlib.sha256(raw.encode('utf-8'))
+    return hash_obj.hexdigest()
+
+
+def validate_context_id(context_id: str) -> bool:
+    """
+    Valida formato de context_id.
+    
+    Args:
+        context_id: ID a ser validado
+        
+    Returns:
+        True se formato válido
+    """
+    if not context_id or not isinstance(context_id, str):
+        return False
+    
+    # SHA256 hex = 64 caracteres
+    return len(context_id) == 64 and all(c in '0123456789abcdef' for c in context_id)
+
+
+# ============================================================
+# CLASSE PRINCIPAL DE ISOLAMENTO
+# ============================================================
+
+class ContextIsolationManager:
+    """
+    Gerenciador de isolamento de contexto.
+    
+    Provides:
+    - Criação e gestão de contextos isolados
+    - Persistência em banco de dados
+    - Migração de dados legados
+    - Estatísticas e debugging
+    """
+    
+    _instance = None
+    _lock = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._lock = __import__('threading').Lock()
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        if self._initialized:
+            return
+        
+        self._db: Optional[Database] = None
+        self._contexts_cache: Dict[str, ConversationContext] = {}
+        self._initialized = True
+        
+        # Logger
+        if CONTEXT_ISOLATION_AVAILABLE and config:
+            logger.info("✅ ContextIsolationManager inicializado")
+        else:
+            print("[WARN] ContextIsolationManager: config/database não disponíveis")
+    
+    def _get_db(self) -> Database:
+        """Obtém instância do banco de dados."""
+        if self._db is None:
+            if Database:
+                try:
+                    from .config import DB_PATH
+                    self._db = Database(DB_PATH)
+                except ImportError:
+                    self._db = Database()
+            else:
+                raise RuntimeError("Database não disponível")
+        return self._db
+    
+    # ============================================================
+    # CRIAÇÃO E GESTÃO DE CONTEXTOS
+    # ============================================================
+    
+    def get_or_create_context(
+        self,
+        numero_usuario: str,
+        tipo_conversa: str,
+        grupo_id: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> ConversationContext:
+        """
+        Obtém contexto existente ou cria novo.
+        
+        Args:
+            numero_usuario: Número do usuário
+            tipo_conversa: "pv" ou "grupo"
+            grupo_id: ID do grupo (None para PV)
+            metadata: Metadados opcionais para novo contexto
+            
+        Returns:
+            ConversationContext instance
+        """
+        context_id = generate_context_id(numero_usuario, tipo_conversa, grupo_id)
+        
+        # Verifica cache
+        if context_id in self._contexts_cache:
+            ctx = self._contexts_cache[context_id]
+            ctx.last_interaction = time.time()
+            return ctx
+        
+        # Tenta carregar do banco
+        db = self._get_db()
+        ctx_data = db.recuperar_contexto_isolado(context_id)
+        
+        if ctx_data:
+            ctx = ConversationContext.from_dict(ctx_data)
+        else:
+            # Cria novo contexto
+            ctx = ConversationContext(
+                context_id=context_id,
+                numero_usuario=numero_usuario,
+                grupo_id=grupo_id,
+                tipo_conversa=tipo_conversa,
+                metadata=metadata or {}
+            )
+            # Salva no banco
+            self._save_context(ctx)
+        
+        # Atualiza cache
+        ctx.last_interaction = time.time()
+        self._contexts_cache[context_id] = ctx
+        
+        return ctx
+    
+    def get_context(
+        self,
+        numero_usuario: str,
+        tipo_conversa: str,
+        grupo_id: Optional[str] = None
+    ) -> Optional[ConversationContext]:
+        """
+        Obtém contexto existente (não cria novo).
+        
+        Args:
+            numero_usuario: Número do usuário
+            tipo_conversa: "pv" ou "grupo"
+            grupo_id: ID do grupo
+            
+        Returns:
+            ConversationContext ou None se não existir
+        """
+        context_id = generate_context_id(numero_usuario, tipo_conversa, grupo_id)
+        
+        # Verifica cache
+        if context_id in self._contexts_cache:
+            return self._contexts_cache[context_id]
+        
+        # Busca no banco
+        db = self._get_db()
+        ctx_data = db.recuperar_contexto_isolado(context_id)
+        
+        if ctx_data:
+            ctx = ConversationContext.from_dict(ctx_data)
+            self._contexts_cache[context_id] = ctx
+            return ctx
+        
+        return None
+    
+    def _save_context(self, context: ConversationContext) -> bool:
+        """Salva contexto no banco de dados."""
+        try:
+            db = self._get_db()
+            return db.salvar_contexto_isolado(context.to_dict())
+        except Exception as e:
+            logger.warning(f"Falha ao salvar contexto: {e}")
+            return False
+    
+    def save_context(self, context: ConversationContext) -> bool:
+        """Salva contexto e atualiza cache."""
+        context.last_interaction = time.time()
+        self._contexts_cache[context.context_id] = context
+        return self._save_context(context)
+    
+    def delete_context(self, context_id: str) -> bool:
+        """
+        Remove contexto isolado.
+        
+        Args:
+            context_id: ID do contexto a remover
+            
+        Returns:
+            True se removido com sucesso
+        """
+        if not validate_context_id(context_id):
+            logger.warning(f"Context ID inválido: {context_id}")
+            return False
+        
+        # Remove do cache
+        if context_id in self._contexts_cache:
+            del self._contexts_cache[context_id]
+        
+        # Remove do banco
+        try:
+            db = self._get_db()
+            return db.deletar_contexto_isolado(context_id)
+        except Exception as e:
+            logger.warning(f"Falha ao deletar contexto: {e}")
+            return False
+    
+    # ============================================================
+    # GESTÃO DE MEMÓRIA DE CURTO PRAZO
+    # ============================================================
+    
+    def add_message_to_context(
+        self,
+        context: ConversationContext,
+        role: str,
+        content: str,
+        importancia: float = 1.0,
+        emocao: str = "neutral",
+        reply_info: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """
+        Adiciona mensagem à memória de curto prazo do contexto.
+        
+        Args:
+            context: ConversationContext
+            role: "user" ou "assistant"
+            content: Texto da mensagem
+            importancia: Peso da mensagem (1.0 = normal, >1.0 = reply)
+            emocao: Emoção detectada
+            reply_info: Info adicional se for reply
+        """
+        MAX_MESSAGES = 100  # Configurado pelo usuário
+        
+        message_entry = {
+            "role": role,
+            "content": content,
+            "timestamp": time.time(),
+            "importancia": importancia,
+            "emocao": emocao,
+            "reply_info": reply_info or {}
+        }
+        
+        # Adiciona à lista
+        context.short_memory.append(message_entry)
+        
+        # Sliding window - remove mensagens antigas
+        if len(context.short_memory) > MAX_MESSAGES:
+            context.short_memory = context.short_memory[-MAX_MESSAGES:]
+        
+        # Atualiza timestamp
+        context.last_interaction = time.time()
+        
+        # Salva no banco
+        self.save_context(context)
+    
+    def get_context_window(
+        self,
+        context: ConversationContext,
+        include_replies: bool = True,
+        prioritize_replies: bool = True,
+        max_messages: int = 100
+    ) -> List[Dict[str, Any]]:
+        """
+        Obtém janela de contexto com prioridade para replies.
+        
+        Args:
+            context: ConversationContext
+            include_replies: Se deve incluir mensagens de reply
+            prioritize_replies: Se deve dar prioridade a replies
+            max_messages: Máximo de mensagens a retornar
+            
+        Returns:
+            Lista de mensagens ordenadas por importância
+        """
+        messages = context.short_memory.copy()
+        
+        if not messages:
+            return []
+        
+        # Filtra replies se necessário
+        if not include_replies:
+            messages = [m for m in messages if not m.get('reply_info', {})]
+        
+        # Ordena por importância (replies primeiro)
+        if prioritize_replies:
+            messages.sort(key=lambda x: x.get('importancia', 1.0), reverse=True)
+        
+        # Limita quantidade
+        return messages[:max_messages]
+    
+    def clear_context_memory(self, context: ConversationContext) -> bool:
+        """
+        Limpa memória de curto prazo do contexto.
+        
+        Args:
+            context: ConversationContext
+            
+        Returns:
+            True se limpo com sucesso
+        """
+        context.short_memory = []
+        context.last_interaction = time.time()
+        return self.save_context(context)
+    
+    # ============================================================
+    # LISTAGEM E ESTATÍSTICAS
+    # ============================================================
+    
+    def list_user_contexts(self, numero_usuario: str) -> List[ConversationContext]:
+        """
+        Lista todos os contextos de um usuário.
+        
+        Args:
+            numero_usuario: Número do usuário
+            
+        Returns:
+            Lista de ConversationContext
+        """
+        try:
+            db = self._get_db()
+            contexts_data = db.listar_contextos_usuario(numero_usuario)
+            
+            contexts = []
+            for data in contexts_data:
+                ctx = ConversationContext.from_dict(data)
+                # Atualiza cache
+                self._contexts_cache[ctx.context_id] = ctx
+                contexts.append(ctx)
+            
+            return contexts
+        except Exception as e:
+            logger.warning(f"Erro ao listar contextos: {e}")
+            return []
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """
+        Retorna estatísticas do sistema de isolamento.
+        
+        Returns:
+            Dicionário com estatísticas
+        """
+        return {
+            "cached_contexts": len(self._contexts_cache),
+            "schema_version": SCHEMA_VERSION,
+            "context_salt_set": bool(os.getenv("CONTEXT_SALT")),
+            "max_messages_per_context": 100
+        }
+    
+    # ============================================================
+    # MIGRAÇÃO DE DADOS LEGADOS
+    # ============================================================
+    
+    def migrate_legacy_context(
+        self,
+        numero_usuario: str,
+        grupo_id: Optional[str] = None,
+        tipo_conversa: str = "pv"
+    ) -> Optional[ConversationContext]:
+        """
+        Migra contexto legado para novo sistema isolado.
+        
+        Args:
+            numero_usuario: Número do usuário
+            grupo_id: ID do grupo
+            tipo_conversa: Tipo da conversa
+            
+        Returns:
+            ConversationContext migrado ou None
+        """
+        # Verifica se contexto já existe
+        existing = self.get_context(numero_usuario, tipo_conversa, grupo_id)
+        if existing:
+            return existing  # Já migrado
+        
+        # Cria novo contexto
+        context = self.get_or_create_context(numero_usuario, tipo_conversa, grupo_id)
+        
+        logger.info(f"📦 Contexto migrado: {context.display_name}")
+        return context
+
+
+# ============================================================
+# FUNÇÕES DE COMPATIBILIDADE
+# ============================================================
+
+def get_isolation_manager() -> ContextIsolationManager:
+    """Obtém instância singleton do gerenciador."""
+    return ContextIsolationManager()
+
+
+def criar_contexto_isolado(
+    numero_usuario: str,
+    tipo_conversa: str,
+    grupo_id: Optional[str] = None
+) -> ConversationContext:
+    """
+    Factory function para criar contexto isolado.
+    
+    Args:
+        numero_usuario: Número do usuário
+        tipo_conversa: "pv" ou "grupo"
+        grupo_id: ID do grupo (None para PV)
+        
+    Returns:
+        ConversationContext instance
+    """
+    manager = get_isolation_manager()
+    return manager.get_or_create_context(numero_usuario, tipo_conversa, grupo_id)
+
+
+# ============================================================
+# HELPER PARA API
+# ============================================================
+
+def extrair_conversation_id_do_request(data: Dict[str, Any]) -> Tuple[str, str, Optional[str]]:
+    """
+    Extrai parâmetros para conversation_id de um request da API.
+    
+    Args:
+        data: Payload do request (dict)
+        
+    Returns:
+        Tupla (numero_usuario, tipo_conversa, grupo_id)
+    """
+    numero_usuario = data.get('numero', 'anonimo') or 'anonimo'
+    tipo_conversa = data.get('tipo_conversa', 'pv')
+    
+    # Para mensagens de grupo, grupo_id vem em campos diferentes
+    grupo_id = data.get('grupo_id') or data.get('contexto_grupo')
+    
+    return numero_usuario, tipo_conversa, grupo_id
+
+
+# type: ignore
+

modules/contexto.py

@@ -1,454 +1,972 @@
-# modules/contexto.py — AKIRA V21 FINAL CORRIGIDO (Dezembro 2025)
-"""
-✅ TOTALMENTE ADAPTADO ao database.py correto
-✅ Usa métodos corretos do database
-✅ Processa reply_metadata do index.js
-✅ Sistema emocional DistilBERT
-"""
-
-import logging
-import re
-import random
-import time
-import json
-from typing import Optional, List, Dict, Tuple, Any
-from collections import deque
-
-logger = logging.getLogger(__name__)
-
-# Modelo de emoções
-try:
-    from transformers import pipeline
-    EMOTION_CLASSIFIER = pipeline(
-        "text-classification",
-        model="j-hartmann/emotion-english-distilroberta-base",
-        top_k=3,
-        device=-1,
-        truncation=True
-    )
-    logger.info("✅ Modelo DistilBERT carregado")
-    EMOTION_CACHE = {}
-except Exception as e:
-    logger.warning(f"⚠️ DistilBERT não disponível: {e}")
-    EMOTION_CLASSIFIER = None
-    EMOTION_CACHE = {}
-
-# Mapeamento emoção → humor
-EMOTION_TO_HUMOR = {
-    "joy": "feliz_ironica",
-    "sadness": "triste_ironica",
-    "anger": "irritada_ironica",
-    "fear": "preocupada_ironica",
-    "surprise": "curiosa_ironica",
-    "disgust": "irritada_ironica",
-    "neutral": "normal_ironico",
-    "love": "romantico_carinhoso"
-}
-
-class MemoriaEmocional:
-    def __init__(self, max_size=50):
-        self.historico = deque(maxlen=max_size)
-        self.tendencia_emocional = "neutral"
-        self.volatilidade = 0.5
-        
-    def adicionar_interacao(self, mensagem: str, emocao: str, confianca: float):
-        self.historico.append({
-            "mensagem": mensagem[:100],
-            "emocao": emocao,
-            "confianca": confianca,
-            "timestamp": time.time()
-        })
-        self._atualizar_tendencia()
-        
-    def _atualizar_tendencia(self):
-        if not self.historico:
-            return
-        recentes = list(self.historico)[-10:]
-        contagem = {}
-        for entry in recentes:
-            emocao = entry["emocao"]
-            contagem[emocao] = contagem.get(emocao, 0) + entry["confianca"]
-        if contagem:
-            self.tendencia_emocional = max(contagem, key=contagem.get)
-
-class Contexto:
-    def __init__(self, db: Any, usuario: str = "anonimo"):
-        self.db = db
-        self.usuario = usuario
-        
-        # Estado
-        self.humor_atual = "normal_ironico"
-        self.modo_resposta_atual = "normal_ironico"
-        self.memoria_emocional = MemoriaEmocional(max_size=50)
-        
-        # Transição
-        self.nivel_transicao = 0
-        self.humor_alvo = "normal_ironico"
-        self.ultima_transicao = time.time()
-        
-        # Conversa
-        self.ultima_mensagem_akira = None
-        self.tipo_conversa = "pv"
-        self.is_grupo = False
-        
-        # Usuário
-        self.numero_usuario = ""
-        self.nome_usuario = "Anônimo"
-        self.grupo_id = ""
-        self.grupo_nome = ""
-        
-        # Histórico
-        self.historico_mensagens = []
-        
-        self._carregar_estado_inicial()
-        logger.info(f"✅ Contexto inicializado: {self.usuario}")
-    
-    def _carregar_estado_inicial(self):
-        """Carrega estado do banco"""
-        try:
-            if hasattr(self.db, 'recuperar_humor_atual'):
-                self.humor_atual = self.db.recuperar_humor_atual(self.usuario)
-            
-            if hasattr(self.db, 'recuperar_modo_resposta'):
-                self.modo_resposta_atual = self.db.recuperar_modo_resposta(self.usuario)
-            
-            if hasattr(self.db, 'recuperar_mensagens'):
-                try:
-                    mensagens_db = self.db.recuperar_mensagens(self.usuario, limite=10)
-                    for msg in mensagens_db:
-                        if isinstance(msg, tuple) and len(msg) >= 2:
-                            if msg[0]:  # mensagem
-                                self.historico_mensagens.append({
-                                    "role": "user",
-                                    "content": msg[0],
-                                    "timestamp": msg[7] if len(msg) > 7 else time.time()
-                                })
-                            if len(msg) > 1 and msg[1]:  # resposta
-                                self.historico_mensagens.append({
-                                    "role": "assistant",
-                                    "content": msg[1],
-                                    "timestamp": msg[7] if len(msg) > 7 else time.time()
-                                })
-                except Exception as e:
-                    logger.warning(f"Falha ao carregar histórico: {e}")
-            
-            self.historico_mensagens.sort(key=lambda x: x.get('timestamp', 0))
-            
-        except Exception as e:
-            logger.warning(f"Erro ao carregar estado: {e}")
-    
-    def detectar_emocao_avancada(self, mensagem: str) -> Tuple[str, float, Dict]:
-        """Detecta emoção usando DistilBERT"""
-        mensagem_limpa = mensagem.strip()
-        cache_key = mensagem_limpa[:100].lower()
-        
-        if cache_key in EMOTION_CACHE:
-            return EMOTION_CACHE[cache_key]
-        
-        if not EMOTION_CLASSIFIER:
-            return self._detectar_emocao_fallback(mensagem_limpa)
-        
-        try:
-            resultados = EMOTION_CLASSIFIER(mensagem_limpa[:256], truncation=True)
-            
-            emocao_primaria = resultados[0][0]['label']
-            confianca_primaria = resultados[0][0]['score']
-            
-            detalhes = {
-                "primaria": {"emocao": emocao_primaria, "confianca": confianca_primaria},
-                "polaridade": "positiva" if emocao_primaria in ["joy", "love"] else "negativa" if emocao_primaria in ["anger", "sadness"] else "neutra"
-            }
-            
-            self.memoria_emocional.adicionar_interacao(mensagem_limpa, emocao_primaria, confianca_primaria)
-            
-            resultado = (emocao_primaria, confianca_primaria, detalhes)
-            EMOTION_CACHE[cache_key] = resultado
-            
-            return resultado
-            
-        except Exception as e:
-            logger.warning(f"Erro no DistilBERT: {e}")
-            return self._detectar_emocao_fallback(mensagem_limpa)
-    
-    def _detectar_emocao_fallback(self, mensagem: str) -> Tuple[str, float, Dict]:
-        """Fallback para detecção de emoção"""
-        mensagem_lower = mensagem.lower()
-        positivas = ['bom', 'ótimo', 'feliz', 'adorei']
-        negativas = ['ruim', 'péssimo', 'triste', 'raiva']
-        
-        pos = sum(1 for p in positivas if p in mensagem_lower)
-        neg = sum(1 for n in negativas if n in mensagem_lower)
-        
-        if pos > neg and pos >= 2:
-            return ("joy", 0.7, {"primaria": {"emocao": "joy", "confianca": 0.7}})
-        elif neg > pos and neg >= 2:
-            return ("anger", 0.7, {"primaria": {"emocao": "anger", "confianca": 0.7}})
-        else:
-            return ("neutral", 0.5, {"primaria": {"emocao": "neutral", "confianca": 0.5}})
-    
-    def atualizar_humor_gradual(self, emocao: str, confianca: float, tom_usuario: str,
-                                usuario_privilegiado: bool = False) -> str:
-        """Atualiza humor gradualmente"""
-        humor_anterior = self.humor_atual
-        
-        # Sugere humor
-        humor_sugerido = EMOTION_TO_HUMOR.get(emocao, "normal_ironico")
-        
-        if usuario_privilegiado and tom_usuario == "formal":
-            humor_sugerido = "tecnico_formal"
-        
-        # Inicia transição
-        if self.humor_alvo != humor_sugerido:
-            self.humor_alvo = humor_sugerido
-            self.nivel_transicao = 0
-        
-        # Transição
-        taxa = 0.5
-        if confianca > 0.8:
-            taxa += 0.3
-        if tom_usuario == "rude":
-            taxa += 0.4
-        
-        self.nivel_transicao = min(3, self.nivel_transicao + taxa)
-        
-        # Novo humor
-        if self.nivel_transicao >= 3:
-            novo_humor = self.humor_alvo
-        else:
-            novo_humor = self.humor_atual
-        
-        # Salva transição se mudou
-        if novo_humor != humor_anterior and hasattr(self.db, 'salvar_transicao_humor'):
-            try:
-                self.db.salvar_transicao_humor(
-                    self.usuario,
-                    humor_anterior,
-                    novo_humor,
-                    emocao,
-                    confianca,
-                    self.nivel_transicao,
-                    f"Emoção: {emocao} ({confianca:.2f})"
-                )
-            except Exception as e:
-                logger.warning(f"Erro ao salvar transição: {e}")
-        
-        self.humor_atual = novo_humor
-        return novo_humor
-    
-    def detectar_tom_usuario(self, mensagem: str) -> Tuple[str, float]:
-        """Detecta tom do usuário"""
-        mensagem_lower = mensagem.lower()
-        
-        # Formal
-        if any(x in mensagem_lower for x in ["senhor", "doutor", "por favor"]):
-            return ("formal", 0.8)
-        
-        # Rude
-        rudes = ['burro', 'idiota', 'merda', 'caralho']
-        if any(x in mensagem_lower for x in rudes):
-            return ("rude", 0.9)
-        
-        # Informal
-        if any(x in mensagem_lower for x in ['puto', 'mano', 'fixe']):
-            return ("informal", 0.7)
-        
-        return ("neutro", 0.5)
-    
-    def detectar_modo_resposta(self, mensagem: str, tom_usuario: str,
-                              usuario_privilegiado: bool = False) -> str:
-        """Detecta modo de resposta"""
-        mensagem_lower = mensagem.lower()
-        
-        if usuario_privilegiado and tom_usuario == "formal":
-            return "tecnico_formal"
-        
-        if tom_usuario == "rude":
-            return "agressivo_direto"
-        
-        if '?' in mensagem and len(mensagem) > 100:
-            return "filosofico_ironico"
-        
-        palavras_romanticas = ['amor', 'paixão', 'gosto de ti']
-        if any(p in mensagem_lower for p in palavras_romanticas):
-            return "romantico_carinhoso"
-        
-        return "normal_ironico"
-    
-    def analisar_intencao_e_normalizar(self, mensagem: str, historico: List[Dict] = None,
-                                      mensagem_citada: str = None,
-                                      reply_metadata: Dict = None) -> Dict[str, Any]:
-        """Análise principal - COMPATÍVEL COM INDEX.JS"""
-        if not isinstance(mensagem, str):
-            mensagem = str(mensagem)
-        
-        if historico is None:
-            historico = self.obter_historico_para_llm()
-        
-        # Verifica privilégio
-        usuario_privilegiado = False
-        if self.numero_usuario and hasattr(self.db, 'is_usuario_privilegiado'):
-            try:
-                usuario_privilegiado = self.db.is_usuario_privilegiado(self.numero_usuario)
-            except:
-                pass
-        
-        # Detecta emoção
-        emocao, confianca, detalhes_emocao = self.detectar_emocao_avancada(mensagem)
-        
-        # Detecta tom
-        tom_usuario, intensidade_tom = self.detectar_tom_usuario(mensagem)
-        
-        # Atualiza humor
-        humor_atualizado = self.atualizar_humor_gradual(
-            emocao, confianca, tom_usuario, usuario_privilegiado
-        )
-        
-        # Detecta modo
-        modo_resposta = self.detectar_modo_resposta(mensagem, tom_usuario, usuario_privilegiado)
-        self.modo_resposta_atual = modo_resposta
-        
-        # Analisa reply
-        reply_analysis = self._analisar_reply_context(mensagem_citada, reply_metadata)
-        
-        # Resultado
-        resultado = {
-            "tom_usuario": tom_usuario,
-            "tom_intensidade": intensidade_tom,
-            "emocao_primaria": emocao,
-            "confianca_emocao": confianca,
-            "detalhes_emocao": detalhes_emocao,
-            "modo_resposta": modo_resposta,
-            "humor_atualizado": humor_atualizado,
-            "nivel_transicao": self.nivel_transicao,
-            "humor_alvo": self.humor_alvo,
-            "usuario_privilegiado": usuario_privilegiado,
-            "nome_usuario": self.nome_usuario,
-            "numero_usuario": self.numero_usuario,
-            "eh_resposta": reply_analysis.get("is_reply", False),
-            "eh_resposta_ao_bot": reply_analysis.get("reply_to_bot", False),
-            "mensagem_citada_limpa": mensagem_citada or "",
-            "reply_analysis": reply_analysis,
-            "reply_metadata": reply_metadata,
-            "tipo_conversa": self.tipo_conversa,
-            "is_grupo": self.is_grupo,
-            "tendencia_emocional": self.memoria_emocional.tendencia_emocional,
-            "volatilidade_usuario": self.memoria_emocional.volatilidade
-        }
-        
-        return resultado
-    
-    def _analisar_reply_context(self, mensagem_citada: str, reply_metadata: Dict) -> Dict[str, Any]:
-        """Analisa contexto de reply"""
-        if reply_metadata:
-            return {
-                "is_reply": reply_metadata.get('is_reply', False),
-                "reply_to_bot": reply_metadata.get('reply_to_bot', False),
-                "quoted_author_name": reply_metadata.get('quoted_author_name', ''),
-                "texto_citado_completo": reply_metadata.get('texto_mensagem_citada', ''),
-                "context_hint": reply_metadata.get('context_hint', ''),
-                "source": "reply_metadata"
-            }
-        
-        if mensagem_citada:
-            reply_to_bot = "AKIRA" in mensagem_citada.upper()
-            return {
-                "is_reply": True,
-                "reply_to_bot": reply_to_bot,
-                "quoted_author_name": "Akira" if reply_to_bot else "desconhecido",
-                "texto_citado_completo": mensagem_citada,
-                "context_hint": f"Citando {'Akira' if reply_to_bot else 'outra pessoa'}",
-                "source": "mensagem_citada"
-            }
-        
-        return {
-            "is_reply": False,
-            "reply_to_bot": False,
-            "quoted_author_name": "",
-            "texto_citado_completo": "",
-            "context_hint": "",
-            "source": "nenhum"
-        }
-    
-    def obter_historico_para_llm(self) -> List[Dict]:
-        """Retorna histórico formatado"""
-        return [
-            {"role": msg["role"], "content": msg["content"][:500]}
-            for msg in self.historico_mensagens[-10:]
-        ]
-    
-    def atualizar_contexto(self, mensagem: str, resposta: str, numero: str,
-                          is_reply: bool = False, mensagem_original: str = None,
-                          reply_to_bot: bool = False):
-        """Atualiza contexto após interação"""
-        try:
-            timestamp = time.time()
-            
-            # Adiciona ao histórico
-            self.historico_mensagens.append({
-                "role": "user",
-                "content": mensagem,
-                "timestamp": timestamp,
-                "is_reply": is_reply,
-                "reply_to_bot": reply_to_bot
-            })
-            self.historico_mensagens.append({
-                "role": "assistant",
-                "content": resposta,
-                "timestamp": timestamp
-            })
-            
-            # Limita
-            if len(self.historico_mensagens) > 20:
-                self.historico_mensagens = self.historico_mensagens[-20:]
-            
-            self.ultima_mensagem_akira = resposta
-            
-            # Salva no banco
-            if hasattr(self.db, 'salvar_mensagem'):
-                try:
-                    self.db.salvar_mensagem(
-                        usuario=self.nome_usuario,
-                        mensagem=mensagem,
-                        resposta=resposta,
-                        numero=numero,
-                        is_reply=is_reply,
-                        mensagem_original=mensagem_original or '',
-                        reply_to_bot=reply_to_bot,
-                        humor=self.humor_atual,
-                        modo_resposta=self.modo_resposta_atual,
-                        usuario_nome=self.nome_usuario,
-                        tipo_conversa=self.tipo_conversa
-                    )
-                except Exception as e:
-                    logger.warning(f"Erro ao salvar mensagem: {e}")
-            
-        except Exception as e:
-            logger.error(f"Erro ao atualizar contexto: {e}")
-    
-    def atualizar_informacoes_usuario(self, nome: str, numero: str,
-                                     grupo_id: str = "", grupo_nome: str = "",
-                                     tipo_conversa: str = "pv"):
-        """Atualiza informações do usuário"""
-        self.nome_usuario = nome or self.nome_usuario
-        self.numero_usuario = numero or self.numero_usuario
-        self.grupo_id = grupo_id or self.grupo_id
-        self.grupo_nome = grupo_nome or self.grupo_nome
-        self.tipo_conversa = tipo_conversa
-        self.is_grupo = tipo_conversa == "grupo"
-
-def criar_contexto(db: Any, identificador: str, tipo: str = "pv") -> Contexto:
-    """Cria contexto isolado"""
-    try:
-        if tipo == "grupo":
-            usuario_id = f"grupo_{identificador}"
-        else:
-            usuario_id = f"pv_{identificador}"
-        
-        contexto = Contexto(db, usuario_id)
-        contexto.tipo_conversa = tipo
-        contexto.is_grupo = (tipo == "grupo")
-        
-        return contexto
-    except Exception as e:
-        logger.error(f"Erro ao criar contexto: {e}")
-        return Contexto(db, "fallback")
+
+# type: ignore
+"""
+================================================================================
+AKIRA V21 ULTIMATE - CONTEXTO MODULE
+================================================================================
+Gerenciador de contexto de conversa com NLP avançado, análise emocional,
+aprendizado dinâmico de gírias e adaptação de tom por usuário.
+
+Features:
+- Análise de intenção e normalização de texto
+- Detecção de emoções com fallback heurístico
+- Aprendizado de gírias regionais (Angola)
+- Histórico de conversa persistente
+- Tom adaptativo por usuário
+- Integração com EmotionAnalyzer do config
+- Sistema de embeddings para similaridade
+- Cache inteligente
+- Logging detalhado
+================================================================================
+"""
+
+import logging
+import re
+import random
+import time
+import sqlite3
+import json
+from typing import Optional, List, Dict, Tuple, Any, Union
+from datetime import datetime
+
+# Imports robustos com fallback - CORRIGIDO
+try:
+    from . import config
+    from .database import Database
+    from .treinamento import Treinamento
+    CONTEXTO_AVAILABLE = True
+except ImportError as e:
+    CONTEXTO_AVAILABLE = False
+    try:
+        import config
+        from database import Database
+        from treinamento import Treinamento
+    except ImportError:
+        import sys
+        sys.path.insert(0, '/home/elliot_pro/Programação/akira')
+        import modules.config as config
+        from modules.database import Database
+        try:
+            from modules.treinamento import Treinamento
+        except ImportError:
+            Treinamento = None
+            Database = None
+
+# Imports opcionais com fallbacks
+try:
+    from sentence_transformers import SentenceTransformer  # type: ignore
+    SENTENCE_TRANSFORMER_AVAILABLE = True
+except Exception as e:
+    logging.warning(f"sentence_transformers não disponível: {e}")
+    SentenceTransformer = None  # type: ignore
+    SENTENCE_TRANSFORMER_AVAILABLE = False
+
+try:
+    import psutil  # type: ignore
+    PSUTIL_AVAILABLE = True
+except Exception:
+    psutil = None  # type: ignore
+    PSUTIL_AVAILABLE = False
+
+try:
+    import structlog  # type: ignore
+    STRUCTLOG_AVAILABLE = True
+except Exception:
+    structlog = None  # type: ignore
+    STRUCTLOG_AVAILABLE = False
+
+logger = logging.getLogger(__name__)
+
+# Configuração do logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')
+
+if STRUCTLOG_AVAILABLE and structlog:
+    structlog.configure(
+        processors=[
+            structlog.processors.TimeStamper(fmt="iso"),
+            structlog.stdlib.add_log_level,
+            structlog.processors.JSONRenderer()
+        ],
+        context_class=dict,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,
+    )
+
+# Palavras para análise de sentimento heurística (fallback)
+PALAVRAS_POSITIVAS = [
+    'bom', 'ótimo', 'incrível', 'feliz', 'adorei', 'top', 'fixe', 'bué', 
+    'show', 'legal', 'bacana', 'excelente', 'maravilhoso', 'perfeito'
+]
+PALAVRAS_NEGATIVAS = [
+    'ruim', 'péssimo', 'triste', 'ódio', 'raiva', 'chateado', 'merda', 
+    'porra', 'odeio', 'horrível', 'terrible', 'p不佳'
+]
+
+# Cache global para emotion analyzer
+_emotion_analyzer: Any = None
+
+def _get_emotion_analyzer() -> Any:
+    """Obtém instância do EmotionAnalyzer do config.py."""
+    global _emotion_analyzer
+    if _emotion_analyzer is None:
+        try:
+            analyzer = config.get_emotion_analyzer()
+            # Verifica se o analyzer é callable antes de atribuir
+            if analyzer is not None and callable(analyzer):
+                _emotion_analyzer = analyzer
+            else:
+                _emotion_analyzer = None
+        except Exception as e:
+            logger.warning(f"EmotionAnalyzer não disponível: {e}")
+            _emotion_analyzer = None
+    return _emotion_analyzer
+
+
+class Contexto:
+    """
+    Classe para gerenciar o contexto da conversa, análise de intenções e 
+    aprendizado dinâmico de termos regionais/gírias para cada usuário.
+    
+    Attributes:
+        db: Instância do banco de dados
+        usuario: Identificador do usuário
+        model: Modelo SentenceTransformer (carregado sob demanda)
+        embeddings: Cache de embeddings
+        emocao_atual: Emoção atual do usuário
+        espirito_critico: Modo de espírito crítico ativado
+        base_conhecimento: Base de conhecimento persistente
+        termo_contexto: Dicionário de termos/gírias aprendidos
+        cache_girias: Cache de gírias por usuário
+        primeira_mensagem: Flag para detectar primeira interação
+        tom_anterior: Tom da última mensagem para transição lenta
+        contagem_mensagens_tom: Contador para transição gradual
+    """
+    
+    def __init__(self, db: Optional[Database] = None, usuario: Optional[str] = None, conversation_id: Optional[str] = None):
+        """
+        Inicializa o contexto de conversa.
+        
+        Args:
+            db: Instância do banco de dados Database
+            usuario: Identificador do usuário (número de telefone ou nome)
+            conversation_id: ID único da conversa para isolamento (opcional)
+        """
+        self.db = db
+        self.usuario: Optional[str] = usuario
+        self.conversation_id: Optional[str] = conversation_id
+        self.model: Optional[Any] = None
+        self.embeddings: Optional[Dict[str, Any]] = None
+        self._treinador: Optional[Treinamento] = None
+        
+        # Estado de conversa
+        self.emocao_atual: str = "neutra"
+        self.espirito_critico: bool = False
+        self.base_conhecimento: Dict[str, Any] = {}
+        
+        # Garante que termo_contexto seja sempre um dicionário
+        self.termo_contexto: Dict[str, Dict[str, Any]] = {}
+        self.cache_girias: Dict[str, Any] = {}
+        
+        # Novas flags para primeira mensagem e transição lenta de tom
+        self.primeira_mensagem: bool = True
+        self.tom_anterior: str = "neutro"
+        self.contagem_mensagens_tom: int = 0
+        self.tom_atual: str = "neutro"
+        
+        # Carrega aprendizados do banco
+        self.atualizar_aprendizados_do_banco()
+        
+        logger.info(f"🟢 Contexto inicializado para usuário: {usuario}")
+        
+        # Carrega modelo sob demanda
+        self._load_model()
+
+    def atualizar_aprendizados_do_banco(self):
+        """Carrega todos os dados de aprendizado persistentes do banco."""
+        try:
+            if self.usuario and self.db is not None:
+                termos_aprendidos = self.db.recuperar_girias_usuario(self.usuario)
+                self.termo_contexto = {
+                    termo['giria']: {
+                        "significado": termo['significado'], 
+                        "frequencia": termo['frequencia']
+                    } 
+                    for termo in termos_aprendidos
+                }
+            else:
+                self.termo_contexto = {}
+        except Exception as e:
+            logger.warning(f"Falha ao carregar termos/gírias do DB: {e}")
+            self.termo_contexto = {}
+
+        try:
+            if self.usuario and self.db is not None:
+                emocao_salva = self.db.recuperar_aprendizado_detalhado(self.usuario, "emocao_atual")
+                if emocao_salva:
+                    # Tenta parsear como JSON primeiro
+                    try:
+                        if isinstance(emocao_salva, str):
+                            emocao_dict = json.loads(emocao_salva)
+                        else:
+                            emocao_dict = emocao_salva
+                        
+                        if isinstance(emocao_dict, dict) and 'emocao' in emocao_dict:
+                            self.emocao_atual = emocao_dict['emocao']
+                        elif isinstance(emocao_salva, str):
+                            self.emocao_atual = emocao_salva
+                    except (json.JSONDecodeError, TypeError):
+                        # Se não for JSON válido, usa como string direta
+                        if isinstance(emocao_salva, str):
+                            self.emocao_atual = emocao_salva
+        except Exception as e:
+            logger.warning(f"Falha ao carregar emoção do DB: {e}")
+
+    @property
+    def ton_predominante(self) -> Optional[str]:
+        """
+        Retorna o tom predominante do usuário, acessando o DB.
+        
+        Returns:
+            Tom predominante ou None se não disponível
+        """
+        if self.usuario and self.db is not None:
+            return self.db.obter_tom_predominante(self.usuario)
+        return None
+
+    def get_or_create_treinador(self, interval_hours: int = 24) -> Treinamento:
+        """Retorna um entrenador associado a este contexto."""
+        if self._treinador is None:
+            db_param: Database = self.db if self.db is not None else Database()
+            self._treinador = Treinamento(db_param, contexto=self, interval_hours=interval_hours)
+        return self._treinador
+
+    def _load_model(self):
+        """Carrega o modelo SentenceTransformer e embeddings sob demanda."""
+        if self.model is not None:
+            return
+        
+        if not SENTENCE_TRANSFORMER_AVAILABLE:
+            logger.warning("SentenceTransformer não disponível")
+            return
+        
+        start_time = time.time()
+        
+        try:
+            self.model = SentenceTransformer('all-MiniLM-L6-v2')
+            logger.info("Modelo SentenceTransformer carregado com sucesso")
+        except Exception as e:
+            logger.error(f"Erro ao carregar modelo: {e}")
+            self.model = None
+            
+        self._check_embeddings()
+        duration = time.time() - start_time
+        logger.info(f"Modelo carregado em {duration:.2f}s")
+
+    def _check_embeddings(self):
+        """Verifica ou cria embeddings no banco de dados."""
+        if self.model and not self.embeddings:
+            try:
+                self.embeddings = {"conhecimento_base": "placeholder_embedding_data"}
+            except Exception as e:
+                logger.warning(f"Não foi possível carregar embeddings: {e}")
+
+    def analisar_emocoes_mensagem(self, mensagem: str) -> Dict[str, Any]:
+        """
+        Analisa o sentimento e emoção da mensagem (Heurística simples).
+        
+        Args:
+            mensagem: Texto da mensagem para análise
+            
+        Returns:
+            Dicionário com análise emocional
+        """
+        mensagem_lower = mensagem.strip().lower()
+
+        # Análise de Sentimento
+        pos_count = sum(mensagem_lower.count(w) for w in PALAVRAS_POSITIVAS)
+        neg_count = sum(mensagem_lower.count(w) for w in PALAVRAS_NEGATIVAS)
+        
+        sentimento = "neutro"
+        if pos_count > neg_count:
+            sentimento = "positivo"
+        elif neg_count > pos_count:
+            sentimento = "negativo"
+            
+        # Determinar Emoção Predominante
+        if sentimento == "positivo":
+            emocao_predominante = "alegria"
+        elif sentimento == "negativo":
+            emocao_predominante = "frustração"
+        else:
+            emocao_predominante = "neutra"
+            
+        # Atualiza o estado
+        self.emocao_atual = emocao_predominante
+            
+        return {
+            "sentimento_detectado": sentimento,
+            "emocao_predominante": emocao_predominante,
+            "intensidade_positiva": pos_count,
+            "intensidade_negativa": neg_count,
+            "tom_sugerido": "casual" if sentimento != "neutro" else "neutro"
+        }
+    
+    def analisar_intencao_e_normalizar(
+        self, 
+        mensagem: str, 
+        historico: List[Tuple[str, str]]
+    ) -> Dict[str, Any]:
+        """
+        Analisa a intenção, normaliza a mensagem e detecta sentimentos/estilo.
+        
+        Args:
+            mensagem: Mensagem do usuário
+            historico: Histórico de conversas
+            
+        Returns:
+            Dicionário com análise completa
+        """
+        self._load_model()
+        
+        if not isinstance(mensagem, str):
+            mensagem = str(mensagem)
+        mensagem_lower = mensagem.strip().lower()
+
+        # 1. Análise de Intenção
+        intencao = "pergunta"
+        if '?' not in mensagem_lower and ('porquê' not in mensagem_lower or 'porque' not in mensagem_lower):
+            intencao = "afirmacao"
+        if any(w in mensagem_lower for w in ['ola', 'oi', 'bom dia', 'boa tarde', 'boa noite', 'como vai']):
+            intencao = "saudacao"
+        if any(w in mensagem_lower for w in ['tchau', 'ate mais', 'adeus', 'fim', 'parar']):
+            intencao = "despedida"
+        
+        # 2. Análise de Sentimento/Emoção
+        try:
+            emotion_analyzer = _get_emotion_analyzer()  # type: ignore[call-overload]
+            nlp_config = getattr(config, 'NLP_CONFIG', None)
+            nivel = getattr(nlp_config, 'level', 'advanced') if nlp_config else 'advanced'
+            
+            # Converte histórico para formato esperado
+            historico_dict: List[Dict[str, str]] = []
+            for h in historico:
+                if isinstance(h, tuple) and len(h) >= 2:
+                    historico_dict.append({"mensagem": h[0], "resposta": h[1]})
+            
+            # Verificação robusta para evitar "Object of type None has no attribute"
+            if hasattr(emotion_analyzer, 'analisar'):
+                analise_emocional = emotion_analyzer.analisar(
+                    mensagem_lower, 
+                    historico=historico_dict, 
+                    nivel=nivel
+                )
+                self.emocao_atual = analise_emocional.get('emocao', 'neutra')
+            else:
+                raise ValueError("EmotionAnalyzer não possui o método analisar")
+            
+        except Exception as e:
+            logger.warning(f"EmotionAnalyzer falhou, usando fallback heurístico: {e}")
+            analise_emocional = self.analisar_emocoes_mensagem(mensagem_lower)
+            
+        # 3. Análise de Estilo
+        estilo = "informal"
+        if len(re.findall(r'[A-ZÀ-Ÿ]{3,}', mensagem)) >= 2 or re.search(r'\b(Senhor|Doutor|Atenciosamente)\b', mensagem, re.IGNORECASE):
+            estilo = "formal"
+            
+        # 4. Outras bandeiras
+        ironia = False
+        meia_frase = False 
+        usar_nome = random.random() < getattr(config, 'USAR_NOME_PROBABILIDADE', 0.7)
+
+        return {
+            "texto_normalizado": mensagem_lower,
+            "intencao": intencao,
+            "sentimento": analise_emocional.get('sentimento_detectado', 
+                         analise_emocional.get('emocao', 'neutral')),
+            "estilo": estilo,
+            "contexto_ajustado": self.substituir_termos_aprendidos(mensagem_lower),
+            "ironia": ironia,
+            "meia_frase": meia_frase,
+            "usar_nome": usar_nome,
+            "emocao": self.emocao_atual,
+            "confianca_emocao": analise_emocional.get('confianca', 0.5),
+            "nivel_analise": analise_emocional.get('nivel_analise', 'heuristica')
+        }
+
+    def obter_historico(self, limite: int = 5) -> List[Tuple[str, str]]:
+        """
+        Recupera o histórico de mensagens do banco de dados.
+        
+        Args:
+            limite: Número máximo de mensagens a recuperar
+            
+        Returns:
+            Lista de tuplas (mensagem, resposta)
+        """
+        if not self.usuario:
+            return []
+            
+        if self.db is None:
+            return []
+            
+        try:
+            # 🔥 CONTEXT ISOLATION: Usa conversation_id se disponível
+            raw_result = self.db.recuperar_historico(
+                self.usuario, 
+                limite=limite,
+                conversation_id=self.conversation_id
+            )
+            return raw_result if raw_result else []
+        except Exception as e:
+            # Fallback para o método antigo
+            try:
+                raw_result = self.db.recuperar_mensagens(self.usuario, limite=limite)
+                return raw_result if raw_result else []
+            except Exception as e2:
+                logger.warning(f"Erro ao recuperar histórico: {e2}")
+                return []
+
+    def obter_historico_expandido(self, limite: int = 30) -> List[Tuple[str, str]]:
+        """
+        Recupera histórico expandido (últimas 30 mensagens) para contexto completo.
+        
+        Args:
+            limite: Número máximo de mensagens (padrão 30)
+            
+        Returns:
+            Lista de tuplas (mensagem, resposta)
+        """
+        return self.obter_historico(limite=limite)
+
+    def criar_resumo_topicos_conversa(self, historico: List[Tuple[str, str]]) -> Dict[str, Any]:
+        """
+        Cria resumo inteligente de tópicos da conversa em tempo real.
+        """
+        if not historico:
+            return {"topicos": [], "resumo": "Conversa vazia"}
+        
+        topicos_detectados = []
+        mensagens_concat = " ".join([msg for msg, _ in historico]).lower()
+        
+        categorias = {
+            "tecnologia": ["computador", "programa", "código", "app", "site", "internet", "ai", "bot"],
+            "pessoal": ["eu", "minha", "meu", "vida", "família", "amigo", "trabalho"],
+            "entretenimento": ["música", "filme", "jogo", "esporte", "notícia", "youtube"],
+            "ajuda": ["ajuda", "como", "explicar", "ensinar", "dúvida", "problema"],
+            "conversa": ["oi", "ola", "bom", "tudo", "bem", "como vai"]
+        }
+        
+        for categoria, palavras in categorias.items():
+            if any(palavra in mensagens_concat for palavra in palavras):
+                topicos_detectados.append(categoria)
+        
+        num_mensagens = len(historico)
+        resumo = f"Conversa com {num_mensagens} mensagens sobre: {', '.join(topicos_detectados[:3])}"
+        
+        return {
+            "topicos": topicos_detectados,
+            "resumo": resumo,
+            "num_mensagens": num_mensagens,
+            "timestamp": datetime.now().isoformat(),
+            "nota": "ESTE RESUMO É APENAS PARA CONTEXTO INTERNO DA API - NÃO INCLUIR NAS RESPOSTAS!"
+        }
+
+    def processar_contexto_reply(
+        self,
+        mensagem: str,
+        reply_metadata: Dict[str, Any],
+        historico_geral: List[Tuple[str, str]]
+    ) -> Dict[str, Any]:
+        """
+        Processa contexto específico de reply, mantendo histórico geral.
+        """
+        contexto_reply = {
+            "is_reply": reply_metadata.get('is_reply', False),
+            "reply_to_bot": reply_metadata.get('reply_to_bot', False),
+            "quoted_author": reply_metadata.get('quoted_author_name', ''),
+            "quoted_text": reply_metadata.get('quoted_text_original', ''),
+            "context_hint": reply_metadata.get('context_hint', ''),
+            "historico_geral": historico_geral,
+            "resumo_topicos": self.criar_resumo_topicos_conversa(historico_geral)
+        }
+
+        if contexto_reply["is_reply"]:
+            quoted_content = self._extract_full_quoted_content(reply_metadata)
+            contexto_reply["quoted_content_full"] = quoted_content
+
+            content_analysis = self._analyze_quoted_content_for_reply(quoted_content, mensagem)
+            contexto_reply["content_analysis"] = content_analysis
+
+            related_context = self._find_related_context_in_history(quoted_content, historico_geral)
+            contexto_reply["related_context"] = related_context
+
+            reply_priority = self._calculate_reply_priority(
+                reply_metadata,
+                quoted_content,
+                mensagem
+            )
+            contexto_reply["reply_priority"] = reply_priority
+
+            topics = self._extract_topics_from_quoted_content(quoted_content)
+            contexto_reply["topics_identified"] = topics
+
+        return contexto_reply
+
+    def _extract_full_quoted_content(self, reply_metadata: Dict[str, Any]) -> str:
+        fields_to_check = [
+            'mensagem_citada', 'quoted_text_original', 'quoted_text', 'reply_content', 'full_message'
+        ]
+        
+        for field in fields_to_check:
+            if field in reply_metadata and reply_metadata[field]:
+                content = str(reply_metadata[field]).strip()
+                if len(content) > 5:
+                    return content
+        
+        for key, value in reply_metadata.items():
+            if isinstance(value, str) and len(value) > 10:
+                if any(word in value.lower() for word in ['eu', 'você', 'tu', 'mim', 'nosso', 'teu']):
+                    return value.strip()
+        
+        return ""
+
+    def _analyze_quoted_content_for_reply(self, quoted_content: str, current_message: str) -> Dict[str, Any]:
+        if not quoted_content:
+            return {"empty": True}
+        
+        quoted_lower = quoted_content.lower()
+        
+        content_type = "general"
+        if any(w in quoted_lower for w in ['?', 'qual', 'quando', 'onde', 'como', 'por que']):
+            content_type = "question"
+        elif any(w in quoted_lower for w in ['eu', 'mim', 'meu', 'minha', 'eu sou']):
+            content_type = "personal"
+        elif any(w in quoted_lower for w in ['akira', 'bot', 'você', 'vc']):
+            content_type = "about_bot"
+        
+        keywords = []
+        keyword_mapping = {
+            "tempo": ["tempo", "clima", "chover", "sol", "temperatura"],
+            "musica": ["música", "musica", "youtube", "yt"],
+            "traducao": ["traduz", "letra", "ingles", "english", "tradução"],
+            "pesquisa": ["pesquisa", "web", "google", "busca", "buscar"],
+            "emocao": ["triste", "feliz", "raiva", "amor", "medo", "alegria"],
+        }
+        
+        for category, words in keyword_mapping.items():
+            if any(w in quoted_lower for w in words):
+                keywords.append(category)
+        
+        tone = "neutral"
+        if any(w in quoted_lower for w in ['kkk', 'haha', '😂', '🤣']):
+            tone = "humorous"
+        elif any(w in quoted_lower for w in ['!!!', '???', 'nossa', 'eita']):
+            tone = "excited"
+        elif any(w in quoted_lower for w in ['.', '..', '...']):
+            tone = "thoughtful"
+        
+        return {
+            "content_type": content_type,
+            "keywords": keywords,
+            "tone": tone,
+            "length": len(quoted_content),
+            "has_question": '?' in quoted_content,
+            "is_about_bot": "about_bot" in keywords,
+            "has_emotion_keywords": len([k for k in keywords if k == "emocao"]) > 0
+        }
+
+    def _find_related_context_in_history(self, quoted_content: str, historico: List[Tuple[str, str]]) -> List[Dict[str, Any]]:
+        if not quoted_content or not historico:
+            return []
+        
+        related_contexts = []
+        quoted_words = set(quoted_content.lower().split())
+        
+        for i, (msg_user, msg_bot) in enumerate(historico):
+            if not msg_user or not msg_bot:
+                continue
+            
+            msg_words = set((msg_user + " " + msg_bot).lower().split())
+            intersection = quoted_words.intersection(msg_words)
+            
+            if intersection:
+                similarity = len(intersection) / len(quoted_words.union(msg_words))
+                if similarity > 0.1:
+                    related_contexts.append({
+                        "index": i,
+                        "similarity": round(similarity, 3),
+                        "user_message": msg_user[:100] if len(msg_user) > 100 else msg_user,
+                        "bot_response": msg_bot[:100] if len(msg_bot) > 100 else msg_bot,
+                        "common_words": list(intersection)[:5]
+                    })
+        
+        related_contexts.sort(key=lambda x: x["similarity"], reverse=True)
+        return related_contexts[:5]
+
+    def _calculate_reply_priority(self, reply_metadata: Dict[str, Any], quoted_content: str, current_message: str) -> Dict[str, Any]:
+        priority = 1
+        priority_type = "normal"
+        should_prioritize = False
+        
+        is_reply_to_bot = reply_metadata.get('reply_to_bot', False)
+        current_words = current_message.split()
+        is_short_question = (
+            len(current_words) <= 5 and 
+            any(w in current_message.lower() for w in ['?', 'qual', 'quando', 'onde', 'como', 'oq'])
+        )
+        has_quoted_content = len(quoted_content) > 10
+        
+        if is_reply_to_bot and is_short_question:
+            priority = 4
+            priority_type = "critical_short_question"
+            should_prioritize = True
+        elif is_reply_to_bot:
+            priority = 3
+            priority_type = "reply_to_bot"
+            should_prioritize = True
+        elif is_short_question:
+            priority = 2
+            priority_type = "short_question"
+            should_prioritize = True
+        elif has_quoted_content:
+            priority = 1.5
+            priority_type = "has_content"
+        
+        return {
+            "priority": priority,
+            "type": priority_type,
+            "should_prioritize": should_prioritize,
+            "is_reply_to_bot": is_reply_to_bot,
+            "is_short_question": is_short_question,
+            "has_quoted_content": has_quoted_content,
+            "multiplier": min(priority / 2, 1.0)
+        }
+
+    def _extract_topics_from_quoted_content(self, quoted_content: str) -> List[str]:
+        if not quoted_content:
+            return []
+        
+        topics = []
+        quoted_lower = quoted_content.lower()
+        
+        topic_keywords = {
+            "tempo_clima": ["tempo", "clima", "chover", "sol", "chuva", "temperatura"],
+            "musica": ["música", "musica", "youtube", "yt", "cantor", "link"],
+            "traducao": ["traduz", "letra", "ingles", "english", "português", "significado"],
+            "pesquisa": ["pesquisa", "web", "google", "busca", "buscar", "encontrar"],
+            "emocoes": ["triste", "feliz", "raiva", "amor", "medo", "alegria", "sentimento"],
+            "tecnologia": ["programa", "código", "app", "site", "internet", "bot", "akira"]
+        }
+        
+        for topic, keywords in topic_keywords.items():
+            if any(kw in quoted_lower for kw in keywords):
+                topics.append(topic)
+        
+        if not topics:
+            topics.append("general")
+        
+        return topics
+
+    def atualizar_contexto(
+        self, 
+        mensagem: str, 
+        resposta: str, 
+        numero: Optional[str] = None
+    ):
+        """
+        Salva a interação no banco e aciona aprendizado de termos.
+        
+        Args:
+            mensagem: Mensagem do usuário
+            resposta: Resposta gerada
+            numero: Número de telefone
+        """
+        if not self.usuario:
+            usuario = 'anonimo'
+        else:
+            usuario = self.usuario
+            
+        final_numero = numero if numero else self.usuario
+        
+        try:
+            if self.db is not None:
+                self.db.salvar_mensagem(usuario, mensagem, resposta, numero=final_numero)
+            
+            historico = self.obter_historico(limite=10)
+            self.aprender_do_historico(mensagem, resposta, historico) 
+            
+            if final_numero:
+                self.salvar_estado_contexto_no_db(final_numero)
+
+        except Exception as e:
+            logger.warning(f'Falha ao salvar mensagem no DB: {e}')
+
+    def salvar_estado_contexto_no_db(self, user_key: str):
+        """
+        Persiste o estado atual da classe Contexto no banco de dados.
+        
+        Args:
+            user_key: Chave do usuário
+        """
+        if self.db is None:
+            return
+            
+        termos_json = json.dumps(self.termo_contexto)
+        emocao_str = self.emocao_atual
+        
+        try:
+            self.db.salvar_aprendizado_detalhado(user_key, "emocao_atual", json.dumps({"emocao": emocao_str}))
+            
+            self.db.salvar_contexto(
+                user_key=user_key,
+                historico="[]", 
+                emocao_atual=emocao_str,
+                termos=termos_json,
+                girias=termos_json,
+                tom=emocao_str 
+            )
+            logger.debug(f"Contexto do usuário {user_key} salvo no DB.")
+        except Exception as e:
+            logger.error(f"Falha ao salvar estado do contexto no DB: {e}")
+
+    def aprender_do_historico(
+        self, 
+        mensagem: str, 
+        resposta: str, 
+        historico: List[Tuple[str, str]]
+    ):
+        """
+        Aprende termos do histórico de conversas.
+        
+        Args:
+            mensagem: Mensagem do usuário
+            resposta: Resposta gerada
+            historico: Histórico de conversas
+        """
+        if not self.usuario:
+            return
+            
+        if self.db is None:
+            return
+
+        mensagem_lower = mensagem.lower()
+        
+        # Gírias angolanas comuns
+        girias_angolanas = ['ya', 'bué', 'fixe', 'puto', 'kapa', 'muxima', 'kalai']
+        
+        for giria in girias_angolanas:
+            if giria in mensagem_lower:
+                try:
+                    significado_placeholder = f'termo regional para {giria}'
+                    
+                    self.db.salvar_giria_aprendida(
+                        self.usuario,
+                        giria, 
+                        significado_placeholder,
+                        mensagem[:50]
+                    )
+                    
+                    freq_atual = self.termo_contexto.get(giria, {}).get("frequencia", 0)
+                    self.termo_contexto[giria] = {
+                        "significado": significado_placeholder, 
+                        "frequencia": freq_atual + 1
+                    }
+                    
+                except Exception as e:
+                    logger.warning(f"Erro ao salvar gíria no DB: {e}")
+    
+    def substituir_termos_aprendidos(self, mensagem: str) -> str:
+        """
+        Substitui termos aprendidos na mensagem.
+        
+        Args:
+            mensagem: Mensagem original
+            
+        Returns:
+            Mensagem com termos substituídos
+        """
+        for termo, info in self.termo_contexto.items():
+            if isinstance(info, dict) and "significado" in info:
+                # Substitui apenas a palavra inteira (case insensitive)
+                mensagem = re.sub(
+                    r'\b' + re.escape(termo) + r'\b', 
+                    info["significado"], 
+                    mensagem, 
+                    flags=re.IGNORECASE
+                )
+        return mensagem
+        
+    def obter_aprendizado_detalhado(self, chave: str) -> Optional[Dict[str, Any]]:
+        """
+        Recupera aprendizados detalhados do usuário.
+        
+        Args:
+            chave: Chave do aprendizado
+            
+        Returns:
+            Dicionário com o aprendizado ou None
+        """
+        if not self.usuario:
+            return None
+        if self.db is None:
+            return None
+        try:
+            raw_data = self.db.recuperar_aprendizado_detalhado(self.usuario, chave)
+            if raw_data:
+                if isinstance(raw_data, str):
+                    return json.loads(raw_data)
+                return raw_data
+            return None
+        except Exception as e:
+            logger.warning(f"Erro ao obter aprendizado detalhado: {e}")
+            return None
+            
+    def obter_emocao_atual(self) -> str:
+        """Recupera a emoção atual do usuário."""
+        return self.emocao_atual
+
+    def ativar_espirito_critico(self):
+        """Ativa o espírito crítico para respostas questionadoras."""
+        self.espirito_critico = True
+
+    def obter_aprendizados(self) -> Dict[str, Any]:
+        """
+        Retorna os aprendizados do usuário.
+        
+        Returns:
+            Dicionário com termos, emoção e tom
+        """
+        aprendizados = {
+            "termos": self.termo_contexto,
+            "emocao_preferida": self.emocao_atual,
+            "ton_predominante": self.ton_predominante
+        }
+        return aprendizados
+
+    def salvar_conhecimento_base(self, chave: str, valor: Any):
+        """Salva uma informação na base de conhecimento."""
+        self.base_conhecimento[chave] = valor
+
+    def obter_conhecimento_base(self, chave: str) -> Optional[Any]:
+        """Obtém uma informação da base de conhecimento."""
+        return self.base_conhecimento.get(chave)
+
+    def obter_historico_para_llm(self) -> List[Dict[str, str]]:
+        """
+        Retorna o histórico no formato esperado pelos LLMs.
+        
+        Returns:
+            Lista de dicionários com role e content
+        """
+        historico = self.obter_historico()
+        if historico and len(historico) > 0:
+            return [
+                {"role": "user", "content": h[0]} if isinstance(h, tuple) and len(h) >= 2 else h
+                for h in historico
+            ]
+        return []
+
+
+# ================================================================
+# FUNÇÕES AUXILIARES (para compatibilidade com testar_correcoes.py)
+# ================================================================
+
+def criar_contexto(db: Optional[Database], identificador: str) -> Contexto:
+    """
+    Factory function para criar contexto.
+    
+    Args:
+        db: Instância do banco de dados
+        identificador: Identificador do usuário
+        
+    Returns:
+        Instância de Contexto
+    """
+    return Contexto(db=db, usuario=identificador)
+
+
+# Funções auxiliares para config.py
+def eh_usuario_privilegiado(numero: str) -> bool:
+    """
+    Verifica se um número é de usuário privilegiado.
+    
+    Args:
+        numero: Número de telefone
+        
+    Returns:
+        True se for privilegiado
+    """
+    try:
+        from .database import Database
+        db = Database()
+        return db.eh_privilegiado(numero)
+    except Exception as e:
+        logger.error(f"Erro ao verificar privilégios: {e}")
+        return False
+
+
+def forcar_modo_inicial_privilegiado(numero: str) -> str:
+    """
+    Retorna o modo de fala forçado para usuário privilegiado.
+    
+    Args:
+        numero: Número de telefone
+        
+    Returns:
+        Modo de fala
+    """
+    try:
+        from .database import Database
+        db = Database()
+        modo = db.obter_modo_fala_privilegiado(numero)
+        return modo if modo else "tecnico_formal"
+    except Exception as e:
+        logger.error(f"Erro ao obter modo de fala: {e}")
+        return "tecnico_formal"
+
+
+def analisar_tom_usuario(mensagem: str) -> str:
+    """
+    Analisa o tom de uma mensagem.
+    
+    Args:
+        mensagem: Texto da mensagem
+        
+    Returns:
+        Tom detectado
+    """
+    contexto = Contexto(db=None, usuario=None)
+    analise = contexto.analisar_emocoes_mensagem(mensagem)
+    return analise.get("tom_sugerido", "neutro")
+
+
+def determinar_nivel_transicao(
+    numero: str, 
+    tom: str, 
+    nivel_atual: int
+) -> int:
+    """
+    Determina o nível de transição baseado no tom.
+    Usa transição LENTA e gradual conforme configurações do config.
+    
+    Args:
+        numero: Número do usuário
+        tom: Tom detectado
+        nivel_atual: Nível atual
+        
+    Returns:
+        Novo nível de transição (mudança muito gradual)
+    """
+    # threshold configurado no config.py (atual: 0.9)
+    threshold = getattr(config, 'TRANSICAO_HUMOR_THRESHOLD', 0.9)
+    nivel_max = getattr(config, 'NIVEL_TRANSICAO_MAX', 1)
+    
+    # Com threshold de 0.9, só muda se tiver 90% de certeza
+    # Com nivel_max = 1, só pode mudar 1 nível por vez (muito lento)
+    
+    if tom in ["formal", "tecnico_formal"]:
+        return min(nivel_atual + 1, nivel_max)
+    elif tom in ["casual", "informal"]:
+        return max(nivel_atual - 1, 1)
+    return nivel_atual
+

modules/database.py

@@ -1,1112 +1,853 @@
-# modules/database.py — AKIRA V21 FINAL CORRIGIDO (Dezembro 2025) - CORREÇÃO: Com suporte a nivel_transicao, desc_transicao e usuario_privilegiado
-"""
-✅ TOTALMENTE ADAPTADO ao index.js atualizado
-✅ CORREÇÃO: Problema com message_id UNIQUE resolvido
-✅ CORREÇÃO: Suporte para nivel_transicao, desc_transicao e usuario_privilegiado adicionado
-✅ Métodos corretos para api.py, contexto.py, treinamento.py
-✅ Estrutura completa com reply_metadata
-✅ Todos os métodos necessários implementados
-"""
-
-import sqlite3
-import time
-import os
-import json
-import hashlib
-import random
-from datetime import datetime
-from typing import Optional, List, Dict, Any, Tuple
-from loguru import logger
-
-class Database:
-    def __init__(self, db_path: str = "akira.db"):
-        self.db_path = db_path
-        self.max_retries = 5
-        self.retry_delay = 0.1
-        
-        db_dir = os.path.dirname(self.db_path)
-        if db_dir:
-            os.makedirs(db_dir, exist_ok=True)
-        
-        self._init_db()
-        self._ensure_columns()
-        logger.info(f"✅ Database inicializado: {self.db_path}")
-
-    def _get_connection(self) -> sqlite3.Connection:
-        conn = sqlite3.connect(self.db_path, timeout=30.0, check_same_thread=False)
-        conn.execute('PRAGMA journal_mode=WAL')
-        conn.execute('PRAGMA synchronous=NORMAL')
-        conn.execute('PRAGMA cache_size=2000')
-        return conn
-
-    def _execute_with_retry(self, query: str, params: Optional[tuple] = None,
-                           commit: bool = False, fetch: bool = True):
-        for attempt in range(self.max_retries):
-            try:
-                with self._get_connection() as conn:
-                    c = conn.cursor()
-                    if params:
-                        c.execute(query, params)
-                    else:
-                        c.execute(query)
-                    
-                    if commit:
-                        conn.commit()
-                    
-                    if fetch and query.strip().upper().startswith('SELECT'):
-                        return c.fetchall()
-                    elif fetch:
-                        return c.fetchall() if c.description else []
-                    else:
-                        return c.lastrowid
-            except sqlite3.OperationalError as e:
-                if "database is locked" in str(e) and attempt < self.max_retries - 1:
-                    time.sleep(self.retry_delay * (2 ** attempt))
-                    continue
-                logger.error(f"Erro SQL: {e}")
-                raise
-            except Exception as e:
-                logger.error(f"Erro na query: {e}")
-                raise
-
-    def _init_db(self):
-        """Cria todas as tabelas necessárias - CORREÇÃO: message_id sem UNIQUE"""
-        try:
-            with self._get_connection() as conn:
-                c = conn.cursor()
-                
-                # Tabela principal de mensagens - CORREÇÃO: message_id sem UNIQUE
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS mensagens (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        usuario TEXT NOT NULL,
-                        usuario_nome TEXT DEFAULT '',
-                        numero TEXT NOT NULL,
-                        mensagem TEXT NOT NULL,
-                        resposta TEXT NOT NULL,
-                        contexto_id TEXT NOT NULL,
-                        tipo_contexto TEXT DEFAULT 'pv',
-                        tipo_conversa TEXT DEFAULT 'pv',
-                        tipo_mensagem TEXT DEFAULT 'texto',
-                        
-                        -- Reply info
-                        is_reply BOOLEAN DEFAULT 0,
-                        mensagem_original TEXT,
-                        mensagem_citada_limpa TEXT,
-                        reply_to_bot BOOLEAN DEFAULT 0,
-                        reply_info_json TEXT,
-                        
-                        -- Estado
-                        humor TEXT DEFAULT 'normal_ironico',
-                        modo_resposta TEXT DEFAULT 'normal_ironico',
-                        emocao_detectada TEXT,
-                        confianca_emocao REAL DEFAULT 0.5,
-                        
-                        -- Transição
-                        nivel_transicao INTEGER DEFAULT 0,
-                        info_transicao_json TEXT,
-                        usuario_privilegiado BOOLEAN DEFAULT 0,
-                        
-                        -- Grupo
-                        grupo_id TEXT DEFAULT '',
-                        grupo_nome TEXT DEFAULT '',
-                        
-                        -- Audio
-                        audio_transcricao TEXT,
-                        fonte_stt TEXT DEFAULT 'deepgram',
-                        confianca_stt REAL DEFAULT 0.0,
-                        
-                        -- Meta
-                        comando_executado TEXT,
-                        has_media BOOLEAN DEFAULT 0,
-                        media_type TEXT DEFAULT '',
-                        message_id TEXT,
-                        bot_response_time_ms INTEGER DEFAULT 0,
-                        is_mention BOOLEAN DEFAULT 0,
-                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-                        deletado BOOLEAN DEFAULT 0
-                    )
-                ''')
-                
-                # Índice para message_id para performance (sem UNIQUE)
-                c.execute('''
-                    CREATE INDEX IF NOT EXISTS idx_mensagens_message_id 
-                    ON mensagens(message_id)
-                ''')
-                
-                # Índice para busca por número
-                c.execute('''
-                    CREATE INDEX IF NOT EXISTS idx_mensagens_numero 
-                    ON mensagens(numero)
-                ''')
-                
-                # Índice para usuario_privilegiado
-                c.execute('''
-                    CREATE INDEX IF NOT EXISTS idx_mensagens_usuario_privilegiado 
-                    ON mensagens(usuario_privilegiado)
-                ''')
-                
-                # Usuários privilegiados
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS usuarios_privilegiados (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero TEXT UNIQUE NOT NULL,
-                        nome TEXT NOT NULL,
-                        nome_curto TEXT,
-                        tom_inicial TEXT DEFAULT 'formal',
-                        pode_dar_ordens BOOLEAN DEFAULT 0,
-                        pode_usar_reset BOOLEAN DEFAULT 0,
-                        pode_forcar_modo BOOLEAN DEFAULT 0,
-                        pode_apagar_mensagens BOOLEAN DEFAULT 0,
-                        pode_moderar_grupos BOOLEAN DEFAULT 0,
-                        nivel_acesso TEXT DEFAULT 'vip',
-                        ultimo_comando TEXT,
-                        timestamp_comando DATETIME,
-                        comandos_executados INTEGER DEFAULT 0,
-                        comandos_falhos INTEGER DEFAULT 0,
-                        config_personalizada TEXT DEFAULT '{}',
-                        data_criacao DATETIME DEFAULT CURRENT_TIMESTAMP,
-                        data_atualizacao DATETIME DEFAULT CURRENT_TIMESTAMP
-                    )
-                ''')
-                
-                # Contexto
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS contexto (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero TEXT UNIQUE NOT NULL,
-                        contexto_id TEXT NOT NULL,
-                        tipo_contexto TEXT DEFAULT 'pv',
-                        historico TEXT,
-                        humor_atual TEXT DEFAULT 'normal_ironico',
-                        modo_resposta TEXT DEFAULT 'normal_ironico',
-                        nivel_transicao INTEGER DEFAULT 0,
-                        info_transicao_json TEXT,
-                        usuario_privilegiado BOOLEAN DEFAULT 0,
-                        humor_alvo TEXT DEFAULT 'normal_ironico',
-                        termos TEXT,
-                        girias TEXT,
-                        tom TEXT DEFAULT 'normal',
-                        emocao_tendencia TEXT DEFAULT 'neutral',
-                        volatilidade REAL DEFAULT 0.5,
-                        nome_usuario TEXT DEFAULT '',
-                        ultima_mensagem_audio BOOLEAN DEFAULT 0,
-                        frequencia_audio INTEGER DEFAULT 0,
-                        prefere_audio BOOLEAN DEFAULT 0,
-                        nivel_confianca_stt REAL DEFAULT 0.0,
-                        configuracao_reply TEXT DEFAULT '{}',
-                        estatisticas_interacao TEXT DEFAULT '{}',
-                        ultimo_contato DATETIME,
-                        data_criacao DATETIME DEFAULT CURRENT_TIMESTAMP,
-                        data_atualizacao DATETIME DEFAULT CURRENT_TIMESTAMP
-                    )
-                ''')
-                
-                # Training examples
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS training_examples (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        input_text TEXT NOT NULL,
-                        output_text TEXT NOT NULL,
-                        humor TEXT DEFAULT 'normal_ironico',
-                        modo_resposta TEXT DEFAULT 'normal_ironico',
-                        nivel_transicao INTEGER DEFAULT 0,
-                        usuario_privilegiado BOOLEAN DEFAULT 0,
-                        emocao_contexto TEXT,
-                        contexto_super_claro TEXT,
-                        tipo_interacao TEXT DEFAULT 'normal',
-                        score_relevancia REAL DEFAULT 1.0,
-                        tags TEXT DEFAULT '',
-                        qualidade_score REAL DEFAULT 1.0,
-                        usado BOOLEAN DEFAULT 0,
-                        usado_para_finetuning BOOLEAN DEFAULT 0,
-                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
-                    )
-                ''')
-                
-                # Transições de humor
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS transicoes_humor (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero TEXT NOT NULL,
-                        contexto_id TEXT NOT NULL,
-                        humor_anterior TEXT NOT NULL,
-                        humor_novo TEXT NOT NULL,
-                        nivel_transicao_anterior INTEGER DEFAULT 0,
-                        nivel_transicao_novo INTEGER DEFAULT 0,
-                        usuario_privilegiado BOOLEAN DEFAULT 0,
-                        emocao_trigger TEXT,
-                        confianca_emocao REAL,
-                        razao TEXT,
-                        intensidade REAL DEFAULT 0.5,
-                        contexto_mensagem TEXT,
-                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
-                    )
-                ''')
-                
-                # Gírias
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS girias_aprendidas (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero TEXT NOT NULL,
-                        contexto_id TEXT NOT NULL,
-                        giria TEXT NOT NULL,
-                        significado TEXT NOT NULL,
-                        contexto TEXT,
-                        frequencia INTEGER DEFAULT 1,
-                        ultimo_uso DATETIME DEFAULT CURRENT_TIMESTAMP,
-                        data_criacao DATETIME DEFAULT CURRENT_TIMESTAMP,
-                        UNIQUE(numero, giria)
-                    )
-                ''')
-                
-                # Comandos executados
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS comandos_executados (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero TEXT NOT NULL,
-                        comando TEXT NOT NULL,
-                        parametros TEXT,
-                        sucesso BOOLEAN DEFAULT 1,
-                        resposta TEXT,
-                        tipo_conversa TEXT DEFAULT 'pv',
-                        grupo_id TEXT DEFAULT '',
-                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
-                    )
-                ''')
-                
-                # Reset log
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS reset_log (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero TEXT NOT NULL,
-                        tipo_reset TEXT NOT NULL,
-                        itens_apagados INTEGER DEFAULT 0,
-                        motivo TEXT,
-                        sucesso BOOLEAN DEFAULT 1,
-                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
-                    )
-                ''')
-                
-                # Interações (para treinamento)
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS interacoes (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero TEXT NOT NULL,
-                        mensagem TEXT NOT NULL,
-                        resposta TEXT NOT NULL,
-                        humor TEXT DEFAULT 'normal_ironico',
-                        modo_resposta TEXT DEFAULT 'normal_ironico',
-                        nivel_transicao INTEGER DEFAULT 0,
-                        usuario_privilegiado BOOLEAN DEFAULT 0,
-                        emocao_detectada TEXT,
-                        tipo_conversa TEXT DEFAULT 'pv',
-                        reply_info_json TEXT,
-                        qualidade_score REAL DEFAULT 1.0,
-                        data_criacao DATETIME DEFAULT CURRENT_TIMESTAMP
-                    )
-                ''')
-                
-                conn.commit()
-                logger.info("✅ Tabelas criadas/verificadas com suporte a nivel_transicao e usuario_privilegiado")
-                
-        except Exception as e:
-            logger.error(f"❌ Erro ao criar tabelas: {e}")
-            raise
-
-    def _ensure_columns(self):
-        """Garante que todas as colunas existam"""
-        try:
-            with self._get_connection() as conn:
-                c = conn.cursor()
-                
-                # Colunas para mensagens
-                novas_colunas = [
-                    ("tipo_mensagem", "TEXT DEFAULT 'texto'"),
-                    ("reply_info_json", "TEXT"),
-                    ("usuario_nome", "TEXT DEFAULT ''"),
-                    ("grupo_id", "TEXT DEFAULT ''"),
-                    ("grupo_nome", "TEXT DEFAULT ''"),
-                    ("audio_transcricao", "TEXT"),
-                    ("fonte_stt", "TEXT DEFAULT 'deepgram'"),
-                    ("confianca_stt", "REAL DEFAULT 0.0"),
-                    ("comando_executado", "TEXT"),
-                    ("tipo_conversa", "TEXT DEFAULT 'pv'"),
-                    ("is_mention", "BOOLEAN DEFAULT 0"),
-                    ("has_media", "BOOLEAN DEFAULT 0"),
-                    ("media_type", "TEXT DEFAULT ''"),
-                    ("message_id", "TEXT"),
-                    ("bot_response_time_ms", "INTEGER DEFAULT 0"),
-                    ("nivel_transicao", "INTEGER DEFAULT 0"),
-                    ("info_transicao_json", "TEXT"),
-                    ("usuario_privilegiado", "BOOLEAN DEFAULT 0")
-                ]
-                
-                for col_name, col_def in novas_colunas:
-                    try:
-                        c.execute(f"ALTER TABLE mensagens ADD COLUMN {col_name} {col_def}")
-                    except sqlite3.OperationalError:
-                        pass
-                
-                # Colunas para contexto
-                contexto_colunas = [
-                    ("info_transicao_json", "TEXT"),
-                    ("nivel_transicao", "INTEGER DEFAULT 0"),
-                    ("usuario_privilegiado", "BOOLEAN DEFAULT 0")
-                ]
-                
-                for col_name, col_def in contexto_colunas:
-                    try:
-                        c.execute(f"ALTER TABLE contexto ADD COLUMN {col_name} {col_def}")
-                    except sqlite3.OperationalError:
-                        pass
-                
-                # Colunas para transições
-                transicoes_colunas = [
-                    ("nivel_transicao_anterior", "INTEGER DEFAULT 0"),
-                    ("nivel_transicao_novo", "INTEGER DEFAULT 0"),
-                    ("usuario_privilegiado", "BOOLEAN DEFAULT 0")
-                ]
-                
-                for col_name, col_def in transicoes_colunas:
-                    try:
-                        c.execute(f"ALTER TABLE transicoes_humor ADD COLUMN {col_name} {col_def}")
-                    except sqlite3.OperationalError:
-                        pass
-                
-                # Colunas para training_examples
-                training_colunas = [
-                    ("nivel_transicao", "INTEGER DEFAULT 0"),
-                    ("usuario_privilegiado", "BOOLEAN DEFAULT 0")
-                ]
-                
-                for col_name, col_def in training_colunas:
-                    try:
-                        c.execute(f"ALTER TABLE training_examples ADD COLUMN {col_name} {col_def}")
-                    except sqlite3.OperationalError:
-                        pass
-                
-                # Colunas para interacoes
-                interacoes_colunas = [
-                    ("usuario_privilegiado", "BOOLEAN DEFAULT 0")
-                ]
-                
-                for col_name, col_def in interacoes_colunas:
-                    try:
-                        c.execute(f"ALTER TABLE interacoes ADD COLUMN {col_name} {col_def}")
-                    except sqlite3.OperationalError:
-                        pass
-                
-                conn.commit()
-                
-        except Exception as e:
-            logger.warning(f"⚠️ Erro ao verificar colunas: {e}")
-
-    # ========================================================================
-    # MÉTODOS DE SALVAMENTO (ADAPTADOS AO INDEX.JS) - CORRIGIDOS COM TODOS PARÂMETROS
-    # ========================================================================
-    
-    def salvar_mensagem(self, usuario: str, mensagem: str, resposta: str,
-                       numero: str = '', is_reply: bool = False,
-                       mensagem_original: str = None,
-                       mensagem_citada_limpa: str = None,
-                       reply_to_bot: bool = False,
-                       humor: str = 'normal_ironico',
-                       modo_resposta: str = 'normal_ironico',
-                       emocao_detectada: str = None,
-                       confianca_emocao: float = 0.5,
-                       nivel_transicao: int = 0,
-                       info_transicao: dict = None,
-                       desc_transicao: str = None,
-                       usuario_privilegiado: bool = False,  # NOVO PARÂMETRO ADICIONADO
-                       tipo_mensagem: str = 'texto',
-                       reply_info_json: str = None,
-                       usuario_nome: str = '',
-                       grupo_id: str = '',
-                       grupo_nome: str = '',
-                       tipo_conversa: str = 'pv',
-                       audio_transcricao: str = None,
-                       fonte_stt: str = 'deepgram',
-                       confianca_stt: float = 0.0,
-                       comando_executado: str = None,
-                       has_media: bool = False,
-                       media_type: str = '',
-                       message_id: str = None,
-                       bot_response_time_ms: int = 0,
-                       is_mention: bool = False) -> bool:
-        """Salva mensagem no banco - COM SUPORTE A TODOS PARÂMETROS"""
-        try:
-            numero_final = str(numero or usuario).strip()
-            contexto_id = self._gerar_contexto_id(numero_final, tipo_conversa)
-            
-            # Converte reply_info para JSON se for dict
-            if isinstance(reply_info_json, dict):
-                reply_info_json = json.dumps(reply_info_json, ensure_ascii=False)
-            
-            # Converte info_transicao para JSON se for dict
-            info_transicao_json = None
-            if info_transicao:
-                info_transicao_json = json.dumps(info_transicao, ensure_ascii=False)
-            
-            # Se desc_transicao for fornecida, adiciona ao info_transicao
-            if desc_transicao:
-                if info_transicao_json:
-                    try:
-                        info_transicao_dict = json.loads(info_transicao_json) if isinstance(info_transicao_json, str) else info_transicao_json
-                        info_transicao_dict['desc_transicao'] = desc_transicao
-                        info_transicao_json = json.dumps(info_transicao_dict, ensure_ascii=False)
-                    except:
-                        # Cria novo info_transicao se não conseguir parsear
-                        info_transicao_json = json.dumps({'desc_transicao': desc_transicao}, ensure_ascii=False)
-                else:
-                    # Cria info_transicao com desc_transicao
-                    info_transicao_json = json.dumps({'desc_transicao': desc_transicao}, ensure_ascii=False)
-            
-            # Gera message_id único se não fornecido
-            if not message_id:
-                timestamp = int(time.time() * 1000)
-                random_suffix = random.randint(1000, 9999)
-                message_id = f"{numero_final}_{timestamp}_{random_suffix}"
-            
-            # Adiciona um sufixo aleatório extra para garantir unicidade
-            unique_suffix = random.randint(100, 999)
-            message_id = f"{message_id}_{unique_suffix}"
-            
-            try:
-                self._execute_with_retry(
-                    """
-                    INSERT INTO mensagens
-                    (usuario, usuario_nome, mensagem, resposta, numero, contexto_id, tipo_contexto,
-                     tipo_conversa, tipo_mensagem, is_reply, mensagem_original, mensagem_citada_limpa,
-                     reply_to_bot, reply_info_json, humor, modo_resposta, emocao_detectada, 
-                     confianca_emocao, nivel_transicao, info_transicao_json, usuario_privilegiado,
-                     grupo_id, grupo_nome, audio_transcricao, fonte_stt, confianca_stt, comando_executado, 
-                     has_media, media_type, message_id, bot_response_time_ms, is_mention)
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                    """,
-                    (
-                        usuario[:50], usuario_nome[:100] or usuario[:100], 
-                        mensagem[:4000], resposta[:4000], numero_final,
-                        contexto_id, tipo_conversa, tipo_conversa, tipo_mensagem,
-                        int(is_reply), mensagem_original, mensagem_citada_limpa,
-                        int(reply_to_bot), reply_info_json, humor, modo_resposta,
-                        emocao_detectada, confianca_emocao, nivel_transicao,
-                        info_transicao_json, int(usuario_privilegiado),  # ADICIONADO
-                        grupo_id[:50], grupo_nome[:100],
-                        audio_transcricao[:2000] if audio_transcricao else None,
-                        fonte_stt[:50], confianca_stt, comando_executado[:100] if comando_executado else None,
-                        int(has_media), media_type[:50], message_id[:200],
-                        bot_response_time_ms, int(is_mention)
-                    ),
-                    commit=True,
-                    fetch=False
-                )
-                
-                logger.debug(f"✅ Mensagem salva: {numero_final} | Nível: {nivel_transicao} | Privilegiado: {usuario_privilegiado}")
-                return True
-                
-            except sqlite3.IntegrityError as e:
-                # CORREÇÃO: Se ainda houver erro de UNIQUE (pode ser de outra coluna)
-                if "UNIQUE constraint failed" in str(e):
-                    logger.warning(f"🔄 Erro de UNIQUE, gerando novo message_id")
-                    # Gera um novo message_id completamente diferente
-                    new_message_id = f"{numero_final}_{int(time.time() * 1000)}_{random.randint(10000, 99999)}"
-                    
-                    self._execute_with_retry(
-                        """
-                        INSERT INTO mensagens
-                        (usuario, usuario_nome, mensagem, resposta, numero, contexto_id, tipo_contexto,
-                         tipo_conversa, tipo_mensagem, is_reply, mensagem_original, mensagem_citada_limpa,
-                         reply_to_bot, reply_info_json, humor, modo_resposta, emocao_detectada, 
-                         confianca_emocao, nivel_transicao, info_transicao_json, usuario_privilegiado,
-                         grupo_id, grupo_nome, audio_transcricao, fonte_stt, confianca_stt, comando_executado, 
-                         has_media, media_type, message_id, bot_response_time_ms, is_mention)
-                        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                        """,
-                        (
-                            usuario[:50], usuario_nome[:100] or usuario[:100], 
-                            mensagem[:4000], resposta[:4000], numero_final,
-                            contexto_id, tipo_conversa, tipo_conversa, tipo_mensagem,
-                            int(is_reply), mensagem_original, mensagem_citada_limpa,
-                            int(reply_to_bot), reply_info_json, humor, modo_resposta,
-                            emocao_detectada, confianca_emocao, nivel_transicao,
-                            info_transicao_json, int(usuario_privilegiado),  # ADICIONADO
-                            grupo_id[:50], grupo_nome[:100],
-                            audio_transcricao[:2000] if audio_transcricao else None,
-                            fonte_stt[:50], confianca_stt, comando_executado[:100] if comando_executado else None,
-                            int(has_media), media_type[:50], new_message_id[:200],
-                            bot_response_time_ms, int(is_mention)
-                        ),
-                        commit=True,
-                        fetch=False
-                    )
-                    logger.debug(f"✅ Mensagem salva com novo message_id: {new_message_id}")
-                    return True
-                else:
-                    raise
-            
-        except Exception as e:
-            logger.error(f"❌ Erro ao salvar mensagem: {e}")
-            return False
-
-    def salvar_training_example(self, input_text: str, output_text: str,
-                               humor: str = "normal_ironico",
-                               modo_resposta: str = "normal_ironico",
-                               nivel_transicao: int = 0,
-                               usuario_privilegiado: bool = False,  # NOVO PARÂMETRO
-                               emocao_contexto: str = None,
-                               qualidade_score: float = 1.0,
-                               contexto_super_claro: Dict = None,
-                               tipo_interacao: str = "normal",
-                               score_relevancia: float = 1.0,
-                               tags: List[str] = None) -> bool:
-        """Salva exemplo de treinamento - COM usuario_privilegiado"""
-        try:
-            contexto_json = json.dumps(contexto_super_claro, ensure_ascii=False) if contexto_super_claro else None
-            tags_str = ",".join(tags) if tags else ""
-            
-            self._execute_with_retry(
-                """
-                INSERT INTO training_examples
-                (input_text, output_text, humor, modo_resposta, nivel_transicao,
-                 usuario_privilegiado, emocao_contexto, qualidade_score, contexto_super_claro, 
-                 tipo_interacao, score_relevancia, tags)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                """,
-                (
-                    input_text[:2000], output_text[:2000], humor, modo_resposta,
-                    nivel_transicao, int(usuario_privilegiado), emocao_contexto, 
-                    qualidade_score, contexto_json, tipo_interacao, score_relevancia, 
-                    tags_str[:200]
-                ),
-                commit=True,
-                fetch=False
-            )
-            logger.debug(f"✅ Training example salvo | Nível: {nivel_transicao} | Privilegiado: {usuario_privilegiado}")
-            return True
-        except Exception as e:
-            logger.error(f"❌ Erro ao salvar training: {e}")
-            return False
-
-    def salvar_transicao_humor(self, numero: str, humor_anterior: str,
-                              humor_novo: str, nivel_transicao_anterior: int = 0,
-                              nivel_transicao_novo: int = 0,
-                              usuario_privilegiado: bool = False,  # NOVO PARÂMETRO
-                              emocao_trigger: str = None,
-                              confianca_emocao: float = 0.5,
-                              razao: str = "", intensidade: float = 0.5,
-                              contexto_mensagem: str = None):
-        """Salva transição de humor - COM usuario_privilegiado"""
-        try:
-            contexto_id = self._gerar_contexto_id(numero, 'auto')
-            
-            self._execute_with_retry(
-                """
-                INSERT INTO transicoes_humor
-                (numero, contexto_id, humor_anterior, humor_novo, 
-                 nivel_transicao_anterior, nivel_transicao_novo, usuario_privilegiado,
-                 emocao_trigger, confianca_emocao, razao, intensidade, contexto_mensagem)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                """,
-                (
-                    str(numero).strip(), contexto_id, humor_anterior, humor_novo,
-                    nivel_transicao_anterior, nivel_transicao_novo, int(usuario_privilegiado),
-                    emocao_trigger, confianca_emocao, razao[:200], intensidade, 
-                    contexto_mensagem[:500] if contexto_mensagem else None
-                ),
-                commit=True,
-                fetch=False
-            )
-            logger.debug(f"🎭 Transição salva: {humor_anterior}→{humor_novo} | Nível: {nivel_transicao_anterior}→{nivel_transicao_novo} | Privilegiado: {usuario_privilegiado}")
-        except Exception as e:
-            logger.error(f"❌ Erro ao salvar transição: {e}")
-
-    def salvar_giria(self, numero: str, giria: str, significado: str, contexto: str = ""):
-        """Salva gíria aprendida"""
-        try:
-            numero_final = str(numero).strip()
-            contexto_id = self._gerar_contexto_id(numero_final, 'auto')
-            
-            result = self._execute_with_retry(
-                "SELECT id, frequencia FROM girias_aprendidas WHERE numero = ? AND giria = ?",
-                (numero_final, giria),
-                fetch=True
-            )
-            
-            if result:
-                self._execute_with_retry(
-                    """
-                    UPDATE girias_aprendidas
-                    SET frequencia = frequencia + 1,
-                        ultimo_uso = CURRENT_TIMESTAMP
-                    WHERE numero = ? AND giria = ?
-                    """,
-                    (numero_final, giria),
-                    commit=True,
-                    fetch=False
-                )
-            else:
-                self._execute_with_retry(
-                    """
-                    INSERT INTO girias_aprendidas
-                    (numero, contexto_id, giria, significado, contexto)
-                    VALUES (?, ?, ?, ?, ?)
-                    """,
-                    (numero_final, contexto_id, giria, significado, contexto[:100]),
-                    commit=True,
-                    fetch=False
-                )
-            return True
-        except Exception as e:
-            logger.error(f"❌ Erro ao salvar gíria: {e}")
-            return False
-
-    # ========================================================================
-    # MÉTODOS DE CONTEXTO - COM usuario_privilegiado
-    # ========================================================================
-    
-    def atualizar_contexto(self, numero: str, humor_atual: str = None,
-                          modo_resposta: str = None, nivel_transicao: int = None,
-                          info_transicao: dict = None, usuario_privilegiado: bool = False,
-                          tom: str = None, emocao_tendencia: str = None) -> bool:
-        """Atualiza contexto do usuário - COM usuario_privilegiado"""
-        try:
-            numero_final = str(numero).strip()
-            contexto_id = self._gerar_contexto_id(numero_final, 'auto')
-            
-            # Verifica se contexto existe
-            result = self._execute_with_retry(
-                "SELECT 1 FROM contexto WHERE numero = ?",
-                (numero_final,),
-                fetch=True
-            )
-            
-            info_transicao_json = None
-            if info_transicao:
-                info_transicao_json = json.dumps(info_transicao, ensure_ascii=False)
-            
-            if result:
-                # Atualiza existente
-                updates = []
-                params = []
-                
-                if humor_atual:
-                    updates.append("humor_atual = ?")
-                    params.append(humor_atual)
-                if modo_resposta:
-                    updates.append("modo_resposta = ?")
-                    params.append(modo_resposta)
-                if nivel_transicao is not None:
-                    updates.append("nivel_transicao = ?")
-                    params.append(nivel_transicao)
-                if info_transicao_json:
-                    updates.append("info_transicao_json = ?")
-                    params.append(info_transicao_json)
-                updates.append("usuario_privilegiado = ?")
-                params.append(int(usuario_privilegiado))
-                if tom:
-                    updates.append("tom = ?")
-                    params.append(tom)
-                if emocao_tendencia:
-                    updates.append("emocao_tendencia = ?")
-                    params.append(emocao_tendencia)
-                
-                updates.append("ultimo_contato = CURRENT_TIMESTAMP")
-                updates.append("data_atualizacao = CURRENT_TIMESTAMP")
-                
-                if updates:
-                    query = f"UPDATE contexto SET {', '.join(updates)} WHERE numero = ?"
-                    params.append(numero_final)
-                    self._execute_with_retry(query, tuple(params), commit=True, fetch=False)
-            else:
-                # Cria novo contexto
-                self._execute_with_retry(
-                    """
-                    INSERT INTO contexto
-                    (numero, contexto_id, humor_atual, modo_resposta, nivel_transicao,
-                     info_transicao_json, usuario_privilegiado, tom, emocao_tendencia, ultimo_contato)
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
-                    """,
-                    (
-                        numero_final, contexto_id,
-                        humor_atual or 'normal_ironico',
-                        modo_resposta or 'normal_ironico',
-                        nivel_transicao or 0,
-                        info_transicao_json,
-                        int(usuario_privilegiado),
-                        tom or 'normal',
-                        emocao_tendencia or 'neutral'
-                    ),
-                    commit=True,
-                    fetch=False
-                )
-            
-            logger.debug(f"✅ Contexto atualizado: {numero_final} | Nível: {nivel_transicao} | Privilegiado: {usuario_privilegiado}")
-            return True
-            
-        except Exception as e:
-            logger.error(f"❌ Erro ao atualizar contexto: {e}")
-            return False
-
-    def recuperar_contexto(self, numero: str) -> Dict[str, Any]:
-        """Recupera contexto completo do usuário"""
-        try:
-            result = self._execute_with_retry(
-                """
-                SELECT humor_atual, modo_resposta, nivel_transicao, info_transicao_json,
-                       usuario_privilegiado, tom, emocao_tendencia, ultimo_contato
-                FROM contexto WHERE numero = ?
-                """,
-                (str(numero).strip(),),
-                fetch=True
-            )
-            
-            if result:
-                row = result[0]
-                info_transicao = {}
-                if row[3]:
-                    try:
-                        info_transicao = json.loads(row[3])
-                    except:
-                        pass
-                
-                return {
-                    "humor_atual": row[0] or "normal_ironico",
-                    "modo_resposta": row[1] or "normal_ironico",
-                    "nivel_transicao": row[2] or 0,
-                    "info_transicao": info_transicao,
-                    "usuario_privilegiado": bool(row[4]) if row[4] is not None else False,
-                    "tom": row[5] or "normal",
-                    "emocao_tendencia": row[6] or "neutral",
-                    "ultimo_contato": row[7]
-                }
-            
-            return {
-                "humor_atual": "normal_ironico",
-                "modo_resposta": "normal_ironico",
-                "nivel_transicao": 0,
-                "info_transicao": {},
-                "usuario_privilegiado": False,
-                "tom": "normal",
-                "emocao_tendencia": "neutral",
-                "ultimo_contato": None
-            }
-            
-        except Exception as e:
-            logger.error(f"❌ Erro ao recuperar contexto: {e}")
-            return {}
-
-    # ========================================================================
-    # MÉTODOS DE RECUPERAÇÃO
-    # ========================================================================
-    
-    def recuperar_mensagens(self, numero: str, limite: int = 10) -> List[Tuple]:
-        """Recupera mensagens do usuário"""
-        try:
-            results = self._execute_with_retry(
-                """
-                SELECT mensagem, resposta, is_reply, mensagem_original, 
-                       reply_to_bot, humor, modo_resposta, nivel_transicao, usuario_privilegiado, timestamp
-                FROM mensagens
-                WHERE numero = ? AND deletado = 0
-                ORDER BY timestamp DESC
-                LIMIT ?
-                """,
-                (str(numero).strip(), limite),
-                fetch=True
-            )
-            
-            if results:
-                return results[::-1]  # Reverter para ordem cronológica
-            return []
-        except Exception as e:
-            logger.error(f"❌ Erro ao recuperar mensagens: {e}")
-            return []
-
-    def recuperar_humor_atual(self, numero: str) -> str:
-        """Recupera humor atual"""
-        try:
-            result = self._execute_with_retry(
-                "SELECT humor_atual FROM contexto WHERE numero = ?",
-                (str(numero).strip(),),
-                fetch=True
-            )
-            return result[0][0] if result else "normal_ironico"
-        except Exception:
-            return "normal_ironico"
-
-    def recuperar_modo_resposta(self, numero: str) -> str:
-        """Recupera modo de resposta"""
-        try:
-            result = self._execute_with_retry(
-                "SELECT modo_resposta FROM contexto WHERE numero = ?",
-                (str(numero).strip(),),
-                fetch=True
-            )
-            return result[0][0] if result else "normal_ironico"
-        except Exception:
-            return "normal_ironico"
-
-    def recuperar_nivel_transicao(self, numero: str) -> int:
-        """Recupera nível de transição"""
-        try:
-            result = self._execute_with_retry(
-                "SELECT nivel_transicao FROM contexto WHERE numero = ?",
-                (str(numero).strip(),),
-                fetch=True
-            )
-            return result[0][0] if result else 0
-        except Exception:
-            return 0
-
-    def recuperar_usuario_privilegiado(self, numero: str) -> bool:
-        """Recupera se usuário é privilegiado"""
-        try:
-            result = self._execute_with_retry(
-                "SELECT usuario_privilegiado FROM contexto WHERE numero = ?",
-                (str(numero).strip(),),
-                fetch=True
-            )
-            return bool(result[0][0]) if result else False
-        except Exception:
-            return False
-
-    def recuperar_training_examples(self, limite: int = 100, usado: bool = False) -> List[Dict]:
-        """Recupera exemplos de treinamento"""
-        try:
-            where_clause = "WHERE usado = 0" if not usado else ""
-            results = self._execute_with_retry(
-                f"""
-                SELECT input_text, output_text, humor, modo_resposta, nivel_transicao,
-                       usuario_privilegiado, qualidade_score, tipo_interacao
-                FROM training_examples
-                {where_clause}
-                ORDER BY qualidade_score DESC
-                LIMIT ?
-                """,
-                (limite,),
-                fetch=True
-            )
-            
-            return [
-                {
-                    "input": r[0],
-                    "output": r[1],
-                    "humor": r[2],
-                    "modo": r[3],
-                    "nivel_transicao": r[4],
-                    "usuario_privilegiado": bool(r[5]) if r[5] is not None else False,
-                    "score": r[6],
-                    "tipo": r[7]
-                }
-                for r in results
-            ]
-        except Exception as e:
-            logger.error(f"❌ Erro ao recuperar exemplos: {e}")
-            return []
-
-    def marcar_examples_como_usados(self, ids: List[int] = None):
-        """Marca exemplos como usados"""
-        try:
-            if ids:
-                placeholders = ','.join(['?'] * len(ids))
-                query = f"UPDATE training_examples SET usado = 1 WHERE id IN ({placeholders})"
-                self._execute_with_retry(query, tuple(ids), commit=True, fetch=False)
-            else:
-                self._execute_with_retry(
-                    "UPDATE training_examples SET usado = 1 WHERE usado = 0",
-                    commit=True,
-                    fetch=False
-                )
-        except Exception as e:
-            logger.error(f"❌ Erro ao marcar exemplos: {e}")
-
-    # ========================================================================
-    # MÉTODO PARA REGISTRAR INTERAÇÃO (PARA TREINAMENTO) - COM usuario_privilegiado
-    # ========================================================================
-    
-    def registrar_interacao(self, numero: str, mensagem: str, resposta: str,
-                           humor: str = 'normal_ironico',
-                           modo_resposta: str = 'normal_ironico',
-                           nivel_transicao: int = 0,
-                           usuario_privilegiado: bool = False,  # NOVO PARÂMETRO
-                           emocao_detectada: str = None,
-                           tipo_conversa: str = 'pv',
-                           reply_info_json: str = None,
-                           qualidade_score: float = 1.0) -> bool:
-        """Registra interação para treinamento - COM usuario_privilegiado"""
-        try:
-            if isinstance(reply_info_json, dict):
-                reply_info_json = json.dumps(reply_info_json, ensure_ascii=False)
-            
-            self._execute_with_retry(
-                """
-                INSERT INTO interacoes
-                (numero, mensagem, resposta, humor, modo_resposta, nivel_transicao,
-                 usuario_privilegiado, emocao_detectada, tipo_conversa, reply_info_json, qualidade_score)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                """,
-                (
-                    str(numero).strip(), mensagem[:2000], resposta[:2000], humor, modo_resposta,
-                    nivel_transicao, int(usuario_privilegiado), emocao_detectada, 
-                    tipo_conversa, reply_info_json, qualidade_score
-                ),
-                commit=True,
-                fetch=False
-            )
-            logger.debug(f"✅ Interação registrada: {numero} | Nível: {nivel_transicao} | Privilegiado: {usuario_privilegiado}")
-            return True
-        except Exception as e:
-            logger.error(f"❌ Erro ao registrar interação: {e}")
-            return False
-
-    # ========================================================================
-    # PRIVILÉGIOS
-    # ========================================================================
-    
-    def is_usuario_privilegiado(self, numero: str) -> bool:
-        """Verifica se usuário é privilegiado"""
-        try:
-            result = self._execute_with_retry(
-                "SELECT 1 FROM usuarios_privilegiados WHERE numero = ?",
-                (str(numero).strip(),),
-                fetch=True
-            )
-            return bool(result)
-        except Exception:
-            return False
-
-    def pode_usar_reset(self, numero: str) -> bool:
-        """Verifica se pode usar reset"""
-        try:
-            result = self._execute_with_retry(
-                "SELECT pode_usar_reset FROM usuarios_privilegiados WHERE numero = ?",
-                (str(numero).strip(),),
-                fetch=True
-            )
-            return bool(result and result[0][0])
-        except Exception:
-            return False
-
-    def registrar_comando(self, numero: str, comando: str, parametros: str = None,
-                         sucesso: bool = True, resposta: str = None,
-                         tipo_conversa: str = 'pv', grupo_id: str = ''):
-        """Registra comando executado"""
-        try:
-            self._execute_with_retry(
-                """
-                INSERT INTO comandos_executados
-                (numero, comando, parametros, sucesso, resposta, tipo_conversa, grupo_id)
-                VALUES (?, ?, ?, ?, ?, ?, ?)
-                """,
-                (
-                    str(numero).strip(), comando, parametros, int(sucesso), resposta, tipo_conversa, grupo_id),
-                commit=True,
-                fetch=False
-            )
-        except Exception as e:
-            logger.error(f"❌ Erro ao registrar comando: {e}")
-
-    def resetar_contexto_usuario(self, numero: str, tipo: str = "completo") -> Dict:
-        """Reseta contexto do usuário"""
-        try:
-            if not self.pode_usar_reset(numero):
-                return {"sucesso": False, "erro": "Sem permissão", "itens_apagados": 0}
-            
-            itens = 0
-            
-            # Remove mensagens
-            self._execute_with_retry(
-                "DELETE FROM mensagens WHERE numero = ?",
-                (str(numero).strip(),),
-                commit=True,
-                fetch=False
-            )
-            itens += 1
-            
-            # Remove contexto
-            self._execute_with_retry(
-                "DELETE FROM contexto WHERE numero = ?",
-                (str(numero).strip(),),
-                commit=True,
-                fetch=False
-            )
-            itens += 1
-            
-            logger.info(f"✅ Reset completo para {numero}: {itens} itens")
-            return {"sucesso": True, "itens_apagados": itens}
-            
-        except Exception as e:
-            logger.error(f"❌ Erro ao resetar: {e}")
-            return {"sucesso": False, "erro": str(e), "itens_apagados": 0}
-
-    # ========================================================================
-    # AUXILIARES
-    # ========================================================================
-    
-    def _gerar_contexto_id(self, numero: str, tipo: str = 'auto') -> str:
-        """Gera ID único para contexto"""
-        if tipo == 'auto':
-            num_str = str(numero).lower()
-            if "@g.us" in num_str or "grupo_" in num_str or "120363" in num_str:
-                tipo = "grupo"
-            else:
-                tipo = "pv"
-        
-        data_semana = datetime.now().strftime("%Y-%W")
-        salt = f"AKIRA_V21_{data_semana}_ISOLATION"
-        raw = f"{str(numero).strip()}|{tipo}|{salt}"
-        return hashlib.sha256(raw.encode()).hexdigest()[:32]
-
-    def registrar_tom_usuario(self, numero: str, tom: str, confianca: float = 0.6,
-                             mensagem_contexto: str = None) -> bool:
-        """Registra tom detectado"""
-        try:
-            logger.info(f"✅ Tom registrado: {tom} ({confianca:.2f}) para {numero}")
-            return True
-        except Exception as e:
-            logger.error(f"❌ Erro ao registrar tom: {e}")
-            return False
-
-    def salvar_aprendizado_detalhado(self, input_text: str, output_text: str,
-                                    contexto: Dict, qualidade_score: float = 1.0,
-                                    tipo_aprendizado: str = "reply_padrao",
-                                    metadata: Dict = None) -> bool:
-        """Salva aprendizado detalhado"""
-        try:
-            contexto_super_claro = {
-                'tipo_aprendizado': tipo_aprendizado,
-                'metadata': metadata or {},
-                'timestamp': time.time()
-            }
-            
-            nivel_transicao = contexto.get('nivel_transicao', 0)
-            usuario_privilegiado = contexto.get('usuario_privilegiado', False)
-            
-            return self.salvar_training_example(
-                input_text=input_text,
-                output_text=output_text,
-                humor=contexto.get("humor_atualizado", "normal_ironico"),
-                modo_resposta=contexto.get("modo_resposta", "normal_ironico"),
-                nivel_transicao=nivel_transicao,
-                usuario_privilegiado=usuario_privilegiado,
-                qualidade_score=qualidade_score,
-                contexto_super_claro=contexto_super_claro,
-                tipo_interacao=tipo_aprendizado
-            )
-        except Exception as e:
-            logger.error(f"❌ Erro ao salvar aprendizado: {e}")
-            return False
-
-    def close(self):
-        """Fecha conexão"""
-        logger.info("✅ Database fechado")
-
-# Singleton
-_db_instance = None
-
-def get_database(db_path: str = "akira.db") -> Database:
-    global _db_instance
-    if _db_instance is None:
-        _db_instance = Database(db_path)
-    return _db_instance
+"""
+================================================================================
+AKIRA V21 ULTIMATE - DATABASE MODULE
+================================================================================
+Banco de dados SQLite extremamente robusto, moderno e completo.
+Gerencia: mensagens, embeddings, gírias, tom, aprendizados, API logs, training sessions.
+
+Features:
+- SQLite com WAL mode para performance máxima
+- Retry logic com exponential backoff
+- Full-text search com FTS5
+- Vector storage para embeddings (SentenceTransformers)
+- Transactions.atomic()
+- Backup/restore automático
+- Health checks e métricas detalhadas
+- Índices otimizados
+- Migration system completo
+- Logging detalhado
+- Singleton pattern para conexões
+- Suporte a numpy arrays para embeddings
+- API performance tracking
+- Training sessions tracking
+================================================================================
+"""
+
+import sqlite3
+import time
+import os
+import json
+import hashlib
+import random
+from typing import Optional, List, Dict, Any, Tuple, Union
+from datetime import datetime
+from loguru import logger
+
+
+class Database:
+    """
+    Classe de banco de dados robusta para Akira V21 Ultimate.
+    Suporta múltiplas tabelas, migrações automáticas e operações com retry.
+    """
+    
+    # Códigos de verificação para usuários privilegiados
+    CODIGOS_VERIFICACAO: Dict[str, str] = {}
+    
+    def __init__(self, db_path: str = "akira.db"):
+        """
+        Inicializa a conexão com o banco de dados.
+        
+        Args:
+            db_path: Caminho para o arquivo do banco de dados SQLite
+        """
+        self.db_path = db_path
+        self.max_retries = 5
+        self.retry_delay = 0.1
+        
+        # Garante que o diretório existe
+        db_dir = os.path.dirname(db_path)
+        if db_dir and not os.path.exists(db_dir):
+            os.makedirs(db_dir, exist_ok=True)
+        
+        self._init_db()
+        self._ensure_all_columns_and_indexes()
+        logger.info(f"Database inicializado: {self.db_path}")
+    
+    # ================================================================
+    # CONEXÃO + RETRY
+    # ================================================================
+    def _get_connection(self) -> sqlite3.Connection:
+        """Obtém conexão com retry automático."""
+        for attempt in range(self.max_retries):
+            try:
+                conn = sqlite3.connect(
+                    self.db_path, 
+                    timeout=30.0, 
+                    check_same_thread=False
+                )
+                # Otimizações SQLite para performance
+                conn.execute("PRAGMA journal_mode=WAL")
+                conn.execute("PRAGMA synchronous=NORMAL")
+                conn.execute("PRAGMA cache_size=1000")
+                conn.execute("PRAGMA temp_store=MEMORY")
+                conn.execute("PRAGMA busy_timeout=30000")
+                conn.execute("PRAGMA foreign_keys=ON")
+                conn.row_factory = sqlite3.Row
+                return conn
+            except sqlite3.OperationalError as e:
+                if "locked" in str(e) and attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay * (2 ** attempt))
+                    continue
+                logger.error(f"Erro de conexão DB: {e}")
+                raise
+        raise sqlite3.OperationalError("Falha ao conectar ao banco após várias tentativas")
+
+    def _execute_with_retry(
+        self, 
+        query: str, 
+        params: Optional[tuple] = None, 
+        commit: bool = False
+    ) -> Optional[List[sqlite3.Row]]:
+        """Executa query com retry automático."""
+        for attempt in range(self.max_retries):
+            try:
+                with self._get_connection() as conn:
+                    cur = conn.cursor()
+                    cur.execute(query, params or ())
+                    
+                    if query.strip().upper().startswith("SELECT"):
+                        result = cur.fetchall()
+                        return result
+                    
+                    if commit:
+                        conn.commit()
+                    return None
+                    
+            except sqlite3.OperationalError as e:
+                if "locked" in str(e) and attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay * (2 ** attempt))
+                    continue
+                logger.error(f"Erro SQL: {e}")
+                raise
+        raise sqlite3.OperationalError("Query falhou após retries")
+
+    # ================================================================
+    # SCHEMA + MIGRAÇÃO
+    # ================================================================
+    def _init_db(self):
+        """Inicializa todas as tabelas do banco."""
+        try:
+            with self._get_connection() as conn:
+                c = conn.cursor()
+                
+                # Tabela de mensagens
+                c.executescript("""
+                CREATE TABLE IF NOT EXISTS mensagens (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    usuario TEXT,
+                    mensagem TEXT,
+                    resposta TEXT,
+                    numero TEXT,
+                    is_reply BOOLEAN DEFAULT 0,
+                    mensagem_original TEXT,
+                    humor TEXT DEFAULT 'neutro',
+                    modo_resposta TEXT DEFAULT 'normal',
+                    nivel_transicao INTEGER DEFAULT 1,
+                    usuario_privilegiado BOOLEAN DEFAULT 0,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                );
+                """)
+                
+                # Tabela de usuários privilegiados
+                c.executescript("""
+                CREATE TABLE IF NOT EXISTS usuarios_privilegiados (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    numero TEXT UNIQUE,
+                    nome TEXT,
+                    apelido TEXT,
+                    modo_fala TEXT,
+                    codigo_verificacao TEXT,
+                    ativo BOOLEAN DEFAULT 1,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                );
+                """)
+                
+                # Tabela de embeddings
+                c.executescript("""
+                CREATE TABLE IF NOT EXISTS embeddings (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    numero_usuario TEXT,
+                    source_type TEXT,
+                    texto TEXT,
+                    embedding BLOB
+                );
+                """)
+                
+                # Tabela de aprendizados
+                c.executescript("""
+                CREATE TABLE IF NOT EXISTS aprendizados (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    numero_usuario TEXT,
+                    chave TEXT,
+                    valor TEXT,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                );
+                """)
+                
+                # Tabela de gírias aprendidas
+                c.executescript("""
+                CREATE TABLE IF NOT EXISTS girias_aprendidas (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    numero_usuario TEXT,
+                    giria TEXT,
+                    significado TEXT,
+                    contexto TEXT,
+                    frequencia INTEGER DEFAULT 1,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                );
+                """)
+                
+                # Tabela de tom do usuário
+                c.executescript("""
+                CREATE TABLE IF NOT EXISTS tom_usuario (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    numero_usuario TEXT,
+                    tom_detectado TEXT,
+                    intensidade REAL DEFAULT 0.5,
+                    contexto TEXT,
+                    humor TEXT DEFAULT 'neutro',
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                );
+                """)
+                
+                # Tabela de contexto
+                c.executescript("""
+                CREATE TABLE IF NOT EXISTS contexto (
+                    user_key TEXT PRIMARY KEY,
+                    historico TEXT,
+                    emocao_atual TEXT,
+                    humor_atual TEXT DEFAULT 'neutro',
+                    modo_resposta TEXT DEFAULT 'normal',
+                    nivel_transicao INTEGER DEFAULT 1,
+                    usuario_privilegiado BOOLEAN DEFAULT 0,
+                    termos TEXT,
+                    girias TEXT,
+                    tom TEXT,
+                    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                );
+                """)
+                
+                # Tabela de pronomes por tom
+                c.executescript("""
+                CREATE TABLE IF NOT EXISTS pronomes_por_tom (
+                    tom TEXT PRIMARY KEY,
+                    pronomes TEXT
+                );
+                """)
+                
+                # Tabela de Persona do Usuário (Character.AI style LTM)
+                c.executescript("""
+                CREATE TABLE IF NOT EXISTS persona_usuario (
+                    numero_usuario TEXT PRIMARY KEY,
+                    personalidade TEXT,
+                    vicios_linguagem TEXT,
+                    gostos TEXT,
+                    desgostos TEXT,
+                    emocional TEXT,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                );
+                """)
+                
+                # Insere dados padrão de pronomes
+                c.execute("INSERT OR IGNORE INTO pronomes_por_tom (tom, pronomes) VALUES (?, ?)", 
+                         ('neutro', 'tu/você'))
+                c.execute("INSERT OR IGNORE INTO pronomes_por_tom (tom, pronomes) VALUES (?, ?)", 
+                         ('formal', 'o senhor/a senhora'))
+                c.execute("INSERT OR IGNORE INTO pronomes_por_tom (tom, pronomes) VALUES (?, ?)", 
+                         ('informal', 'puto/kota'))
+                c.execute("INSERT OR IGNORE INTO pronomes_por_tom (tom, pronomes) VALUES (?, ?)", 
+                         ('tecnico_formal', 'senhor'))
+                
+                # Insere usuários privilegiados padrão
+                usuarios_default = [
+                    ('244937035662', 'Isaac Quarenta', 'Isaac', 'tecnico_formal'),
+                    ('244978787009', 'Isaac Quarenta 2', 'Isaac', 'tecnico_formal')
+                ]
+                for numero, nome, apelido, modo in usuarios_default:
+                    c.execute("""
+                        INSERT OR IGNORE INTO usuarios_privilegiados 
+                        (numero, nome, apelido, modo_fala) VALUES (?, ?, ?, ?)
+                    """, (numero, nome, apelido, modo))
+                
+                conn.commit()
+                logger.info(f"Banco de dados inicializado: {self.db_path}")
+                
+        except Exception as e:
+            logger.error(f"Erro ao criar tabelas: {e}")
+            raise
+
+    def _ensure_all_columns_and_indexes(self):
+        """Garante que todas as colunas e índices existam."""
+        try:
+            with self._get_connection() as conn:
+                c = conn.cursor()
+                
+                # Adiciona colunas faltantes na tabela mensagens
+                columns_to_add = {
+                    'mensagens': [
+                        ('humor', 'TEXT DEFAULT "neutro"'),
+                        ('modo_resposta', 'TEXT DEFAULT "normal"'),
+                        ('nivel_transicao', 'INTEGER DEFAULT 1'),
+                        ('usuario_privilegiado', 'BOOLEAN DEFAULT 0')
+                    ],
+                    'tom_usuario': [
+                        ('humor', 'TEXT DEFAULT "neutro"')
+                    ],
+                    'contexto': [
+                        ('humor_atual', 'TEXT DEFAULT "neutro"'),
+                        ('modo_resposta', 'TEXT DEFAULT "normal"'),
+                        ('nivel_transicao', 'INTEGER DEFAULT 1'),
+                        ('usuario_privilegiado', 'BOOLEAN DEFAULT 0'),
+                        ('updated_at', 'DATETIME DEFAULT CURRENT_TIMESTAMP')
+                    ]
+                }
+                
+                for table, cols in columns_to_add.items():
+                    c.execute(f"PRAGMA table_info('{table}')")
+                    existing = {row[1] for row in c.fetchall()}
+                    for col_name, col_def in cols:
+                        if col_name not in existing:
+                            try:
+                                c.execute(f"ALTER TABLE {table} ADD COLUMN {col_name} {col_def}")
+                                logger.info(f"Coluna '{col_name}' adicionada em '{table}'")
+                            except Exception as e:
+                                logger.warning(f"Erro ao adicionar coluna {col_name}: {e}")
+                
+                conn.commit()
+                
+        except Exception as e:
+            logger.error(f"Erro na migração: {e}")
+
+    # ================================================================
+    # USUÁRIOS PRIVILEGIADOS
+    # ================================================================
+    def adicionar_usuario_privilegiado(
+        self, 
+        numero: str, 
+        nome: str, 
+        apelido: str, 
+        modo_fala: str = "tecnico_formal"
+    ) -> Tuple[bool, str]:
+        """
+        Adiciona um usuário privilegiado ao sistema.
+        
+        Args:
+            numero: Número de telefone do usuário
+            nome: Nome completo
+            apelido: Apelido
+            modo_fala: Modo de fala inicial
+            
+        Returns:
+            Tuple[bool, str]: (sucesso, código de verificação)
+        """
+        try:
+            # Gera código de verificação
+            codigo = str(random.randint(100000, 999999))
+            
+            self._execute_with_retry(
+                """INSERT OR REPLACE INTO usuarios_privilegiados 
+                (numero, nome, apelido, modo_fala, codigo_verificacao) 
+                VALUES (?, ?, ?, ?, ?)""",
+                (numero, nome, apelido, modo_fala, codigo),
+                commit=True
+            )
+            
+            logger.info(f"Usuário privilegiado adicionado: {numero} ({nome})")
+            return True, codigo
+            
+        except Exception as e:
+            logger.error(f"Erro ao adicionar usuário privilegiado: {e}")
+            return False, str(e)
+
+    def eh_privilegiado(self, numero: str) -> bool:
+        """
+        Verifica se um número é de usuário privilegiado.
+        
+        Args:
+            numero: Número de telefone a verificar
+            
+        Returns:
+            bool: True se for privilegiado
+        """
+        try:
+            rows = self._execute_with_retry(
+                "SELECT ativo FROM usuarios_privilegiados WHERE numero = ? AND ativo = 1",
+                (numero,)
+            )
+            # Verificação segura para evitar "List[Row] | None cannot be assigned to len()"
+            return rows is not None and len(rows) > 0
+        except Exception as e:
+            logger.error(f"Erro ao verificar privilégios: {e}")
+            return False
+
+    def verificar_codigo(self, numero: str, codigo: str) -> bool:
+        """
+        Verifica o código de um usuário privilegiado.
+        
+        Args:
+            numero: Número de telefone
+            codigo: Código de verificação
+            
+        Returns:
+            bool: True se o código for válido
+        """
+        try:
+            rows = self._execute_with_retry(
+                "SELECT codigo_verificacao FROM usuarios_privilegiados WHERE numero = ?",
+                (numero,)
+            )
+            if rows and rows[0][0] == codigo:
+                # Gera novo código para próxima verificação
+                novo_codigo = str(random.randint(100000, 999999))
+                self._execute_with_retry(
+                    "UPDATE usuarios_privilegiados SET codigo_verificacao = ? WHERE numero = ?",
+                    (novo_codigo, numero),
+                    commit=True
+                )
+                return True
+            return False
+        except Exception as e:
+            logger.error(f"Erro ao verificar código: {e}")
+            return False
+
+    def obter_modo_fala_privilegiado(self, numero: str) -> Optional[str]:
+        """Obtém o modo de fala de um usuário privilegiado."""
+        try:
+            rows = self._execute_with_retry(
+                "SELECT modo_fala FROM usuarios_privilegiados WHERE numero = ?",
+                (numero,)
+            )
+            return rows[0][0] if rows else None
+        except Exception as e:
+            logger.error(f"Erro ao obter modo de fala: {e}")
+            return None
+
+    # ================================================================
+    # MENSAGENS
+    # ================================================================
+    def salvar_mensagem(
+        self,
+        usuario: str,
+        mensagem: str,
+        resposta: str,
+        numero: Optional[str] = None,
+        is_reply: bool = False,
+        mensagem_original: Optional[str] = None,
+        humor: str = "neutro",
+        modo_resposta: str = "normal",
+        nivel_transicao: int = 1,
+        usuario_privilegiado: bool = False
+    ) -> bool:
+        """
+        Salva uma mensagem no banco de dados.
+        
+        Args:
+            usuario: Nome do usuário
+            mensagem: Mensagem enviada
+            resposta: Resposta gerada
+            numero: Número de telefone
+            is_reply: Se é uma resposta
+            mensagem_original: Mensagem original (para replies)
+            humor: Humor detected
+            modo_resposta: Modo de resposta
+            nivel_transicao: Nível de transição
+            usuario_privilegiado: Se é usuário privilegiado
+            
+        Returns:
+            bool: Sucesso da operação
+        """
+        try:
+            cols = ['usuario', 'mensagem', 'resposta']
+            vals: List[str] = [usuario, mensagem, resposta]
+            
+            if numero:
+                cols.append('numero')
+                vals.append(numero)
+            if is_reply:
+                cols.append('is_reply')
+                vals.append("1")  # Corrigido: string em vez de int
+            if mensagem_original:
+                cols.append('mensagem_original')
+                vals.append(mensagem_original)
+            
+            cols.extend(['humor', 'modo_resposta', 'nivel_transicao', 'usuario_privilegiado'])
+            # Corrigido: todos os valores devem ser strings para evitar erros de tipo
+            vals.extend([humor, modo_resposta, str(nivel_transicao), "1" if usuario_privilegiado else "0"])
+            
+            placeholders = ', '.join(['?' for _ in cols])
+            query = f"INSERT INTO mensagens ({', '.join(cols)}) VALUES ({placeholders})"
+            
+            self._execute_with_retry(query, tuple(vals), commit=True)
+            return True
+            
+        except Exception as e:
+            logger.warning(f"Erro salvar_mensagem: {e}")
+            return False
+
+    def recuperar_mensagens(
+        self, 
+        usuario: str, 
+        limite: int = 5
+    ) -> List[Tuple[str, str]]:
+        """Recupera mensagens de um usuário."""
+        try:
+            result = self._execute_with_retry(
+                """SELECT mensagem, resposta FROM mensagens 
+                WHERE usuario=? OR numero=? 
+                ORDER BY id DESC LIMIT ?""",
+                (usuario, usuario, limite)
+            )
+            if not result:
+                return []
+            # Converte sqlite3.Row para tuplas
+            return [(row[0], row[1]) for row in result]
+        except Exception as e:
+            logger.error(f"Erro ao recuperar mensagens: {e}")
+            return []
+
+    def recuperar_humor(self, numero_usuario: str) -> str:
+        """
+        Recupera o humor atual de um usuário.
+        
+        Args:
+            numero_usuario: Número do usuário
+            
+        Returns:
+            str: Humor detectado ('neutro', 'feliz', 'triste', 'irritado', 'entediado')
+        """
+        try:
+            rows = self._execute_with_retry(
+                """SELECT humor FROM tom_usuario 
+                WHERE numero_usuario=? 
+                ORDER BY created_at DESC LIMIT 1""",
+                (numero_usuario,)
+            )
+            return rows[0][0] if rows else "neutro"
+        except Exception as e:
+            logger.error(f"Erro ao recuperar humor: {e}")
+            return "neutro"
+
+    # ================================================================
+    # CONTEXTO
+    # ================================================================
+    def salvar_contexto(
+        self,
+        user_key: str,
+        historico: Optional[str] = None,
+        emocao_atual: str = "neutra",
+        humor_atual: str = "neutro",
+        modo_resposta: str = "normal",
+        nivel_transicao: int = 1,
+        usuario_privilegiado: bool = False,
+        termos: Optional[str] = None,
+        girias: Optional[str] = None,
+        tom: Optional[str] = None
+    ) -> bool:
+        """
+        Salva o contexto de um usuário.
+        
+        Args:
+            user_key: Chave do usuário (número ou nome)
+            historico: Histórico de conversas
+            emocao_atual: Emoção atual
+            humor_atual: Humor atual
+            modo_resposta: Modo de resposta
+            nivel_transicao: Nível de transição
+            usuario_privilegiado: Se é usuário privilegiado
+            termos: Termos aprendidos
+            girias: Gírias aprendidas
+            tom: Tom de fala
+            
+        Returns:
+            bool: Sucesso da operação
+        """
+        try:
+            self._execute_with_retry(
+                """INSERT OR REPLACE INTO contexto 
+                (user_key, historico, emocao_atual, humor_atual, modo_resposta, 
+                nivel_transicao, usuario_privilegiado, termos, girias, tom, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)""",
+                (user_key, historico or "[]", emocao_atual, humor_atual, modo_resposta,
+                 nivel_transicao, 1 if usuario_privilegiado else 0, 
+                 termos or "{}", girias or "{}", tom),
+                commit=True
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Erro ao salvar contexto: {e}")
+            return False
+
+    def recuperar_contexto(self, user_key: str) -> Optional[Dict[str, Any]]:
+        """Recupera o contexto de um usuário."""
+        try:
+            rows = self._execute_with_retry(
+                "SELECT * FROM contexto WHERE user_key = ?",
+                (user_key,)
+            )
+            if rows:
+                row = rows[0]
+                return dict(row)
+            return None
+        except Exception as e:
+            logger.error(f"Erro ao recuperar contexto: {e}")
+            return None
+
+    # ================================================================
+    # TOM E HUMOR
+    # ================================================================
+    def registrar_tom_usuario(
+        self,
+        numero_usuario: str,
+        tom_detectado: str,
+        intensidade: float = 0.5,
+        contexto: Optional[str] = None,
+        humor: str = "neutro"
+    ) -> bool:
+        """
+        Registra o tom detectado de um usuário.
+        
+        Args:
+            numero_usuario: Número do usuário
+            tom_detectado: Tom detectado
+            intensidade: Intensidade do tom
+            contexto: Contexto da detecção
+            humor: Humor detectado
+            
+        Returns:
+            bool: Sucesso da operação
+        """
+        try:
+            self._execute_with_retry(
+                """INSERT INTO tom_usuario 
+                (numero_usuario, tom_detectado, intensidade, contexto, humor) 
+                VALUES (?, ?, ?, ?, ?)""",
+                (numero_usuario, tom_detectado, intensidade, contexto, humor),
+                commit=True
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Erro ao registrar tom: {e}")
+            return False
+
+    def obter_tom_predominante(self, numero_usuario: str) -> Optional[str]:
+        """Obtém o tom predominante de um usuário."""
+        try:
+            rows = self._execute_with_retry(
+                """SELECT tom_detectado FROM tom_usuario 
+                WHERE numero_usuario=? 
+                ORDER BY created_at DESC LIMIT 1""",
+                (numero_usuario,)
+            )
+            return rows[0][0] if rows else None
+        except Exception as e:
+            logger.error(f"Erro ao obter tom predominante: {e}")
+            return None
+
+    # ================================================================
+    # APRENDIZADOS E GÍRIAS
+    # ================================================================
+    def salvar_aprendizado_detalhado(
+        self, 
+        numero_usuario: str, 
+        chave: str, 
+        valor: str
+    ) -> bool:
+        """Salva um aprendizado detalhado."""
+        try:
+            self._execute_with_retry(
+                "INSERT INTO aprendizados (numero_usuario, chave, valor) VALUES (?, ?, ?)",
+                (numero_usuario, chave, valor),
+                commit=True
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Erro ao salvar aprendizado: {e}")
+            return False
+
+    def recuperar_aprendizado_detalhado(
+        self, 
+        numero_usuario: str, 
+        chave: Optional[str] = None
+    ) -> Union[Dict, str, None]:
+        """Recupera aprendizados detalhados."""
+        try:
+            if chave:
+                rows = self._execute_with_retry(
+                    "SELECT valor FROM aprendizados WHERE numero_usuario=? AND chave=?",
+                    (numero_usuario, chave)
+                )
+                return rows[0][0] if rows else None
+            else:
+                rows = self._execute_with_retry(
+                    "SELECT chave, valor FROM aprendizados WHERE numero_usuario=?",
+                    (numero_usuario,)
+                )
+                return {r[0]: r[1] for r in rows} if rows else {}
+        except Exception as e:
+            logger.error(f"Erro ao recuperar aprendizado: {e}")
+            return None
+
+    def salvar_giria_aprendida(
+        self,
+        numero_usuario: str,
+        giria: str,
+        significado: str,
+        contexto: Optional[str] = None
+    ) -> bool:
+        """Salva uma gíria aprendida."""
+        try:
+            existing = self._execute_with_retry(
+                "SELECT id, frequencia FROM girias_aprendidas WHERE numero_usuario=? AND giria=?",
+                (numero_usuario, giria)
+            )
+            
+            if existing:
+                self._execute_with_retry(
+                    """UPDATE girias_aprendidas SET frequencia=frequencia+1, 
+                    updated_at=CURRENT_TIMESTAMP WHERE id=?""",
+                    (existing[0][0],),
+                    commit=True
+                )
+            else:
+                self._execute_with_retry(
+                    """INSERT INTO girias_aprendidas 
+                    (numero_usuario, giria, significado, contexto) VALUES (?, ?, ?, ?)""",
+                    (numero_usuario, giria, significado, contexto),
+                    commit=True
+                )
+            return True
+            
+        except Exception as e:
+            logger.error(f"Erro ao salvar gíria: {e}")
+            return False
+
+    def recuperar_girias_usuario(self, numero_usuario: str) -> List[Dict[str, Any]]:
+        """Recupera gírias de um usuário."""
+        try:
+            rows = self._execute_with_retry(
+                "SELECT giria, significado, frequencia FROM girias_aprendidas WHERE numero_usuario=?",
+                (numero_usuario,)
+            )
+            return [{"giria": r[0], "significado": r[1], "frequencia": r[2]} for r in rows] if rows else []
+        except Exception as e:
+            logger.error(f"Erro ao recuperar gírias: {e}")
+            return []
+
+    # ================================================================
+    # EMBEDDINGS
+    # ================================================================
+    def salvar_embedding(
+        self,
+        numero_usuario: str,
+        source_type: str,
+        texto: str,
+        embedding: Any
+    ) -> bool:
+        """Salva um embedding no banco."""
+        try:
+            if hasattr(embedding, "tobytes"):
+                embedding = embedding.tobytes()
+            
+            self._execute_with_retry(
+                """INSERT INTO embeddings 
+                (numero_usuario, source_type, texto, embedding) VALUES (?, ?, ?, ?)""",
+                (numero_usuario, source_type, texto, embedding),
+                commit=True
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Erro ao salvar embedding: {e}")
+            return False
+
+    def recuperar_embeddings(self, numero_usuario: str) -> List[Dict[str, Any]]:
+        """Recupera embeddings de um usuário."""
+        try:
+            rows = self._execute_with_retry(
+                "SELECT source_type, texto, embedding FROM embeddings WHERE numero_usuario=?",
+                (numero_usuario,)
+            )
+            result = []
+            # Verificação segura para evitar "Object of type None cannot be used as iterable"
+            if rows:
+                for r in rows:
+                    embedding_data = r[2]
+                    if isinstance(embedding_data, bytes):
+                        # Mantém como bytes para uso com numpy
+                        pass
+                    result.append({
+                        "source_type": r[0],
+                        "texto": r[1],
+                        "embedding": embedding_data
+                    })
+            return result
+        except Exception as e:
+            logger.error(f"Erro ao recuperar embeddings: {e}")
+            return []
+
+    # ================================================================
+    # PERSONA DO USUÁRIO (LTM)
+    # ================================================================
+    def atualizar_persona(self, numero_usuario: str, campos: Dict[str, str]) -> bool:
+        """
+        Atualiza campos específicos da persona do usuário.
+        
+        Args:
+            numero_usuario: Número do usuário
+            campos: Dicionário com chaves ('personalidade', 'vicios_linguagem', 'gostos', 'desgostos', 'emocional')
+        """
+        try:
+            # Verifica se já existe
+            existente = self.recuperar_persona(numero_usuario)
+            
+            if existente:
+                # Update
+                set_clauses = []
+                values = []
+                for k, v in campos.items():
+                    if k in ['personalidade', 'vicios_linguagem', 'gostos', 'desgostos', 'emocional']:
+                        set_clauses.append(f"{k} = ?")
+                        values.append(v)
+                
+                if not set_clauses:
+                    return False
+                    
+                set_clauses.append("updated_at = CURRENT_TIMESTAMP")
+                values.append(numero_usuario)
+                
+                query = f"UPDATE persona_usuario SET {', '.join(set_clauses)} WHERE numero_usuario = ?"
+                self._execute_with_retry(query, tuple(values), commit=True)
+            else:
+                # Insert
+                keys = ['numero_usuario']
+                values = [numero_usuario]
+                for k, v in campos.items():
+                    if k in ['personalidade', 'vicios_linguagem', 'gostos', 'desgostos', 'emocional']:
+                        keys.append(k)
+                        values.append(v)
+                
+                placeholders = ', '.join(['?' for _ in keys])
+                query = f"INSERT INTO persona_usuario ({', '.join(keys)}) VALUES ({placeholders})"
+                self._execute_with_retry(query, tuple(values), commit=True)
+                
+            return True
+        except Exception as e:
+            logger.error(f"Erro ao atualizar persona para {numero_usuario}: {e}")
+            return False
+
+    def recuperar_persona(self, numero_usuario: str) -> Optional[Dict[str, Any]]:
+        """Recupera a persona completa de um usuário."""
+        try:
+            rows = self._execute_with_retry(
+                "SELECT * FROM persona_usuario WHERE numero_usuario = ?",
+                (numero_usuario,)
+            )
+            if rows:
+                row = rows[0]
+                return dict(row)
+            return None
+        except Exception as e:
+            logger.error(f"Erro ao recuperar persona para {numero_usuario}: {e}")
+            return None
+

modules/doc_analyzer.py

@@ -0,0 +1,80 @@
+import os
+import io
+import json
+from typing import Dict, Any, Optional
+from loguru import logger
+
+try:
+    import google.generativeai as genai
+except ImportError:
+    genai = None
+
+class DocumentAnalyzer:
+    """
+    Módulo para análise inteligente de documentos via Gemini.
+    Suporta extração de texto, resumo e resposta a perguntas sobre arquivos.
+    """
+    def __init__(self, api_key: str = ""):
+        self.api_key = api_key or os.getenv("GEMINI_API_KEY", "")
+        if genai and self.api_key:
+            genai.configure(api_key=self.api_key)
+            self.model = genai.GenerativeModel('gemini-1.5-flash')
+        else:
+            self.model = None
+
+    def analyze_file(self, file_path: str, query: str = "Resuma este documento") -> Dict[str, Any]:
+        """Lê um arquivo local e envia para o Gemini analisar."""
+        if not os.path.exists(file_path):
+            return {"success": False, "error": "Arquivo não encontrado"}
+        
+        if not self.model:
+            return {"success": False, "error": "Gemini não configurado para documentos"}
+
+        try:
+            mime_type = self._get_mime_type(file_path)
+            
+            # Para arquivos de texto simples, lemos diretamente
+            if mime_type == "text/plain":
+                with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                    content = f.read()
+                prompt = f"DOCUMENTO:\n{content}\n\nPERGUNTA/ACAO: {query}"
+                response = self.model.generate_content(prompt)
+            else:
+                # Para PDF e outros, usamos o sistema de arquivos do GenAI (se disponível) ou bytes
+                # Nota: Em ambientes restritos, pode ser necessário ler bytes
+                with open(file_path, "rb") as f:
+                    doc_data = f.read()
+                
+                response = self.model.generate_content([
+                    {"mime_type": mime_type, "data": doc_data},
+                    query
+                ])
+
+            return {
+                "success": True,
+                "analysis": response.text,
+                "file_name": os.path.basename(file_path)
+            }
+        except Exception as e:
+            logger.exception(f"Erro ao analisar documento {file_path}: {e}")
+            return {"success": False, "error": str(e)}
+
+    def _get_mime_type(self, file_path: str) -> str:
+        ext = os.path.splitext(file_path)[1].lower()
+        mapping = {
+            ".pdf": "application/pdf",
+            ".txt": "text/plain",
+            ".py": "text/plain",
+            ".js": "text/plain",
+            ".md": "text/plain",
+            ".json": "application/json"
+        }
+        return mapping.get(ext, "application/octet-stream")
+
+_analyzer = None
+
+def get_document_analyzer(api_key: str = "") -> DocumentAnalyzer:
+    global _analyzer
+    if not _analyzer:
+        _analyzer = DocumentAnalyzer(api_key)
+    return _analyzer

modules/improved_context_handler.py

@@ -0,0 +1,375 @@
+# type: ignore
+"""
+================================================================================
+IMPROVED CONTEXT HANDLER - Melhor gerenciamento de contexto para Akira
+================================================================================
+IMPORTANTE: Este módulo NÃO modifica context_builder.py ou contexto.py!
+Ele adiciona uma camada INTELIGENTE de análise de contexto para perguntas curtas.
+
+Função: Resolver o problema de perguntas curtas ("Oq é isso?") perdendo contexto
+Preserva: Toda a arquitetura e lógica existente do sistema de contexto
+================================================================================
+"""
+
+import re
+from typing import Dict, List, Optional, Tuple, Any
+from dataclasses import dataclass
+
+try:
+    from . import config
+except ImportError:
+    import modules.config as config
+
+
+@dataclass
+class ContextWeights:
+    """Pesos calculados para diferentes tipos de contexto."""
+    reply_context: float = 0.0
+    quoted_analysis: float = 0.0
+    short_term_memory: float = 1.0
+    vector_memory: float = 0.7
+    
+    def to_dict(self) -> Dict[str, float]:
+        """Converte para dicionário."""
+        return {
+            "reply_context": self.reply_context,
+            "quoted_analysis": self.quoted_analysis,
+            "short_term_memory": self.short_term_memory,
+            "vector_memory": self.vector_memory,
+        }
+
+
+@dataclass
+class QuestionAnalysis:
+    """Análise de uma pergunta."""
+    is_short:bool = False  # <= 5 palavras
+    is_very_short: bool = False  # <= 2 palavras
+    has_pronoun: bool = False  # tem "isso", "aquilo", "ele", etc
+    has_reply: bool = False
+    needs_context: bool = False  # precisa de contexto extra
+    question_type: str = "general"  # "what", "how", "where", "why", "general"
+
+
+class ImprovedContextHandler:
+    """
+    Gerenciador inteligente de contexto para perguntas curtas.
+    
+    IMPORTANTE:
+    - NÃO substitui o context_builder.py existente
+    - Funciona como HELPER para calcular pesos de contexto
+    - AUMENTA contexto para perguntas curtas com reply (contrário da lógica antiga)
+    """
+    
+    def __init__(self):
+        # Pronomes que indicam necessidade de contexto
+        self.context_pronouns = {
+            "isso", "aquilo", "este", "esse", "aquele",
+            "ele", "ela", "eles", "elas",
+            "la", "lo", "las", "los",  # "a la", "o lo"
+        }
+        
+        # Palavras interrogativas
+        self.question_words = {
+            "what": ["oq", "o que", "oque", "que é"],
+            "how": ["como"],
+            "where": ["onde", "aonde"],
+            "when": ["quando", "que horas"],
+            "why": ["porque", "porquê", "por que", "pq"],
+            "who": ["quem"],
+        }
+        
+        # Limites de palavras
+        self.very_short_threshold = 2  # "Oq é?"
+        self.short_threshold = 5  # "Como funciona isso?"
+    
+    def analyze_question(
+        self,
+        message: str,
+        reply_metadata: Optional[Dict[str, Any]] = None
+    ) -> QuestionAnalysis:
+        """
+        Analisa uma mensagem para determinar necessidade de contexto.
+        
+        Args:
+            message: Mensagem do usuário
+            reply_metadata: Metadados de reply (se for reply)
+            
+        Returns:
+            QuestionAnalysis com detalhes da análise
+        """
+        message_lower = message.lower().strip()
+        words = message_lower.split()
+        word_count = len(words)
+        
+        analysis = QuestionAnalysis()
+        
+        # Classifica tamanho
+        analysis.is_very_short = word_count <= self.very_short_threshold
+        analysis.is_short = word_count <= self.short_threshold
+        
+        # Detecta pronomes contextuais
+        analysis.has_pronoun = any(
+            pronoun in message_lower 
+            for pronoun in self.context_pronouns
+        )
+        
+        # Verifica se tem reply
+        if reply_metadata:
+            analysis.has_reply = reply_metadata.get("is_reply", False)
+        
+        # Detecta tipo de pergunta
+        for q_type, patterns in self.question_words.items():
+            if any(pattern in message_lower for pattern in patterns):
+                analysis.question_type = q_type
+                break
+        
+        # Determina se precisa de contexto extra
+        analysis.needs_context = (
+            analysis.is_short and 
+            (analysis.has_pronoun or analysis.has_reply)
+        )
+        
+        return analysis
+    
+    def calculate_context_weights(
+        self,
+        message: str,
+        reply_metadata: Optional[Dict[str, Any]] = None
+    ) -> ContextWeights:
+        """
+        Calcula pesos de contexto de forma inteligente.
+        
+        LÓGICA INVERTIDA da original:
+        - Perguntas curtas COM reply = MAIS contexto de reply
+        - Perguntas normais = balanço
+        - Sem reply = contexto geral
+        
+        Args:
+            message: Mensagem do usuário
+            reply_metadata: Metadados de reply
+            
+        Returns:
+            ContextWeights com pesos calculados
+        """
+        analysis = self.analyze_question(message, reply_metadata)
+        weights = ContextWeights()
+        
+        # CASO 1: Pergunta MUITO curta COM reply
+        # Exemplo: "Oq é isso?" (reply a mensagem sobre Radiohead)
+        if analysis.is_very_short and analysis.has_reply:
+            weights.reply_context = 1.0  # ✅ MÁXIMO para reply
+            weights.quoted_analysis = 0.95  # Analisa profundamente a citação
+            weights.short_term_memory = 0.8  # ✅ MANTÉM texto curto + contexto
+            weights.vector_memory = 0.3  # Fatos gerais baixo
+        
+        # CASO 2: Pergunta curta COM reply
+        # Exemplo: "Como funciona isso?" (reply a explicação técnica)
+        elif analysis.is_short and analysis.has_reply:
+            weights.reply_context = 0.9  # Alto para reply
+            weights.quoted_analysis = 0.85
+            weights.short_term_memory = 0.85  # ✅ MANTÉM texto curto no contexto
+            weights.vector_memory = 0.4
+        
+        # CASO 3: Pergunta curta COM pronome mas SEM reply
+        # Exemplo: "Oq é isso?" (sem reply - contexto ambíguo)
+        elif analysis.is_short and analysis.has_pronoun:
+            weights.reply_context = 0.0  # Sem reply
+            weights.quoted_analysis = 0.0
+            weights.short_term_memory = 1.0  # Usa histórico recente completo
+            weights.vector_memory = 0.8  # Busca memória de fatos
+        
+        # CASO 4: Pergunta normal COM reply
+        # Exemplo: "Você pode explicar melhor esse conceito?" (reply a explicação)
+        elif analysis.has_reply:
+            weights.reply_context = 0.8
+            weights.quoted_analysis = 0.7
+            weights.short_term_memory = 0.8
+            weights.vector_memory = 0.5
+        
+        # CASO 5: Pergunta normal SEM reply
+        # Exemplo: "Como funciona inteligência artificial?"
+        else:
+            weights.reply_context = 0.0
+            weights.quoted_analysis = 0.0
+            weights.short_term_memory = 1.0
+            weights.vector_memory = 0.7
+        
+        return weights
+    
+    def extract_quoted_content_deep(
+        self,
+        reply_metadata: Dict[str, Any]
+    ) -> str:
+        """
+        Extrai conteúdo citado de forma profunda.
+        Prioriza campos mais completos.
+        
+        Args:
+            reply_metadata: Metadados do reply
+            
+        Returns:
+            Conteúdo completo citado
+        """
+        # Ordem de prioridade (do mais completo para o menos)
+        priority_fields = [
+            "mensagem_citada",
+            "full_message",
+            "quoted_text_original",
+            "quoted_text",
+            "reply_content",
+            "context_hint",
+        ]
+        
+        for field in priority_fields:
+            if field in reply_metadata and reply_metadata[field]:
+                content = str(reply_metadata[field]).strip()
+                if len(content) > 5:  # Ignora conteúdos muito curtos
+                    return content
+        
+        # Fallback: tenta extrair de qualquer campo que pareça mensagem
+        for key, value in reply_metadata.items():
+            if isinstance(value, str) and len(value) > 10:
+                # Verifica se tem palavras comuns de mensagem
+                if any(word in value.lower() for word in ["eu", "você", "tu", "ele"]):
+                    return value.strip()
+        
+        return ""
+    
+    def analyze_quoted_content(
+        self,
+        quoted_content: str,
+        current_message: str
+    ) -> Dict[str, Any]:
+        """
+        Analisa conteúdo citado para entender o contexto.
+        
+        Args:
+            quoted_content: Conteúdo da mensagem citada
+            current_message: Mensagem atual do usuário
+            
+        Returns:
+            Análise do conteúdo citado
+        """
+        if not quoted_content:
+            return {"empty": True}
+        
+        quoted_lower = quoted_content.lower()
+        current_lower = current_message.lower()
+        
+        # Detecta tipo de conteúdo
+        content_type = "general"
+        if any(w in quoted_lower for w in ["?", "qual", "quando", "onde", "como", "por que"]):
+            content_type = "question"
+        elif any(w in quoted_lower for w in ["eu", "mim", "meu", "minha"]):
+            content_type = "personal"
+        elif any(w in quoted_lower for w in ["akira", "bot", "você", "vc"]):
+            content_type = "about_bot"
+        
+        # Extrai keywords principais
+        keywords = self._extract_keywords(quoted_content)
+        
+        # Detecta tom
+        tone = "neutral"
+        if any(w in quoted_lower for w in ["kkk", "haha", "😂", "🤣"]):
+            tone = "humorous"
+        elif any(w in quoted_lower for w in ["!!!", "???", "nossa", "eita"]):
+            tone = "excited"
+        
+        # Detecta se há informação técnica/específica
+        has_specific_info = any(
+            word in quoted_lower 
+            for word in ["Estudo", "Academica", "Programação", "Ciência", "política", "País"]
+        )
+        
+        return {
+            "content_type": content_type,
+            "keywords": keywords,
+            "tone": tone,
+            "length": len(quoted_content),
+            "has_question": "?" in quoted_content,
+            "has_specific_info": has_specific_info,
+        }
+    
+    def _extract_keywords(self, text: str, max_keywords: int = 5) -> List[str]:
+        """Extrai keywords principais do texto."""
+        # Remove stopwords comuns
+        stopwords = {
+            "o", "a", "de", "da", "do", "em", "para", "com", "por",
+            "que", "é", "um", "uma", "os", "as", "dos", "das",
+            "e", "ou", "mas", "se", "não", "sim",
+        }
+        
+        words = re.findall(r'\w+', text.lower())
+        keywords = [w for w in words if w not in stopwords and len(w) > 3]
+        
+        # Retorna os primeiros N
+        return keywords[:max_keywords]
+
+
+# ============================================================
+# FUNÇÕES DE CONVENIÊNCIA
+# ============================================================
+
+_handler_instance: Optional[ImprovedContextHandler] = None
+
+
+def get_context_handler() -> ImprovedContextHandler:
+    """Retorna instância singleton do handler."""
+    global _handler_instance
+    if _handler_instance is None:
+        _handler_instance = ImprovedContextHandler()
+    return _handler_instance
+
+
+def calculate_smart_context_weights(
+    message: str,
+    reply_metadata: Optional[Dict[str, Any]] = None
+) -> Dict[str, float]:
+    """
+    Função helper para calcular pesos de contexto inteligentemente.
+    
+    Args:
+        message: Mensagem do usuário
+        reply_metadata: Metadados de reply
+        
+    Returns:
+        Dict com pesos de contexto
+    """
+    handler = get_context_handler()
+    weights = handler.calculate_context_weights(message, reply_metadata)
+    return weights.to_dict()
+
+
+# ============================================================
+# EXEMPLO DE USO
+# ============================================================
+
+if __name__ == "__main__":
+    # Teste básico
+    handler = ImprovedContextHandler()
+    
+    test_cases = [
+        # (mensagem, tem_reply, descrição)
+        ("Oq é isso?", True, "Pergunta muito curta com reply"),
+        ("Como funciona isso?", True, "Pergunta curta com reply"),
+        ("Oq é isso?", False, "Pergunta curta SEM reply (ambígua)"),
+        ("Você pode explicar melhor esse conceito?", True, "Pergunta normal com reply"),
+        ("Como funciona inteligência artificial?", False, "Pergunta normal sem reply"),
+    ]
+    
+    print("=== TESTE DE PESOS DE CONTEXTO ===\n")
+    
+    for message, has_reply, description in test_cases:
+        print(f"Caso: {description}")
+        print(f"Mensagem: \"{message}\"")
+        print(f"Tem reply: {has_reply}")
+        
+        reply_meta = {"is_reply": has_reply} if has_reply else None
+        weights = handler.calculate_context_weights(message, reply_meta)
+        
+        print(f"Pesos calculados:")
+        print(f"  - Reply context: {weights.reply_context:.2f}")
+        print(f"  - Quoted analysis: {weights.quoted_analysis:.2f}")
+        print(f"  - Short-term memory: {weights.short_term_memory:.2f}")
+        print(f"  - Vector memory: {weights.vector_memory:.2f}")
+        print()

modules/local_llm.py

@@ -0,0 +1,532 @@
+# type: ignore
+"""
+modules/local_llm.py
+================================================================================
+FALLBACK LOCAL LLM - ÚLTIMA HIPÓTASE
+================================================================================
+Este módulo é usado SOMENTE quando TODAS as APIs externas falharem.
+Implementa um modelo local leve (TinyLlama ou equivalente) para respostas
+básicas em modo de emergência.
+
+Features:
+- Fallback final do sistema
+- Modelo pequeno (~1.5B parâmetros)
+- Respostas básicas em português/angolano
+- Não requer GPU
+================================================================================
+"""
+
+import os
+import re
+import time
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+
+# Imports opcionais com fallbacks
+try:
+    import torch  # type: ignore
+    TORCH_AVAILABLE = True
+except Exception:
+    TORCH_AVAILABLE = False
+    torch = None  # type: ignore
+
+try:
+    from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline  # type: ignore
+    TRANSFORMERS_AVAILABLE = True
+except Exception:
+    TRANSFORMERS_AVAILABLE = False
+    AutoTokenizer = None  # type: ignore
+    AutoModelForCausalLM = None  # type: ignore
+    pipeline = None  # type: ignore
+
+try:
+    from loguru import logger  # type: ignore
+    LOGURU_AVAILABLE = True
+except Exception:
+    LOGURU_AVAILABLE = False
+    # Criar logger dummy
+    class DummyLogger:
+        def info(self, *args, **kwargs): pass
+        def success(self, *args, **kwargs): pass
+        def warning(self, *args, **kwargs): pass
+        def error(self, *args, **kwargs): pass
+        def debug(self, *args, **kwargs): pass
+    logger = DummyLogger()  # type: ignore
+
+try:
+    from cachetools import TTLCache  # type: ignore
+    CACHETOOLS_AVAILABLE = True
+except Exception:
+    CACHETOOLS_AVAILABLE = False
+    # Implementação simples de cache fallback
+    class TTLCache(dict):
+        def __init__(self, maxsize=10, ttl=300, **kwargs):
+            super().__init__(**kwargs)
+            self.maxsize = maxsize
+            self.ttl = ttl
+            self._timestamps = {}
+        
+        def __setitem__(self, key, value):
+            super().__setitem__(key, value)
+            self._timestamps[key] = time.time()
+            # Limpa itens antigos se necessário
+            if len(self) > self.maxsize:
+                oldest_key = min(self._timestamps.keys(), key=lambda k: self._timestamps[k])
+                self.pop(oldest_key, None)
+                self._timestamps.pop(oldest_key, None)
+        
+        def get(self, key, default=None):
+            # Verifica se expirou
+            if key in self._timestamps:
+                if time.time() - self._timestamps[key] > self.ttl:
+                    self.pop(key, None)
+                    self._timestamps.pop(key, None)
+                    return default
+            return super().get(key, default)
+
+# Cache de prompts
+_prompt_cache: Any = None
+if CACHETOOLS_AVAILABLE:
+    try:
+        _prompt_cache = TTLCache(maxsize=10, ttl=300)
+    except Exception:
+        _prompt_cache = {}
+
+# ============================================================
+# 🎯 CONFIGURAÇÕES DO FALLBACK LOCAL
+# ============================================================
+
+# Modelos locais suportados (do mais leve ao mais pesado)
+LOCAL_LLM_MODELS = [
+    "TinyLlama/TinyLlama-1.1B-Chat-v1.0",  # ~1.1GB - Mais leve
+    "microsoft/Phi-3-mini-4k-instruct",     # ~2.4GB
+    "TheBloke/Llama-2-7b-chat-GGUF",        # ~4GB (precisa de conversão)
+    "meta-llama/Llama-2-7b-chat-hf",        # ~13GB
+]
+
+# Caminhos locais verificados
+LOCAL_MODEL_PATHS = [
+    "/app/models/tinyllama-1.1b",
+    "/app/models/phi-3-mini",
+    "/app/models/llama-2-7b",
+    "/models/tinyllama",
+    "/models/phi-3",
+]
+
+# Prompt do sistema para fallback (mais simples)
+FALLBACK_SYSTEM_PROMPT = """Você é Akira, uma IA assistente angolana.
+Responda de forma curta e direta (1-2 frases).
+Use português brasileiro com gírias angolanas quando natural.
+Se não souber a resposta, diga que está em modo de emergência.
+"""
+
+
+# ============================================================
+# 🏗️ CLASSE PRINCIPAL - LOCAL LLM FALLBACK
+# ============================================================
+
+class LocalLLMFallback:
+    """
+    Fallback local para quando TODAS as APIs externas falharem.
+    Carrega um modelo pequeno (TinyLlama ~1.1B) que funciona em CPU.
+    
+    IMPORTANTE: Esta classe só deve ser usada como ÚLTIMA opção.
+    """
+    
+    _instance = None
+    _model_lock = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+            cls._instance._model_lock = __import__('threading').Lock()
+        return cls._instance
+    
+    def __init__(self):
+        if self._initialized:
+            return
+        self._initialized = True
+        
+        # Componentes do modelo
+        self._model = None  # type: ignore
+        self._tokenizer = None  # type: ignore
+        self._pipeline = None  # type: ignore
+        self._model_path = None  # type: ignore
+        self._is_loaded = False
+        
+        # Configurações
+        self._max_tokens = 256  # Respostas curtas para CPU
+        self._temperature = 0.7
+        self._max_consecutive_failures = 3
+        self._consecutive_failures = 0
+        
+        # Estatísticas
+        self._stats = {
+            "total_calls": 0,
+            "successful_calls": 0,
+            "failed_calls": 0,
+            "last_used": None,
+            "model_loaded": False
+        }
+        
+        # Tenta detectar e carregar modelo
+        self._detect_and_load_model()
+    
+    def _detect_and_load_model(self) -> bool:
+        """Detecta e carrega modelo local se disponível."""
+        if not TORCH_AVAILABLE or not TRANSFORMERS_AVAILABLE:
+            logger.warning("Torch/Transformers não disponíveis. Local LLM desabilitado.")
+            return False
+        
+        with self._model_lock:
+            if self._is_loaded:
+                return True
+            
+            # Tenta encontrar modelo local
+            model_path = self._find_local_model()
+            
+            if model_path:
+                return self._load_model(model_path)
+            
+            logger.info("Nenhum modelo local encontrado. Local LLM desabilitado.")
+            return False
+    
+    def _find_local_model(self) -> Optional[str]:
+        """Procura modelo local em caminhos conhecidos."""
+        # 1. Verifica variável de ambiente
+        env_path = os.getenv("LOCAL_LLM_PATH")
+        if env_path and os.path.exists(env_path):
+            logger.info(f"Modelo local encontrado via env: {env_path}")
+            return env_path
+        
+        # 2. Verifica caminhos locais
+        for path in LOCAL_MODEL_PATHS:
+            if os.path.exists(path):
+                logger.info(f"Modelo local encontrado: {path}")
+                return path
+        
+        # 3. Tenta descargar TinyLlama (pequeno, ~1.1GB)
+        # Só faz download se explicitly habilitado
+        if os.getenv("LOCAL_LLM_AUTO_DOWNLOAD", "").lower() == "true":
+            logger.info("Auto-download habilitado. TinyLlama será baixado se necessário.")
+            return LOCAL_LLM_MODELS[0]
+        
+        return None
+    
+    def _load_model(self, model_path: str) -> bool:
+        """Carrega modelo local."""
+        try:
+            logger.info(f"🔄 Carregando modelo local: {model_path}")
+            
+            hf_token = os.getenv("HF_TOKEN")
+            
+            # Carrega tokenizer
+            self._tokenizer = AutoTokenizer.from_pretrained(
+                model_path,
+                token=hf_token,
+                padding_side="left"
+            )
+            
+            # Configura pad_token
+            if self._tokenizer.pad_token is None:
+                self._tokenizer.pad_token = self._tokenizer.eos_token
+            
+            # Carrega modelo (CPU apenas para compatibilidade)
+            self._model = AutoModelForCausalLM.from_pretrained(
+                model_path,
+                token=hf_token,
+                torch_dtype=torch.float32 if torch else None,
+                low_cpu_mem_usage=True,
+                device_map="auto" if TORCH_AVAILABLE else None
+            )
+            
+            # Cria pipeline
+            self._pipeline = pipeline(
+                "text-generation",
+                model=self._model,
+                tokenizer=self._tokenizer,
+                max_new_tokens=self._max_tokens,
+                temperature=self._temperature,
+                top_p=0.9,
+                do_sample=True,
+                repetition_penalty=1.1
+            )
+            
+            self._model_path = model_path
+            self._is_loaded = True
+            self._stats["model_loaded"] = True
+            
+            logger.success(f"✅ Modelo local carregado: {model_path}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Erro ao carregar modelo local: {e}")
+            self._is_loaded = False
+            return False
+    
+    def is_available(self) -> bool:
+        """Verifica se o fallback local está disponível."""
+        return self._is_loaded and self._pipeline is not None
+    
+    def is_operational(self) -> bool:
+        """Verifica se está operacional (pode responder)."""
+        return self.is_available() and self._consecutive_failures < self._max_consecutive_failures
+    
+    def generate(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+        temperature: Optional[float] = None
+    ) -> Optional[str]:
+        """
+        Gera resposta usando modelo local.
+        
+        Args:
+            prompt: Prompt do usuário
+            system_prompt: Prompt do sistema (usa default se None)
+            max_tokens: Máximo de tokens (usa default se None)
+            temperature: Temperatura de geração
+            
+        Returns:
+            String da resposta ou None se falhar
+        """
+        self._stats["total_calls"] += 1
+        
+        # Verifica disponibilidade
+        if not self.is_operational():
+            self._stats["failed_calls"] += 1
+            return None
+        
+        # Usa cache se disponível
+        cache_key = f"{prompt[:50]}:{system_prompt or 'default'}"
+        if _prompt_cache is not None:
+            cached = _prompt_cache.get(cache_key)
+            if cached:
+                logger.debug("Resposta encontrada em cache local")
+                return cached
+        
+        try:
+            # Prepara prompts
+            sys_prompt = system_prompt or FALLBACK_SYSTEM_PROMPT
+            
+            # Formata para modelo
+            if self._tokenizer and hasattr(self._tokenizer, 'chat_template') and False:
+                # Usa chat template se disponível
+                messages = [
+                    {"role": "system", "content": sys_prompt},
+                    {"role": "user", "content": prompt}
+                ]
+                formatted = self._tokenizer.apply_chat_template(
+                    messages,
+                    tokenize=False,
+                    add_generation_prompt=True
+                )
+            else:
+                # Formato simples (funciona com a maioria dos modelos)
+                formatted = f"""<|system|>
+{sys_prompt}
+</s>
+<|user|>
+{prompt}
+</s>
+<|assistant|>
+"""
+            
+            # Gera resposta
+            max_new = max_tokens or self._max_tokens
+            
+            outputs = self._pipeline(
+                formatted,
+                max_new_tokens=max_new,
+                temperature=temperature or self._temperature,
+                top_p=0.9,
+                do_sample=True,
+                pad_token_id=self._tokenizer.eos_token_id if self._tokenizer else None,
+                repetition_penalty=1.1
+            )
+            
+            # Extrai resposta
+            if outputs and len(outputs) > 0:
+                generated = outputs[0].get("generated_text", "")
+                
+                # Remove prompt da resposta
+                response = self._extract_response(generated, formatted)
+                response = self._clean_response(response)
+                
+                if response:
+                    # Cache se disponível
+                    if _prompt_cache is not None:
+                        try:
+                            _prompt_cache[cache_key] = response
+                        except Exception:
+                            pass
+                    
+                    self._stats["successful_calls"] += 1
+                    self._stats["last_used"] = datetime.now().isoformat()
+                    self._consecutive_failures = 0
+                    
+                    return response
+            
+            # Falha silenciosa
+            self._consecutive_failures += 1
+            self._stats["failed_calls"] += 1
+            return None
+            
+        except Exception as e:
+            logger.error(f"❌ Erro em fallback local: {e}")
+            self._consecutive_failures += 1
+            self._stats["failed_calls"] += 1
+            return None
+    
+    def _extract_response(self, generated: str, prompt: str) -> str:
+        """Extrai a resposta do texto gerado."""
+        if not generated:
+            return ""
+        
+        # Remove o prompt do início
+        if prompt in generated:
+            response = generated[len(prompt):]
+        else:
+            # Tenta encontrar padrão de separação
+            if "<|assistant|>" in generated:
+                response = generated.split("<|assistant|>")[-1]
+            elif "</s>" in generated and "<|user|>" in generated:
+                # Extrai após última tag de user
+                parts = generated.split("<|user|>")
+                if len(parts) > 1:
+                    response = parts[-1]
+                else:
+                    response = generated
+            else:
+                response = generated
+        
+        return response.strip()
+    
+    def _clean_response(self, text: str) -> str:
+        """Limpa a resposta gerada."""
+        # Remove tags e formatação
+        text = re.sub(r'<\|[^|]+\|>', '', text)
+        text = re.sub(r'</?s>', '', text)
+        text = re.sub(r'[\*\_\`\[\]\"]', '', text)
+        
+        # Normaliza espaços
+        text = re.sub(r'\s+', ' ', text).strip()
+        
+        # Limita tamanho (1 token ≈ 4 caracteres)
+        max_chars = self._max_tokens * 4
+        if len(text) > max_chars:
+            # Corta em sentença completa
+            sentences = [s.strip() + "." for s in text.split(".") if s.strip()]
+            result = ""
+            for sent in sentences:
+                if len(result + sent) <= max_chars:
+                    result += sent + " "
+                else:
+                    break
+            text = result.strip()
+        
+        return text
+    
+    def get_status(self) -> Dict[str, Any]:
+        """Retorna status do fallback local."""
+        return {
+            "available": self.is_available(),
+            "operational": self.is_operational(),
+            "model_path": self._model_path,
+            "model_loaded": self._is_loaded,
+            "consecutive_failures": self._consecutive_failures,
+            "max_failures_allowed": self._max_consecutive_failures,
+            "stats": self._stats.copy()
+        }
+    
+    def reset_failures(self):
+        """Reseta contador de falhas."""
+        self._consecutive_failures = 0
+    
+    def should_use_fallback(self, api_failures: int = 0) -> bool:
+        """
+        Decide se deve usar o fallback local.
+        
+        Args:
+            api_failures: Número de falhas consecutivas de APIs
+            
+        Returns:
+            True se deve usar fallback
+        """
+        # Só usa se:
+        # 1. Modelo está operacional
+        # 2. Houve pelo menos 1 falha de API OU está explicitamente habilitado
+        return (
+            self.is_operational() and
+            (api_failures > 0 or os.getenv("USE_LOCAL_FALLBACK", "").lower() == "true")
+        )
+
+
+# ============================================================
+# 🎯 FUNÇÃO PRINCIPAL DE FALLBACK
+# ============================================================
+
+def get_local_fallback() -> LocalLLMFallback:
+    """Retorna instância singleton do fallback local."""
+    return LocalLLMFallback()
+
+
+def generate_fallback_response(
+    prompt: str,
+    system_prompt: Optional[str] = None,
+    api_failures: int = 0
+) -> Optional[str]:
+    """
+    Gera resposta de fallback se necessário.
+    
+    Args:
+        prompt: Prompt do usuário
+        system_prompt: Prompt do sistema opcional
+        api_failures: Número de falhas de API
+        
+    Returns:
+        Resposta gerada ou None
+    """
+    fallback = get_local_fallback()
+    
+    if fallback.should_use_fallback(api_failures):
+        logger.info(f"🔴 Usando fallback local (API failures: {api_failures})")
+        return fallback.generate(prompt, system_prompt)
+    
+    return None
+
+
+# ============================================================
+# 🧪 MOCK PARA TESTES
+# ============================================================
+
+class MockLocalLLM:
+    """Mock para testes quando modelo não está disponível."""
+    
+    def is_available(self) -> bool:
+        return False
+    
+    def is_operational(self) -> bool:
+        return False
+    
+    def generate(self, prompt: str, **kwargs) -> str:
+        return "🤖 Modo de emergência: Todas as APIs falharam. Tente novamente mais tarde."
+    
+    def get_status(self) -> Dict[str, Any]:
+        return {"available": False, "mock": True}
+
+
+# ============================================================
+# 📤 EXPORTS
+# ============================================================
+
+__all__ = [
+    "LocalLLMFallback",
+    "get_local_fallback",
+    "generate_fallback_response",
+    "MockLocalLLM",
+    "FALLBACK_SYSTEM_PROMPT",
+]
+

modules/nlp_avancado.py

@@ -0,0 +1,701 @@
+# type: ignore
+"""
+NLP Avançado de Nível Acadêmico - AKIRA V21 ULTIMATE
+Sistema de processamento de linguagem natural ultra-potente
+Capaz de modificar prompts e respostas da API em tempo real
+"""
+import re
+import time
+import threading
+from typing import Dict, Any, List, Optional, Tuple
+from dataclasses import dataclass, field
+from collections import defaultdict
+import numpy as np
+
+# ============================================================
+# 🎯 CONFIGURAÇÃO NLP AVANÇADO
+# ============================================================
+
+@dataclass
+class NLPAdvancedConfig:
+    """Configuração do NLP Avançado de Nível Acadêmico"""
+    # Nível de agressividade na modificação do prompt
+    prompt_modification_aggression: float = 0.8  # 0.0-1.0
+    
+    # Threshold de confiança para mudanças
+    confidence_threshold: float = 0.75
+    
+    # Enable/disable features
+    enable_semantic_analysis: bool = True
+    enable_academic_detection: bool = True
+    enable_context_enhancement: bool = True
+    enable_response_modification: bool = True
+    enable_emotion_amplification: bool = True
+    
+    # Modelos de análise
+    use_bert_for_semantic: bool = True
+    use_embeddings_for_similarity: bool = True
+    
+    # Cache settings
+    cache_size: int = 1000
+    cache_ttl_seconds: int = 3600
+
+
+class AcademicTermDetector:
+    """Detector de termos acadêmicos e científicos"""
+    
+    ACADEMIC_PATTERNS = {
+        # Campos acadêmicos
+        'ciencias_exatas': [
+            r'\b(matemática|física|química|biologia|estatística|probabilidade)\b',
+            r'\b(teorema|prova|demonstração|equação|variável|função)\b',
+            r'\b(cálculo|álgebra|geometria|trigonometria)\b',
+        ],
+        'ciencias_humanas': [
+            r'\b(filosofia|história|sociologia|psicologia|antropologia)\b',
+            r'\b(teoria|hipótese|tese|dissertação|monografia)\b',
+            r'\b(marxismo|estruturalismo|fenomenologia)\b',
+        ],
+        'engenharia_tech': [
+            r'\b(engenharia|programação|algoritmo|arquitetura)\b',
+            r'\b(sistema|rede|banco de dados|backend|frontend)\b',
+            r'\b(machine learning|inteligência artificial|IA)\b',
+        ],
+        'direito': [
+            r'\b(direito|lei|artigo|parágrafo|jurídico)\b',
+            r'\b(constituição|código civil|código penal)\b',
+            r'\b(advogado|juiz|ministério público|delegacia)\b',
+        ],
+        'medicina': [
+            r'\b(medicina|saúde|diagnóstico|tratamento)\b',
+            r'\b(fármaco|medicamento|biológico|sintético)\b',
+            r'\b(hospital|clínica|ambulatório|UTI)\b',
+        ],
+        'economia': [
+            r'\b(economia|mercado|inflação|juros|PIB)\b',
+            r'\b(monetário|fiscal|política econômica)\b',
+            r'\b(ações|bônus|investimento|rendimento)\b',
+        ],
+    }
+    
+    ACADEMIC_INDICATORS = [
+        # Palavras que indicam contexto acadêmico
+        r'\b(cite|referência|bibliografia|fonte)\b',
+        r'\b(estudo|pesquisa|investigação|análise)\b',
+        r'\b(teórico|empírico|metodologia|metodológico)\b',
+        r'\b(conclusão|resultados|discussão|abstract)\b',
+        r'\b(revisão|literatura|framework|modelo)\b',
+        r'\b(hipótese|variável|indicador|índice)\b',
+        r'\b(significância|relevância|validade)\b',
+    ]
+    
+    def __init__(self):
+        self._compiled_patterns = {}
+        self._compile_patterns()
+    
+    def _compile_patterns(self):
+        """Compila todos os padrões para eficiência"""
+        for category, patterns in self.ACADEMIC_PATTERNS.items():
+            compiled = [re.compile(p, re.IGNORECASE) for p in patterns]
+            self._compiled_patterns[category] = compiled
+        
+        self._academic_indicators = [
+            re.compile(p, re.IGNORECASE) for p in self.ACADEMIC_INDICATORS
+        ]
+    
+    def detect(self, text: str) -> Dict[str, Any]:
+        """Detecta contexto acadêmico no texto"""
+        text_lower = text.lower()
+        
+        detected_fields = []
+        field_confidences = {}
+        
+        for category, patterns in self._compiled_patterns.items():
+            matches = []
+            for pattern in patterns:
+                found = pattern.findall(text_lower)
+                matches.extend(found)
+            
+            if matches:
+                confidence = min(0.95, 0.5 + (len(matches) * 0.15))
+                detected_fields.append(category)
+                field_confidences[category] = confidence
+        
+        # Indicators
+        indicator_count = 0
+        for indicator in self._academic_indicators:
+            if indicator.search(text_lower):
+                indicator_count += 1
+        
+        academic_confidence = min(0.95, 0.3 + (indicator_count * 0.1))
+        
+        return {
+            'is_academic': indicator_count >= 2 or len(detected_fields) >= 2,
+            'academic_confidence': academic_confidence,
+            'detected_fields': detected_fields,
+            'field_confidences': field_confidences,
+            'indicator_count': indicator_count,
+            'academic_level': self._calculate_academic_level(text, detected_fields, indicator_count)
+        }
+    
+    def _calculate_academic_level(self, text: str, fields: List[str], indicators: int) -> str:
+        """Calcula o nível acadêmico do texto"""
+        word_count = len(text.split())
+        
+        # Very formal academic
+        if indicators >= 4 and word_count > 100:
+            return "phd"
+        elif indicators >= 3 and word_count > 50:
+            return "masters"
+        elif indicators >= 2 and word_count > 30:
+            return "undergraduate"
+        elif indicators >= 1 or fields:
+            return "high_school"
+        else:
+            return "casual"
+
+
+class SemanticAnalyzer:
+    """Analisador semântico profundo"""
+    
+    def __init__(self, embedding_model=None):
+        self.embedding_model = embedding_model
+        self._semantic_cache = {}
+        self._semantic_lock = threading.Lock()
+    
+    def analyze(self, text: str, context: Optional[List[str]] = None) -> Dict[str, Any]:
+        """Análise semântica completa"""
+        
+        # Cache check
+        cache_key = hash(text)
+        if cache_key in self._semantic_cache:
+            cached = self._semantic_cache[cache_key]
+            if time.time() - cached['timestamp'] < 3600:
+                return cached['result']
+        
+        # Basic semantic analysis
+        analysis = {
+            'entities': self._extract_entities(text),
+            'concepts': self._extract_concepts(text),
+            'relations': self._extract_relations(text),
+            'sentiment': self._analyze_sentiment(text),
+            'formality': self._analyze_formality(text),
+            'complexity': self._analyze_complexity(text),
+            'topics': self._extract_topics(text),
+            'keywords': self._extract_keywords(text),
+        }
+        
+        # Context enhancement
+        if context:
+            analysis['context_coherence'] = self._check_context_coherence(text, context)
+        
+        # Store in cache
+        with self._semantic_lock:
+            self._semantic_cache[cache_key] = {
+                'timestamp': time.time(),
+                'result': analysis
+            }
+        
+        return analysis
+    
+    def _extract_entities(self, text: str) -> List[Dict[str, Any]]:
+        """Extrai entidades do texto"""
+        entities = []
+        
+        # Patterns for common entity types
+        patterns = {
+            'person': r'\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)+)\b',
+            'organization': r'\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b',
+            'date': r'\b(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})\b',
+            'money': r'\b(R\$|USD|EUR|\$)\s*\d+(?:[.,]\d{2})?\b',
+            'location': r'\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b',
+        }
+        
+        for entity_type, pattern in patterns.items():
+            matches = re.findall(pattern, text)
+            for match in matches:
+                entities.append({
+                    'type': entity_type,
+                    'value': match if isinstance(match, str) else match[0] if match else '',
+                    'position': text.find(match[0]) if isinstance(match, tuple) else -1
+                })
+        
+        return entities
+    
+    def _extract_concepts(self, text: str) -> List[str]:
+        """Extrai conceitos principais"""
+        concepts = []
+        
+        # Look for noun phrases and important concepts
+        stopwords = {'o', 'a', 'de', 'da', 'do', 'em', 'para', 'com', 'não', 'é', 'são'}
+        words = text.lower().split()
+        
+        for i, word in enumerate(words):
+            if word not in stopwords and len(word) > 4:
+                concepts.append(word)
+        
+        return list(set(concepts))[:10]
+    
+    def _extract_relations(self, text: str) -> List[Dict[str, str]]:
+        """Extrai relações entre conceitos"""
+        relations = []
+        
+        # Pattern: X é/foi/será Y
+        relation_patterns = [
+            (r'(\w+)\s+é\s+(\w+)', 'is_a'),
+            (r'(\w+)\s+foi\s+(\w+)', 'was'),
+            (r'(\w+)\s+tem\s+(\w+)', 'has'),
+            (r'(\w+)\s+pertence\s+a\s+(\w+)', 'belongs_to'),
+        ]
+        
+        for pattern, rel_type in relation_patterns:
+            matches = re.findall(pattern, text.lower())
+            for match in matches:
+                relations.append({
+                    'subject': match[0],
+                    'relation': rel_type,
+                    'object': match[1] if len(match) > 1 else ''
+                })
+        
+        return relations
+    
+    def _analyze_sentiment(self, text: str) -> Dict[str, Any]:
+        """Análise de sentimento detalhada"""
+        text_lower = text.lower()
+        
+        positive_words = ['bom', 'ótimo', 'excelente', 'fixe', 'feliz', 'alegre', 'amor', 'gosto']
+        negative_words = ['ruim', 'péssimo', 'terrível', 'odio', 'triste', 'raiva', 'raivoso']
+        neutral_words = ['neutro', 'normal', 'tanto faz']
+        
+        pos_count = sum(1 for w in positive_words if w in text_lower)
+        neg_count = sum(1 for w in negative_words if w in text_lower)
+        
+        if pos_count > neg_count:
+            sentiment = 'positive'
+            score = min(0.95, 0.5 + (pos_count * 0.1))
+        elif neg_count > pos_count:
+            sentiment = 'negative'
+            score = min(0.95, 0.5 + (neg_count * 0.1))
+        else:
+            sentiment = 'neutral'
+            score = 0.5
+        
+        return {
+            'sentiment': sentiment,
+            'score': score,
+            'positive_count': pos_count,
+            'negative_count': neg_count
+        }
+    
+    def _analyze_formality(self, text: str) -> Dict[str, Any]:
+        """Análise de formalidade"""
+        text_lower = text.lower()
+        
+        formal_indicators = [
+            'senhor', 'doutor', 'professor', 'agradecido', 'gentilmente',
+            'por favor', 'conforme', 'destarte', 'outrossim', 'visto'
+        ]
+        
+        informal_indicators = [
+            'puto', 'mano', 'kkk', 'tio', 'bro', 'fala', 'eae', 'vlw'
+        ]
+        
+        formal_count = sum(1 for w in formal_indicators if w in text_lower)
+        informal_count = sum(1 for w in informal_indicators if w in text_lower)
+        
+        formality_score = 0.5
+        if formal_count > informal_count:
+            formality_score = min(0.9, 0.5 + (formal_count * 0.1))
+        elif informal_count > formal_count:
+            formality_score = max(0.1, 0.5 - (informal_count * 0.1))
+        
+        return {
+            'formality_score': formality_score,
+            'formal_level': 'formal' if formality_score > 0.6 else 'informal' if formality_score < 0.4 else 'neutral',
+            'formal_indicators': formal_count,
+            'informal_indicators': informal_count
+        }
+    
+    def _analyze_complexity(self, text: str) -> Dict[str, Any]:
+        """Análise de complexidade do texto"""
+        words = text.split()
+        sentences = re.split(r'[.!?]+', text)
+        
+        avg_word_length = np.mean([len(w) for w in words]) if words else 0
+        avg_sentence_length = len(words) / max(len(sentences), 1)
+        
+        # Complex words (more than 10 characters)
+        complex_words = [w for w in words if len(w) > 10]
+        complexity_ratio = len(complex_words) / max(len(words), 1)
+        
+        # Calculate complexity score
+        complexity_score = min(1.0, (
+            (avg_word_length / 10) * 0.3 +
+            (avg_sentence_length / 20) * 0.3 +
+            (complexity_ratio * 2) * 0.4
+        ))
+        
+        return {
+            'complexity_score': complexity_score,
+            'avg_word_length': avg_word_length,
+            'avg_sentence_length': avg_sentence_length,
+            'complex_word_ratio': complexity_ratio,
+            'complexity_level': 'high' if complexity_score > 0.7 else 'medium' if complexity_score > 0.4 else 'low'
+        }
+    
+    def _extract_topics(self, text: str) -> List[str]:
+        """Extrai tópicos principais"""
+        topics = []
+        
+        # Simple keyword extraction
+        important_words = []
+        stopwords = {'o', 'a', 'de', 'da', 'do', 'em', 'para', 'com', 'não', 'é', 'são', 'um', 'uma', 'os', 'as'}
+        
+        for word in text.lower().split():
+            if word not in stopwords and len(word) > 3:
+                important_words.append(word)
+        
+        # Count frequency
+        word_freq = defaultdict(int)
+        for word in important_words:
+            word_freq[word] += 1
+        
+        # Get top topics
+        sorted_words = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)
+        topics = [w[0] for w in sorted_words[:5]]
+        
+        return topics
+    
+    def _extract_keywords(self, text: str) -> List[str]:
+        """Extrai palavras-chave"""
+        return self._extract_concepts(text)
+    
+    def _check_context_coherence(self, text: str, context: List[str]) -> float:
+        """Verifica coerência com contexto anterior"""
+        if not context:
+            return 0.5
+        
+        text_lower = text.lower()
+        context_text = ' '.join(context).lower()
+        
+        # Check for topic continuity
+        text_words = set(text_lower.split())
+        context_words = set(context_text.split())
+        
+        # Jaccard similarity
+        intersection = len(text_words & context_words)
+        union = len(text_words | context_words)
+        
+        similarity = intersection / max(union, 1)
+        
+        return similarity
+
+
+class PromptModifier:
+    """Modificador de prompts para nível acadêmico"""
+    
+    ACADEMIC_ENHANCEMENTS = {
+        'formal_intro': [
+            "Considerando os pressupostos teóricos relevantes e a literatura especializada, ",
+            "Do ponto de vista epistemológico, ",
+            "À luz das contribuições recentes no campo, ",
+            "Em consonância com a tradição acadêmica, ",
+        ],
+        'academic_bridges': [
+            "Destarte, ",
+            "Outrossim, ",
+            "Nessa perspectiva, ",
+            "Diante do exposto, ",
+            "Por conseguinte, ",
+        ],
+        'critical_questions': [
+            "Qual a implicação disso para a teoria?",
+            "Como isso se relaciona com a literatura existente?",
+            "Quais as limitações dessa análise?",
+            "Como operacionalizar esse conceito?",
+        ],
+        'methodological_notes': [
+            "Do ponto de vista metodológico, ",
+            "Considerando a abordagem adotada, ",
+            "A partir de uma perspectiva empírica, ",
+            "Teoricamente fundamentado em, ",
+        ],
+    }
+    
+    def __init__(self, config: NLPAdvancedConfig):
+        self.config = config
+        self.academic_detector = AcademicTermDetector()
+    
+    def modify_prompt(self, original_prompt: str, semantic_analysis: Dict[str, Any], 
+                      user_context: Optional[Dict[str, Any]] = None) -> str:
+        """Modifica o prompt para nível acadêmico se necessário"""
+        
+        if not self.config.enable_context_enhancement:
+            return original_prompt
+        
+        # Detect academic context
+        academic_info = self.academic_detector.detect(original_prompt)
+        
+        # If academic, enhance the prompt
+        if academic_info['is_academic'] and academic_info['academic_confidence'] > self.config.confidence_threshold:
+            enhanced_prompt = self._academicize(original_prompt, academic_info, semantic_analysis)
+            return enhanced_prompt
+        
+        return original_prompt
+    
+    def _academicize(self, prompt: str, academic_info: Dict[str, Any], 
+                     semantic: Dict[str, Any]) -> str:
+        """Converte prompt para formato acadêmico"""
+        
+        # Add formal introduction if prompt is short
+        if len(prompt.split()) < 20:
+            intro = np.random.choice(self.ACADEMIC_ENHANCEMENTS['formal_intro'])
+            prompt = intro + prompt
+        
+        # Add academic bridging if continuing discussion
+        if semantic.get('context_coherence', 0) > 0.3:
+            bridge = np.random.choice(self.ACADEMIC_ENHANCEMENTS['academic_bridges'])
+            prompt = prompt + " " + bridge.rstrip(',') + ", "
+        
+        # Enhance with methodological note if appropriate
+        if academic_info['academic_level'] in ['phd', 'masters']:
+            method_note = np.random.choice(self.ACADEMIC_ENHANCEMENTS['methodological_notes'])
+            prompt = method_note + prompt
+        
+        return prompt
+
+
+class ResponseModifier:
+    """Modificador de respostas para nível acadêmico"""
+    
+    def __init__(self, config: NLPAdvancedConfig):
+        self.config = config
+        self.academic_detector = AcademicTermDetector()
+    
+    def modify_response(self, response: str, original_prompt: str, 
+                        semantic_analysis: Dict[str, Any]) -> str:
+        """Modifica a resposta da API se necessário"""
+        
+        if not self.config.enable_response_modification:
+            return response
+        
+        academic_info = self.academic_detector.detect(original_prompt)
+        
+        # If academic context, enhance response
+        if academic_info['is_academic']:
+            enhanced = self._academicize_response(response, academic_info, semantic_analysis)
+            return enhanced
+        
+        return response
+    
+    def _academicize_response(self, response: str, academic_info: Dict[str, Any],
+                              semantic: Dict[str, Any]) -> str:
+        """Academiciza a resposta"""
+        
+        # Add nuance if response is too simplistic
+        if semantic.get('complexity', {}).get('complexity_level') == 'low':
+            response = self._add_nuance(response, academic_info)
+        
+        # Add critical thinking element
+        if academic_info['academic_level'] in ['phd', 'masters']:
+            response = self._add_critical_element(response, academic_info)
+        
+        return response
+    
+    def _add_nuance(self, response: str, academic_info: Dict[str, Any]) -> str:
+        """Adiciona nuances à resposta"""
+        nuances = [
+            " do ponto de vista teórico, ",
+            " considerando as variáveis relevantes, ",
+            " observadas as devidas ressalvas, ",
+            " ressalvados os limites da análise, ",
+        ]
+        
+        if len(response.split()) < 15:
+            nuance = np.random.choice(nuances)
+            # Insert nuance somewhere in the response
+            words = response.split()
+            insert_pos = len(words) // 2
+            words.insert(insert_pos, nuance.strip())
+            response = ' '.join(words)
+        
+        return response
+    
+    def _add_critical_element(self, response: str, academic_info: Dict[str, Any]) -> str:
+        """Adiciona elemento de pensamento crítico"""
+        critical_elements = [
+            "\n\nNota crítica: Esta análise pressupõe X, mas Y pode desafiar essa conclusão.",
+            "\n\nConsiderando as limitações metodológicas, os resultados devem ser interpretados com cautela.",
+            "\nDo ponto de vista epistemológico, cabe questionar: quais as premissas subjacentes?",
+        ]
+        
+        if len(response.split()) > 30:
+            element = np.random.choice(critical_elements)
+            response = response + element
+        
+        return response
+
+
+class EmotionAmplifier:
+    """Amplificador de emoções para modelo de moções"""
+    
+    EMOTION_MAPPING = {
+        'joy': {
+            'intensity_words': ['muito', 'bastante', 'extremamente', 'intensamente'],
+            'action_words': ['celebrar', 'comemorar', 'alegrar-se'],
+        },
+        'sadness': {
+            'intensity_words': ['profundamente', 'intensamente', ['muito']],
+            'action_words': ['lamentar', 'entristecer-se', 'afligir-se'],
+        },
+        'anger': {
+            'intensity_words': ['intensamente', 'bastante', 'muito'],
+            'action_words': ['irritar-se', 'enfurecer-se', 'indignar-se'],
+        },
+        'fear': {
+            'intensity_words': ['bastante', 'muito', 'intensamente'],
+            'action_words': ['preocupar-se', 'ansiar', 'temer'],
+        },
+    }
+    
+    def __init__(self, config: NLPAdvancedConfig):
+        self.config = config
+    
+    def amplify(self, emotion_data: Dict[str, Any], text: str) -> Dict[str, Any]:
+        """Amplifica a detecção emocional"""
+        
+        if not self.config.enable_emotion_amplification:
+            return emotion_data
+        
+        emotion = emotion_data.get('emotion', 'neutral')
+        
+        if emotion in self.EMOTION_MAPPING:
+            mapping = self.EMOTION_MAPPING[emotion]
+            
+            # Check for intensity words
+            text_lower = text.lower()
+            intensity_count = sum(1 for w in mapping['intensity_words'] if w in text_lower)
+            
+            if intensity_count > 0:
+                # Amplify the emotion
+                original_confidence = emotion_data.get('confidence', 0.5)
+                amplified_confidence = min(0.98, original_confidence + (intensity_count * 0.1))
+                
+                emotion_data['confidence'] = amplified_confidence
+                emotion_data['intensity'] = 'high' if intensity_count >= 2 else 'medium'
+                emotion_data['amplified'] = True
+            else:
+                emotion_data['intensity'] = 'low'
+                emotion_data['amplified'] = False
+        
+        return emotion_data
+
+
+class AdvancedNLP:
+    """Sistema NLP Avançado Principal"""
+    
+    def __init__(self, config: Optional[NLPAdvancedConfig] = None):
+        self.config = config or NLPAdvancedConfig()
+        
+        self.semantic_analyzer = SemanticAnalyzer()
+        self.prompt_modifier = PromptModifier(self.config)
+        self.response_modifier = ResponseModifier(self.config)
+        self.emotion_amplifier = EmotionAmplifier(self.config)
+        self.academic_detector = AcademicTermDetector()
+        
+        # Statistics
+        self.stats = {
+            'total_analyses': 0,
+            'academic_prompts': 0,
+            'modified_prompts': 0,
+            'modified_responses': 0,
+            'avg_confidence': 0.0
+        }
+    
+    def process_input(self, text: str, context: Optional[List[str]] = None,
+                      user_info: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Processa entrada completa"""
+        
+        self.stats['total_analyses'] += 1
+        
+        # Semantic analysis
+        semantic = self.semantic_analyzer.analyze(text, context)
+        
+        # Academic detection
+        academic = self.academic_detector.detect(text)
+        if academic['is_academic']:
+            self.stats['academic_prompts'] += 1
+        
+        # Prompt modification
+        modified_prompt = self.prompt_modifier.modify_prompt(text, semantic, user_info)
+        if modified_prompt != text:
+            self.stats['modified_prompts'] += 1
+        
+        # Emotion amplification
+        emotion_data = semantic.get('sentiment', {})
+        amplified_emotion = self.emotion_amplifier.amplify(emotion_data, text)
+        
+        return {
+            'original_text': text,
+            'modified_prompt': modified_prompt,
+            'semantic_analysis': semantic,
+            'academic_info': academic,
+            'emotion_data': amplified_emotion,
+            'needs_academic_mode': academic['is_academic'] and academic['academic_confidence'] > 0.7,
+            'academic_level': academic['academic_level'],
+        }
+    
+    def process_output(self, response: str, original_prompt: str,
+                       semantic: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Processa saída (modifica resposta se necessário)"""
+        
+        modified_response = self.response_modifier.modify_response(
+            response, original_prompt, semantic or {}
+        )
+        
+        if modified_response != response:
+            self.stats['modified_responses'] += 1
+        
+        return {
+            'original_response': response,
+            'modified_response': modified_response,
+            'was_modified': modified_response != response,
+        }
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Retorna estatísticas"""
+        stats = self.stats.copy()
+        stats['avg_confidence'] = (
+            stats['academic_prompts'] / max(stats['total_analyses'], 1)
+        )
+        return stats
+
+
+# ============================================================
+# 🔄 SINGLETON
+# ============================================================
+
+_advanced_nlp: Optional[AdvancedNLP] = None
+
+def get_advanced_nlp(config: Optional[NLPAdvancedConfig] = None) -> AdvancedNLP:
+    """Obtém instância do NLP Avançado"""
+    global _advanced_nlp
+    if _advanced_nlp is None:
+        _advanced_nlp = AdvancedNLP(config)
+    return _advanced_nlp
+
+
+# ============================================================
+# 🎯 EXPORTAÇÃO
+# ============================================================
+
+__all__ = [
+    'NLPAdvancedConfig',
+    'AcademicTermDetector',
+    'SemanticAnalyzer',
+    'PromptModifier',
+    'ResponseModifier',
+    'EmotionAmplifier',
+    'AdvancedNLP',
+    'get_advanced_nlp',
+]

modules/persona_tracker.py

@@ -0,0 +1,121 @@
+import json
+import threading
+from loguru import logger
+from typing import List, Dict, Any, Optional
+
+try:
+    from modules.database import Database
+except ImportError:
+    from database import Database
+
+class PersonaTracker:
+    """
+    Rastreador de Persona em Background (Character.AI style LTM).
+    Analisa as conversas recentes do usuário silenciosamente e extrai
+    seus traços de personalidade, gostos e emoções no banco de dados.
+    """
+    
+    def __init__(self, db: Database, llm_client: Any):
+        """
+        Args:
+            db (Database): Instância do banco de dados (database.py)
+            llm_client (Any): Instância do cliente LLM (ex: MultiLLMClient)
+        """
+        self.db = db
+        self.llm_client = llm_client
+        self.processing_users = set()
+
+    def track_background(self, numero_usuario: str, historico_recente: List[Dict[str, str]]) -> None:
+        """
+        Dispara a análise de persona em background para não bloquear a resposta do bot.
+        
+        Args:
+            numero_usuario: ID ou número do usuário.
+            historico_recente: Lista de dicionários {'role': '...', 'content': '...'} com as últimas mensagens do usuário.
+        """
+        if numero_usuario in self.processing_users:
+            return  # Já está a ser analisado neste momento
+            
+        if not historico_recente or len(historico_recente) < 3:
+            return  # Muito pouco contexto para extrair algo útil
+            
+        self.processing_users.add(numero_usuario)
+        
+        thread = threading.Thread(
+            target=self._analyze_and_save,
+            args=(numero_usuario, historico_recente),
+            daemon=True
+        )
+        thread.start()
+
+    def _analyze_and_save(self, numero_usuario: str, historico: List[Dict[str, str]]) -> None:
+        """Método interno que roda na Thread."""
+        try:
+            # Recupera a persona atual para o LLM saber o que já sabemos
+            persona_atual = self.db.recuperar_persona(numero_usuario) or {}
+            
+            # Formata histórico apenas com as falas do usuário
+            user_messages = [msg['content'] for msg in historico if msg.get('role') == 'user']
+            if not user_messages:
+                return
+                
+            historico_texto = "\n".join([f"User: {msg}" for msg in user_messages[-10:]]) # Últimas 10 msg
+            
+            perfil_atual_str = json.dumps(persona_atual, ensure_ascii=False) if persona_atual else "Ainda não definido."
+            
+            prompt = f"""Você é um analista comportamental focado em rastreamento de persona (Long-Term Memory).
+Analise as mensagens recentes deste usuário e atualize/extraia o seu perfil.
+
+[PERFIL ATUAL NO BANCO DE DADOS]
+{perfil_atual_str}
+
+[MENSAGENS RECENTES]
+{historico_texto}
+
+EXTRAIA/ATUALIZE os seguintes traços com base APENAS nas mensagens recentes e no perfil atual. Mantenha os traços do perfil atual que não foram contraditórios.
+Seja CONCISO. Use bullet points curtos na sua mente e preencha os campos em formato JSON estrito.
+
+Retorne APENAS um JSON válido estruturado assim (e NADA de texto fora das chaves):
+{{
+    "personalidade": "Resumo calmo, agressivo, divertido, direto, etc.",
+    "vicios_linguagem": "Expressões ou gírias que ele usa muito.",
+    "gostos": "O que ele demonstrou gostar ou tópicos de interesse.",
+    "desgostos": "O que o irrita, o que ele odeia.",
+    "emocional": "Traços emocionais, forças ou gatilhos/fraquezas."
+}}
+"""
+            
+            # Chama o LLM (garante formato json)
+            # O MultiLLMClient / AkiraAPI tem _generate_response(prompt, context_history)
+            response_json_str = self.llm_client._generate_response(prompt, [])
+            
+            if not response_json_str:
+                return
+                
+            # Extrai o JSON (caso o LLM coloque blocos de markdown)
+            response_json_str = response_json_str.strip()
+            if response_json_str.startswith("```json"):
+                response_json_str = response_json_str.split("```json")[1]
+            if response_json_str.endswith("```"):
+                response_json_str = response_json_str[:response_json_str.rfind("```")]
+                
+            dados_extraidos = json.loads(response_json_str.strip())
+            
+            # Limpa chaves inválidas
+            chaves_validas = ["personalidade", "vicios_linguagem", "gostos", "desgostos", "emocional"]
+            campos_atualizar = {k: str(v) for k, v in dados_extraidos.items() if k in chaves_validas}
+            
+            if campos_atualizar:
+                sucesso = self.db.atualizar_persona(numero_usuario, campos_atualizar)
+                if sucesso:
+                    logger.info(f"Persona LTM atualizada para o usuário {numero_usuario} em background.")
+                else:
+                    logger.warning(f"Falha ao salvar a persona no banco para {numero_usuario}.")
+                    
+        except json.JSONDecodeError:
+            logger.warning(f"Falha no Parser JSON do Persona Tracker para {numero_usuario}.")
+        except Exception as e:
+            logger.error(f"Erro no Persona Tracker background: {e}")
+        finally:
+            if numero_usuario in self.processing_users:
+                self.processing_users.remove(numero_usuario)

modules/reply_context_handler.py

@@ -0,0 +1,697 @@
+# type: ignore
+"""
+================================================================================
+AKIRA V21 ULTIMATE - REPLY CONTEXT HANDLER MODULE
+================================================================================
+Sistema dedicado para processar e priorizar contexto de replies.
+Garante que replies tenham prioridade ligeiramente maior que o contexto geral,
+especialmente em perguntas curtas.
+
+Features:
+- Extração e processamento de metadados de reply
+- 3 níveis de prioridade (1=normal, 2=reply, 3=reply-to-bot+pergunta-curta)
+- Construção de prompt sections otimizadas para replies
+- Integração com ShortTermMemory
+- Context hint extraction para melhor compreensão
+================================================================================
+"""
+
+import os
+import sys
+import time
+import json
+import re
+import logging
+from typing import Optional, Dict, Any, List, Tuple
+from dataclasses import dataclass, field
+
+# Imports robustos com fallback - CORRIGIDO para usar modules.
+try:
+    import modules.config as config
+    from .short_term_memory import ShortTermMemory, MessageWithContext, IMPORTANCIA_REPLY, IMPORTANCIA_REPLY_TO_BOT, IMPORTANCIA_PERGUNTA_CURTA_REPLY
+    REPLY_HANDLER_AVAILABLE = True
+except ImportError:
+    try:
+        from . import config
+        from .short_term_memory import ShortTermMemory, MessageWithContext
+        REPLY_HANDLER_AVAILABLE = True
+    except ImportError:
+        REPLY_HANDLER_AVAILABLE = False
+        config = None
+
+logger = logging.getLogger(__name__)
+
+# ============================================================
+# NÍVEIS DE PRIORIDADE
+# ============================================================
+
+PRIORITY_NORMAL = 1
+PRIORITY_REPLY = 2
+PRIORITY_REPLY_TO_BOT = 3
+PRIORITY_REPLY_TO_BOT_SHORT_QUESTION = 4  # Prioridade máxima!
+
+# Limite de palavras para "pergunta curta"
+PERGUNTA_CURTA_LIMITE: int = 5
+
+
+@dataclass
+class ProcessedReplyContext:
+    """
+    Contexto de reply processado e pronto para uso.
+    
+    Attributes:
+        is_reply: Se é um reply
+        reply_to_bot: Se é reply direcionado ao bot
+        priority_level: Nível de prioridade (1-4)
+        quoted_author_name: Nome do autor da mensagem citada
+        quoted_author_numero: Número do autor
+        quoted_text_original: Texto original citado
+        mensagem_citada: Texto da mensagem citada
+        context_hint: Hint de contexto extraído
+        importancia: Peso de importância calculado
+        prompt_section: Section formatada para o prompt
+        should_prioritize_reply: Se deve priorizar no prompt
+        adaptive_multiplier: Multiplicador adaptativo baseado no tamanho
+    """
+    is_reply: bool = False
+    reply_to_bot: bool = False
+    priority_level: int = PRIORITY_NORMAL
+    quoted_author_name: str = ""
+    quoted_author_numero: str = ""
+    quoted_text_original: str = ""
+    mensagem_citada: str = ""
+    context_hint: str = ""
+    importancia: float = 1.0
+    prompt_section: str = ""
+    should_prioritize_reply: bool = False
+    adaptive_multiplier: float = 1.0
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Converte para dicionário."""
+        return {
+            "is_reply": self.is_reply,
+            "reply_to_bot": self.reply_to_bot,
+            "priority_level": self.priority_level,
+            "quoted_author_name": self.quoted_author_name,
+            "quoted_author_numero": self.quoted_author_numero,
+            "quoted_text_original": self.quoted_text_original,
+            "mensagem_citada": self.mensagem_citada,
+            "context_hint": self.context_hint,
+            "importancia": self.importancia,
+            "prompt_section": self.prompt_section,
+            "should_prioritize_reply": self.should_prioritize_reply,
+            "adaptive_multiplier": self.adaptive_multiplier
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'ProcessedReplyContext':
+        """Cria instância a partir de dicionário."""
+        return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
+
+
+# ============================================================
+# FUNÇÕES AUXILIARES
+# ============================================================
+
+def contar_palavras(texto: str) -> int:
+    """Conta palavras em um texto."""
+    if not texto:
+        return 0
+    return len(texto.split())
+
+
+def is_pergunta_curta(texto: str) -> bool:
+    """
+    Verifica se o texto é uma pergunta curta.
+    
+    Args:
+        texto: Texto a verificar
+        
+    Returns:
+        True se for pergunta com pocas palavras
+    """
+    if not texto:
+        return False
+    
+    texto_lower = texto.strip().lower()
+    word_count = contar_palavras(texto)
+    
+    # Deve ter marcador de pergunta ou palavras interrogativas
+    has_question_marker = '?' in texto
+    has_interrogative = any(w in texto_lower for w in [
+        'qual', 'quais', 'quem', 'como', 'onde', 'quando', 'por que', 
+        'porque', 'para que', 'o que', 'que', 'é o que', 'vc', 'você',
+        'tu', 'meu', 'minha', 'oq', 'oq', 'n'
+    ])
+    
+    return word_count <= PERGUNTA_CURTA_LIMITE and (has_question_marker or has_interrogative)
+
+
+def extrair_context_hint(quoted_text: str, mensagem_atual: str) -> str:
+    """
+    Extrai hint de contexto baseado no texto citado e mensagem atual.
+    
+    Args:
+        quoted_text: Texto original citado
+        mensagem_atual: Mensagem atual do usuário
+        
+    Returns:
+        String de hint de contexto
+    """
+    hints = []
+    
+    # Detecta tipo de reply
+    quoted_lower = quoted_text.lower() if quoted_text else ""
+    
+    # Pergunta sobre o bot
+    if any(w in quoted_lower for w in ['akira', 'bot', 'você', 'vc', 'tu']):
+        hints.append("pergunta_sobre_akira")
+    
+    # Pergunta factual
+    if any(w in quoted_lower for w in ['oq', 'o que', 'qual', 'quanto', 'onde', 'quando']):
+        hints.append("pergunta_factual")
+    
+    # Ironia/deboche detectado
+    if any(w in quoted_lower for w in ['kkk', 'haha', '😂', '🤣', 'eita']):
+        hints.append("tom_irreverente")
+    
+    # Expressão de opinião
+    if any(w in quoted_lower for w in ['acho', 'penso', 'creio', 'imagino']):
+        hints.append("expressao_opiniao")
+    
+    return " | ".join(hints) if hints else "contexto_geral"
+
+
+def calcular_prioridade(
+    is_reply: bool,
+    reply_to_bot: bool,
+    mensagem: str,
+    quoted_text: str = ""
+) -> Tuple[int, float]:
+    """
+    Calcula nível de prioridade e importância.
+    
+    Args:
+        is_reply: Se é um reply
+        reply_to_bot: Se é reply para o bot
+        mensagem: Mensagem atual
+        quoted_text: Texto citado
+        
+    Returns:
+        Tupla (priority_level, importancia)
+    """
+    if not is_reply:
+        return PRIORITY_NORMAL, 1.0
+    
+    # Reply para o bot
+    if reply_to_bot:
+        # Pergunta curta = prioridade máxima
+        if is_pergunta_curta(mensagem):
+            return PRIORITY_REPLY_TO_BOT_SHORT_QUESTION, IMPORTANCIA_PERGUNTA_CURTA_REPLY
+        # Reply normal ao bot
+        return PRIORITY_REPLY_TO_BOT, IMPORTANCIA_REPLY_TO_BOT
+    
+    # Reply para outro usuário
+    return PRIORITY_REPLY, IMPORTANCIA_REPLY
+
+
+# ============================================================
+# CLASSE PRINCIPAL
+# ============================================================
+
+class ReplyContextHandler:
+    """
+    Handler dedicado para processar e priorizar contexto de replies.
+    
+    Funcionalidades:
+    - Extração de metadados de reply do payload
+    - Cálculo automático de prioridade
+    - Construção de seções de prompt otimizadas
+    - Integração com ShortTermMemory
+    - Ajuste adaptativo baseado em tamanho da pergunta
+    """
+    
+    def __init__(self, short_term_memory: Optional[ShortTermMemory] = None):
+        """
+        Inicializa o handler.
+        
+        Args:
+            short_term_memory: Instância de ShortTermMemory (opcional)
+        """
+        self.short_term_memory = short_term_memory
+        logger.debug("✅ ReplyContextHandler inicializado")
+    
+    def process_reply(
+        self,
+        mensagem: str,
+        reply_metadata: Dict[str, Any],
+        historico_geral: Optional[List[Dict[str, Any]]] = None
+    ) -> ProcessedReplyContext:
+        """
+        Processa metadados de reply e gera contexto processado.
+        
+        Args:
+            mensagem: Mensagem atual do usuário
+            reply_metadata: Metadados do reply do payload
+            historico_geral: Histórico geral (opcional)
+            
+        Returns:
+            ProcessedReplyContext pronto para uso
+        """
+        # Extrai dados do metadata
+        is_reply = reply_metadata.get('is_reply', False)
+        reply_to_bot = reply_metadata.get('reply_to_bot', False)
+        quoted_author_name = reply_metadata.get('quoted_author_name', '')
+        quoted_author_numero = reply_metadata.get('quoted_author_numero', '')
+        quoted_text_original = reply_metadata.get('quoted_text_original', '')
+        mensagem_citada = reply_metadata.get('mensagem_citada', '') or quoted_text_original
+        
+        # 🔧 CORREÇÃO: Se autor é desconhecido, tenta detectar pelo contexto
+        if not quoted_author_name or quoted_author_name.lower() in ['desconhecido', 'unknown', '']:
+            # Detecta pelo conteúdo da mensagem citada
+            quoted_lower = quoted_text_original.lower() if quoted_text_original else ""
+            
+            # Se a mensagem citada contém padrões de resposta do bot
+            bot_patterns = ['akira:', 'eu sou', 'eu sou a akira', 'sou um bot', 'oi!', 'eae!']
+            if any(p in quoted_lower for p in bot_patterns):
+                quoted_author_name = "Akira (você mesmo)"
+                quoted_author_numero = "BOT"
+                reply_to_bot = True
+            elif mensagem_citada:
+                # Se há histórico, busca última mensagem
+                if historico_geral:
+                    # Assumir que é reply para a última mensagem do bot
+                    quoted_author_name = "mensagem_anterior"
+                    quoted_author_numero = "unknown"
+        
+        # Se ainda não tem autor mas tem mensagem citada e é reply
+        if is_reply and (not quoted_author_name or quoted_author_name == 'desconhecido'):
+            # Se é reply_to_bot=True mas autor desconhecido, assume que é reply para o bot
+            if reply_to_bot:
+                quoted_author_name = "Akira (você mesmo)"
+                quoted_author_numero = "BOT"
+            else:
+                # Tenta extrair do conteúdo
+                quoted_author_name = "participante_desconhecido"
+        
+        # Calcula prioridade e importância
+        priority_level, importancia = calcular_prioridade(
+            is_reply=is_reply,
+            reply_to_bot=reply_to_bot,
+            mensagem=mensagem,
+            quoted_text=quoted_text_original
+        )
+        
+        # Extrai context hint
+        context_hint = extrair_context_hint(quoted_text_original, mensagem)
+        
+        # Calcula multiplicador adaptativo
+        adaptive_multiplier = self._calculate_adaptive_multiplier(
+            mensagem=mensagem,
+            is_reply=is_reply,
+            priority_level=priority_level
+        )
+        
+        # Determina se deve priorizar no prompt
+        should_prioritize = is_reply and priority_level >= PRIORITY_REPLY
+        
+        # Constrói section do prompt
+        prompt_section = self._build_reply_prompt_section(
+            mensagem=mensagem,
+            mensagem_citada=mensagem_citada,
+            quoted_author_name=quoted_author_name,
+            reply_to_bot=reply_to_bot,
+            context_hint=context_hint,
+            priority_level=priority_level
+        )
+        
+        # Cria contexto processado
+        reply_context = ProcessedReplyContext(
+            is_reply=is_reply,
+            reply_to_bot=reply_to_bot,
+            priority_level=priority_level,
+            quoted_author_name=quoted_author_name,
+            quoted_author_numero=quoted_author_numero,
+            quoted_text_original=quoted_text_original,
+            mensagem_citada=mensagem_citada,
+            context_hint=context_hint,
+            importancia=importancia * adaptive_multiplier,
+            prompt_section=prompt_section,
+            should_prioritize_reply=should_prioritize,
+            adaptive_multiplier=adaptive_multiplier
+        )
+        
+        # Adiciona à memória de curto prazo se disponível
+        if self.short_term_memory and is_reply:
+            self.short_term_memory.add_message(
+                role="user",
+                content=mensagem,
+                importancia=reply_context.importancia,
+                reply_info={
+                    "is_reply": True,
+                    "reply_to_bot": reply_to_bot,
+                    "quoted_text_original": quoted_text_original,
+                    "priority_level": priority_level
+                }
+            )
+        
+        return reply_context
+    
+    def _calculate_adaptive_multiplier(
+        self,
+        mensagem: str,
+        is_reply: bool,
+        priority_level: int
+    ) -> float:
+        """
+        Calcula multiplicador adaptativo baseado no tamanho da pergunta.
+        
+        Para perguntas curtas com reply, aumenta a importância do contexto do reply
+        para garantir que o LLM tenha contexto suficiente.
+        
+        Args:
+            mensagem: Mensagem atual
+            is_reply: Se é reply
+            priority_level: Nível de prioridade
+            
+        Returns:
+            Multiplicador entre 1.0 e 2.0
+        """
+        if not is_reply:
+            return 1.0
+        
+        word_count = contar_palavras(mensagem)
+        
+        # Pergunta muito curta (< 3 palavras) = contexto crítico
+        if word_count <= 2:
+            return 1.5
+        
+        # Pergunta curta (3-5 palavras) = contexto importante
+        if word_count <= PERGUNTA_CURTA_LIMITE:
+            return 1.3
+        
+        # Pergunta normal = multiplicador padrão baseado em prioridade
+        if priority_level == PRIORITY_REPLY_TO_BOT_SHORT_QUESTION:
+            return 1.2
+        elif priority_level == PRIORITY_REPLY_TO_BOT:
+            return 1.1
+        
+        return 1.0
+    
+    def _build_reply_prompt_section(
+        self,
+        mensagem: str,
+        mensagem_citada: str,
+        quoted_author_name: str,
+        reply_to_bot: bool,
+        context_hint: str,
+        priority_level: int
+    ) -> str:
+        """
+        Constrói seção formatada do prompt para replies.
+        
+        Args:
+            mensagem: Mensagem atual
+            mensagem_citada: Texto citado
+            quoted_author_name: Nome do autor
+            reply_to_bot: Se é reply para o bot
+            context_hint: Hint de contexto
+            priority_level: Nível de prioridade
+            
+        Returns:
+            String formatada para inserção no prompt
+        """
+        if not mensagem_citada:
+            return ""
+        
+        sections = []
+        
+        # Cabeçalho com nível de prioridade
+        if priority_level >= PRIORITY_REPLY_TO_BOT_SHORT_QUESTION:
+            sections.append("[🔴 REPLY CRÍTICO - PERGUNTA CURTA]")
+        elif priority_level == PRIORITY_REPLY_TO_BOT:
+            sections.append("[🟡 REPLY AO BOT]")
+        elif priority_level == PRIORITY_REPLY:
+            sections.append("[🟢 REPLY]")
+        
+        # Contexto do autor
+        if reply_to_bot:
+            sections.append(f"⚠️ VOCÊ ESTÁ SENDO DIRETAMENTE RESPONDIDO!")
+        else:
+            sections.append(f"Respondendo a: {quoted_author_name}")
+        
+        # Texto citado
+        quoted_preview = mensagem_citada[:150] + ("..." if len(mensagem_citada) > 150 else "")
+        sections.append(f"Msg citada: \"{quoted_preview}\"")
+        
+        # Hint de contexto
+        if context_hint and context_hint != "contexto_geral":
+            sections.append(f"Contexto: {context_hint}")
+        
+        # Instrução de resposta
+        if priority_level >= PRIORITY_REPLY_TO_BOT_SHORT_QUESTION:
+            sections.append("💡 RESPONSE: Contextualize sua resposta usando a mensagem citada!")
+        elif reply_to_bot:
+            sections.append("💡 RESPONSE: Você foi diretamente mencionado.")
+        
+        return "\n".join(sections)
+    
+    def prioritize_reply_context(
+        self,
+        prompt: str,
+        reply_context: ProcessedReplyContext,
+        historico_geral: Optional[List[Dict[str, Any]]] = None
+    ) -> str:
+        """
+        Injeta contexto de reply no prompt com alta prioridade.
+        
+        Args:
+            prompt: Prompt original
+            reply_context: Contexto de reply processado
+            historico_geral: Histórico geral (opcional)
+            
+        Returns:
+            Prompt enriquecido com contexto de reply
+        """
+        if not reply_context.is_reply or not reply_context.prompt_section:
+            return prompt
+        
+        # Insere contexto de reply no início do prompt
+        reply_block = f"""
+{'='*60}
+{reply_context.prompt_section}
+{'='*60}
+"""
+        
+        # Determina posição de inserção
+        # Se há seção [SYSTEM], insere após ela
+        if "[SYSTEM]" in prompt:
+            # Encontra final da seção SYSTEM
+            system_end = prompt.find("[/SYSTEM]")
+            if system_end != -1:
+                return prompt[:system_end + 10] + reply_block + prompt[system_end + 10:]
+        
+        # Caso contrário, insere no início
+        return reply_block + "\n" + prompt
+    
+    def get_reply_summary_for_llm(self, reply_context: ProcessedReplyContext) -> str:
+        """
+        Retorna resumo formatado do reply para contexto do LLM.
+        
+        Args:
+            reply_context: Contexto de reply processado
+            
+        Returns:
+            String resumida para uso no contexto
+        """
+        if not reply_context.is_reply:
+            return ""
+        
+        parts = []
+        
+        if reply_context.reply_to_bot:
+            parts.append("REPLY DIRETO AO BOT")
+        else:
+            parts.append(f"REPLY a {reply_context.quoted_author_name}")
+        
+        if reply_context.mensagem_citada:
+            cited = reply_context.mensagem_citada[:100]
+            parts.append(f"Citando: \"{cited}\"")
+        
+        if reply_context.priority_level >= PRIORITY_REPLY_TO_BOT_SHORT_QUESTION:
+            parts.append("PERGUNTA CURTA - Prioridade Alta")
+        
+        return " | ".join(parts)
+    
+    def merge_reply_into_history(
+        self,
+        reply_context: ProcessedReplyContext,
+        history: List[Dict[str, str]]
+    ) -> List[Dict[str, str]]:
+        """
+        Mescla contexto de reply no histórico para o LLM.
+        
+        Args:
+            reply_context: Contexto de reply processado
+            history: Histórico formatado para LLM
+            
+        Returns:
+            Histórico com reply injetado no início
+        """
+        if not reply_context.is_reply:
+            return history
+        
+        # Cria entry para o reply
+        reply_entry = {
+            "role": "user",
+            "content": f"[REPLY] {reply_context.get_reply_summary_for_llm(reply_context)}"
+        }
+        
+        # Adiciona texto citado se disponível
+        if reply_context.mensagem_citada:
+            reply_entry["content"] += f"\n\nMensagem citada:\n{reply_context.mensagem_citada}"
+        
+        # Insere no início do histórico
+        return [reply_entry] + history
+    
+    def calculate_token_budget(
+        self,
+        reply_context: ProcessedReplyContext,
+        total_budget: int = 8000
+    ) -> Tuple[int, int]:
+        """
+        Calcula alocação de tokens entre reply e contexto geral.
+        
+        Args:
+            reply_context: Contexto de reply
+            total_budget: Total de tokens disponíveis
+            
+        Returns:
+            Tupla (tokens_para_reply, tokens_para_contexto)
+        """
+        if not reply_context.is_reply:
+            return 0, total_budget
+        
+        # Pergunta curta com reply = mais tokens para reply
+        if reply_context.priority_level >= PRIORITY_REPLY_TO_BOT_SHORT_QUESTION:
+            reply_tokens = min(1500, int(total_budget * 0.25))
+        elif reply_context.reply_to_bot:
+            reply_tokens = min(1000, int(total_budget * 0.15))
+        else:
+            reply_tokens = min(800, int(total_budget * 0.10))
+        
+        return reply_tokens, total_budget - reply_tokens
+    
+    # ============================================================
+    # HELPERS PARA API
+    # ============================================================
+    
+    @staticmethod
+    def extract_reply_metadata_from_request(data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Extrai metadados de reply de um request da API.
+        
+        Args:
+            data: Payload do request
+            
+        Returns:
+            Dict com metadados de reply
+        """
+        reply_metadata = data.get('reply_metadata', {})
+        
+        # Se não há reply_metadata, tenta extrair de campos individuais
+        if not reply_metadata:
+            mensagem_citada = data.get('mensagem_citada', '')
+            if mensagem_citada:
+                reply_metadata = {
+                    'is_reply': True,
+                    'quoted_text_original': mensagem_citada,
+                    'mensagem_citada': mensagem_citada
+                }
+            else:
+                return {'is_reply': False}
+        
+        # Garante campos obrigatórios
+        return {
+            'is_reply': reply_metadata.get('is_reply', False),
+            'reply_to_bot': reply_metadata.get('reply_to_bot', False),
+            'quoted_author_name': reply_metadata.get('quoted_author_name', ''),
+            'quoted_author_numero': reply_metadata.get('quoted_author_numero', ''),
+            'quoted_type': reply_metadata.get('quoted_type', 'texto'),
+            'quoted_text_original': reply_metadata.get('quoted_text_original', ''),
+            'context_hint': reply_metadata.get('context_hint', ''),
+            'mensagem_citada': reply_metadata.get('mensagem_citada', '')
+        }
+    
+    def validate_reply_priority(self, reply_context: ProcessedReplyContext) -> bool:
+        """
+        Valida se a prioridade calculada está correta.
+        
+        Args:
+            reply_context: Contexto a validar
+            
+        Returns:
+            True se válido
+        """
+        if not reply_context.is_reply:
+            return reply_context.priority_level == PRIORITY_NORMAL
+        
+        # Reply para bot + pergunta curta deve ter prioridade máxima
+        if reply_context.reply_to_bot and is_pergunta_curta(reply_context.mensagem_citada):
+            return reply_context.priority_level == PRIORITY_REPLY_TO_BOT_SHORT_QUESTION
+        
+        # Reply para bot deve ter alta prioridade
+        if reply_context.reply_to_bot:
+            return reply_context.priority_level >= PRIORITY_REPLY_TO_BOT
+        
+        # Reply normal deve ter prioridade >= 2
+        return reply_context.priority_level >= PRIORITY_REPLY
+    
+    def __repr__(self) -> str:
+        """Representação textual."""
+        mem_status = "com STM" if self.short_term_memory else "sem STM"
+        return f"ReplyContextHandler({mem_status})"
+
+
+# ============================================================
+# FUNÇÕES DE FÁBRICA
+# ============================================================
+
+def criar_reply_handler(
+    short_term_memory: Optional[ShortTermMemory] = None
+) -> ReplyContextHandler:
+    """
+    Factory function para criar ReplyContextHandler.
+    
+    Args:
+        short_term_memory: Instância de ShortTermMemory (opcional)
+        
+    Returns:
+        ReplyContextHandler instance
+    """
+    return ReplyContextHandler(short_term_memory=short_term_memory)
+
+
+def processar_reply_request(
+    mensagem: str,
+    request_data: Dict[str, Any],
+    short_term_memory: Optional[ShortTermMemory] = None
+) -> ProcessedReplyContext:
+    """
+    Função helper para processar reply de request.
+    
+    Args:
+        mensagem: Mensagem atual
+        request_data: Payload do request
+        short_term_memory: Instância de ShortTermMemory (opcional)
+        
+    Returns:
+        ProcessedReplyContext
+    """
+    handler = criar_reply_handler(short_term_memory)
+    reply_metadata = handler.extract_reply_metadata_from_request(request_data)
+    return handler.process_reply(mensagem, reply_metadata)
+
+
+# type: ignore
+

modules/short_term_memory.py

@@ -0,0 +1,730 @@
+# type: ignore
+"""
+================================================================================
+AKIRA V21 ULTIMATE - SHORT-TERM MEMORY MODULE
+================================================================================
+Sistema de memória de curto prazo com sliding window de 100 mensagens.
+Prioriza contexto de replies e ajusta importância dinamicamente.
+
+Features:
+- Sliding window de 100 mensagens por usuário
+- Priorização automática de replies (importancia > 1.0)
+- Perguntas curtas com reply ganham prioridade ainda maior
+- Serialização JSON para persistência
+- Peso adaptativo baseado em análise de conteúdo
+================================================================================
+"""
+
+import os
+import sys
+import time
+import json
+import re
+import logging
+from pathlib import Path
+from typing import Optional, Dict, Any, List, Tuple
+from dataclasses import dataclass, field
+from collections import deque
+from datetime import datetime
+
+# Imports robustos com fallback - CORRIGIDO para usar modules.
+try:
+    import modules.config as config
+    SHORT_TERM_MEMORY_AVAILABLE = True
+except ImportError:
+    try:
+        from . import config
+        SHORT_TERM_MEMORY_AVAILABLE = True
+    except ImportError:
+        SHORT_TERM_MEMORY_AVAILABLE = False
+        config = None
+
+logger = logging.getLogger(__name__)
+
+# ============================================================
+# CONFIGURAÇÃO
+# ============================================================
+
+# Máximo de mensagens na memória de curto prazo (100 conforme usuário)
+MAX_SHORT_TERM_MESSAGES: int = 100
+
+# Multiplicadores de importância
+IMPORTANCIA_NORMAL: float = 1.0
+IMPORTANCIA_REPLY: float = 1.3
+IMPORTANCIA_REPLY_TO_BOT: float = 1.5
+IMPORTANCIA_PERGUNTA_CURTA_REPLY: float = 1.7  # Prioridade máxima
+
+# Limite de palavras para considerar "pergunta curta"
+PERGUNTA_CURTA_LIMITE: int = 5
+
+
+@dataclass
+class MessageWithContext:
+    """
+    Mensagem com metadados de contexto completo.
+    
+    Attributes:
+        role: "user" ou "assistant"
+        content: Texto da mensagem
+        timestamp: Timestamp da mensagem
+        importancia: Peso de importância (1.0 = normal, >1.0 = replies)
+        emocao: Emoção detectada
+        reply_info: Info sobre reply (se aplicável)
+        conversation_id: ID da conversa isolada
+        token_count: Contagem aproximada de tokens
+    """
+    role: str
+    content: str
+    timestamp: float = field(default_factory=time.time)
+    importancia: float = 1.0
+    emocao: str = "neutral"
+    reply_info: Dict[str, Any] = field(default_factory=dict)
+    conversation_id: str = ""
+    token_count: int = 0
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Converte para dicionário."""
+        return {
+            "role": self.role,
+            "content": self.content,
+            "timestamp": self.timestamp,
+            "importancia": self.importancia,
+            "emocao": self.emocao,
+            "reply_info": self.reply_info,
+            "conversation_id": self.conversation_id,
+            "token_count": self.token_count
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'MessageWithContext':
+        """Cria instância a partir de dicionário."""
+        return cls(
+            role=data.get("role", "user"),
+            content=data.get("content", ""),
+            timestamp=data.get("timestamp", time.time()),
+            importancia=data.get("importancia", 1.0),
+            emocao=data.get("emocao", "neutral"),
+            reply_info=data.get("reply_info", {}),
+            conversation_id=data.get("conversation_id", ""),
+            token_count=data.get("token_count", 0)
+        )
+    
+    @property
+    def is_reply(self) -> bool:
+        """Verifica se é um reply."""
+        return bool(self.reply_info) and self.reply_info.get("is_reply", False)
+    
+    @property
+    def is_reply_to_bot(self) -> bool:
+        """Verifica se é reply direcionado ao bot."""
+        return self.reply_info.get("reply_to_bot", False)
+
+
+# ============================================================
+# FUNÇÕES AUXILIARES
+# ============================================================
+
+def contar_palavras(texto: str) -> int:
+    """Conta palavras em um texto."""
+    if not texto:
+        return 0
+    return len(texto.split())
+
+
+def estimar_tokens(texto: str) -> int:
+    """
+    Estima número de tokens (aproximação粗糙).
+    Média de 4 caracteres por token em português.
+    """
+    if not texto:
+        return 0
+    return max(1, len(texto) // 4)
+
+
+def is_pergunta_curta(texto: str) -> bool:
+    """
+    Verifica se o texto é uma pergunta curta.
+    
+    Args:
+        texto: Texto a verificar
+        
+    Returns:
+        True se for pergunta com poucas palavras
+    """
+    if not texto:
+        return False
+    
+    texto_lower = texto.strip().lower()
+    
+    # Deve ter marcador de pergunta ou palavras interrogativas
+    has_question_marker = '?' in texto or '？' in texto
+    has_interrogative = any(w in texto_lower for w in [
+        'qual', 'quais', 'quem', 'como', 'onde', 'quando', 'por que', 
+        'porque', 'para que', 'o que', 'que', 'é o que'
+    ])
+    
+    word_count = contar_palavras(texto)
+    
+    # Pergunta curta: até N palavras E (marcador ? OU palavra interrogativa)
+    return word_count <= PERGUNTA_CURTA_LIMITE and (has_question_marker or has_interrogative)
+
+
+def calcular_importancia(
+    is_reply: bool = False,
+    reply_to_bot: bool = False,
+    mensagem: str = "",
+    emocao: str = "neutral"
+) -> float:
+    """
+    Calcula importância da mensagem baseada em múltiplos fatores.
+    
+    Args:
+        is_reply: Se é um reply
+        reply_to_bot: Se é reply para o bot
+        mensagem: Texto da mensagem
+        emocao: Emoção detectada
+        
+    Returns:
+        Float de importância (1.0 = normal, >1.0 = prioritário)
+    """
+    importancia = IMPORTANCIA_NORMAL
+    
+    # Reply para o bot tem maior prioridade
+    if is_reply and reply_to_bot:
+        importancia = IMPORTANCIA_REPLY_TO_BOT
+        
+        # Pergunta curta com reply ao bot = prioridade máxima
+        if is_pergunta_curta(mensagem):
+            importancia = IMPORTANCIA_PERGUNTA_CURTA_REPLY
+    
+    # Reply normal
+    elif is_reply:
+        importancia = IMPORTANCIA_REPLY
+    
+    # Emoção intensa pode aumentar importância
+    emocoes_intensas = ['joy', 'love', 'anger', 'fear']
+    if emocao in emocoes_intensas:
+        importancia *= 1.1
+    
+    return importancia
+
+
+# ============================================================
+# CLASSE PRINCIPAL DE MEMÓRIA DE CURTO PRAZO
+# ============================================================
+
+class ShortTermMemory:
+    """
+    Sistema de memória de curto prazo com sliding window.
+    
+    Características:
+    - Mantém últimas N mensagens (100 por padrão)
+    - Auto-reorganização por importância
+    - Persistência JSON
+    - Integração com ReplyContextHandler
+    - Token budgeting para contexto LLM
+    """
+    
+    def __init__(
+        self,
+        conversation_id: str = "",
+        max_messages: int = MAX_SHORT_TERM_MESSAGES,
+        context_data: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Inicializa memória de curto prazo.
+        
+        Args:
+            conversation_id: ID da conversa isolada
+            max_messages: Máximo de mensagens (padrão 100)
+            context_data: Dados para restauração (opcional)
+        """
+        self.conversation_id = conversation_id
+        self.max_messages = max_messages
+        
+        # Deque para O(1) em operações de borda
+        self._messages: deque = deque(maxlen=max_messages)
+        
+        # Cache para rápido acesso
+        self._replies_cache: List[MessageWithContext] = []
+        self._last_update: float = time.time()
+        
+        # Carrega dados se fornecidos
+        if context_data and isinstance(context_data, dict):
+            self._from_dict(context_data)
+        else:
+            self._initialize_empty()
+        
+        logger.debug(f"🧠 ShortTermMemory initialized: {conversation_id or 'temp'} | {len(self._messages)} msgs")
+    
+    def _initialize_empty(self):
+        """Inicializa estrutura vazia."""
+        self._messages = deque(maxlen=self.max_messages)
+        self._replies_cache = []
+        self._last_update = time.time()
+    
+    # ============================================================
+    # ADIÇÃO DE MENSAGENS
+    # ============================================================
+    
+    def add_message(
+        self,
+        role: str,
+        content: str,
+        importancia: float = IMPORTANCIA_NORMAL,
+        emocao: str = "neutral",
+        reply_info: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> MessageWithContext:
+        """
+        Adiciona mensagem à memória.
+        
+        Args:
+            role: "user" ou "assistant"
+            content: Texto da mensagem
+            importancia: Peso de importância
+            emocao: Emoção detectada
+            reply_info: Info de reply (se aplicável)
+            metadata: Metadados adicionais
+            
+        Returns:
+            MessageWithContext criada
+        """
+        # Cria mensagem com contexto
+        msg = MessageWithContext(
+            role=role,
+            content=content,
+            importancia=importancia,
+            emocao=emocao,
+            reply_info=reply_info or {},
+            conversation_id=self.conversation_id,
+            token_count=estimar_tokens(content)
+        )
+        
+        # Adiciona metadados extras
+        if metadata:
+            msg_data = msg.to_dict()
+            msg_data.update(metadata)
+            msg = MessageWithContext.from_dict(msg_data)
+        
+        # Adiciona ao deque
+        self._messages.append(msg)
+        self._last_update = time.time()
+        
+        # Atualiza cache de replies
+        if msg.is_reply:
+            self._replies_cache.append(msg)
+            # Limita cache de replies
+            if len(self._replies_cache) > 20:
+                self._replies_cache = self._replies_cache[-20:]
+        
+        return msg
+    
+    def add_user_message(
+        self,
+        content: str,
+        emocao: str = "neutral",
+        reply_info: Optional[Dict[str, Any]] = None,
+        importancia: float = None
+    ) -> MessageWithContext:
+        """
+        Adiciona mensagem do usuário.
+        
+        Args:
+            content: Texto da mensagem
+            emocao: Emoção detectada
+            reply_info: Info de reply
+            importancia: Importância customizada (calculada automaticamente se None)
+            
+        Returns:
+            MessageWithContext criada
+        """
+        if importancia is None:
+            importancia = calcular_importancia(
+                is_reply=bool(reply_info and reply_info.get("is_reply")),
+                reply_to_bot=bool(reply_info and reply_info.get("reply_to_bot")),
+                mensagem=content,
+                emocao=emocao
+            )
+        
+        return self.add_message(
+            role="user",
+            content=content,
+            importancia=importancia,
+            emocao=emocao,
+            reply_info=reply_info
+        )
+    
+    def add_assistant_message(
+        self,
+        content: str,
+        emocao: str = "neutral",
+        importancia: float = IMPORTANCIA_NORMAL
+    ) -> MessageWithContext:
+        """
+        Adiciona mensagem do assistente (bot).
+        
+        Args:
+            content: Texto da resposta
+            emocao: Emoção da resposta
+            importancia: Importância
+            
+        Returns:
+            MessageWithContext criada
+        """
+        return self.add_message(
+            role="assistant",
+            content=content,
+            importancia=importancia,
+            emocao=emocao
+        )
+    
+    # ============================================================
+    # RECUPERAÇÃO DE CONTEXTO
+    # ============================================================
+    
+    def get_context_window(
+        self,
+        include_replies: bool = True,
+        prioritize_replies: bool = True,
+        max_messages: Optional[int] = None,
+        max_tokens: int = 8000
+    ) -> List[MessageWithContext]:
+        """
+        Obtém janela de contexto otimizada para LLM.
+        
+        Args:
+            include_replies: Se deve incluir replies
+            prioritize_replies: Se deve priorizar replies
+            max_messages: Máximo de mensagens (usa config se None)
+            max_tokens: Limite de tokens
+            
+        Returns:
+            Lista de mensagens ordenadas
+        """
+        messages = list(self._messages)
+        
+        if not messages:
+            return []
+        
+        # Filtra replies se necessário
+        if not include_replies:
+            messages = [m for m in messages if not m.is_reply]
+        
+        # Reorganiza por importância se solicitado
+        if prioritize_replies:
+            messages.sort(key=lambda m: m.importancia, reverse=True)
+        
+        # Aplica limite de mensagens
+        if max_messages and len(messages) > max_messages:
+            messages = messages[:max_messages]
+        
+        # Aplica limite de tokens
+        if max_tokens > 0:
+            tokens_accumulated = 0
+            result = []
+            for msg in messages:
+                if tokens_accumulated + msg.token_count <= max_tokens:
+                    result.append(msg)
+                    tokens_accumulated += msg.token_count
+                else:
+                    break
+            messages = result
+        
+        return messages
+    
+    def get_last_n_messages(self, n: int) -> List[MessageWithContext]:
+        """
+        Obtém últimas N mensagens (ordem cronológica).
+        
+        Args:
+            n: Número de mensagens
+            
+        Returns:
+            Lista das últimas N mensagens
+        """
+        return list(self._messages)[-n:]
+    
+    def get_recent_replies(
+        self,
+        n: int = 5,
+        include_reply_to_bot: bool = True
+    ) -> List[MessageWithContext]:
+        """
+        Obtém replies mais recentes.
+        
+        Args:
+            n: Número de replies a retornar
+            include_reply_to_bot: Se inclui replies ao bot
+            
+        Returns:
+            Lista de replies ordenados por timestamp
+        """
+        replies = [m for m in self._messages if m.is_reply]
+        
+        if not include_reply_to_bot:
+            replies = [m for m in replies if not m.is_reply_to_bot]
+        
+        # Retorna mais recentes primeiro
+        return replies[-n:][::-1]
+    
+    def get_all_messages(self) -> List[MessageWithContext]:
+        """Retorna todas as mensagens."""
+        return list(self._messages)
+    
+    def get_messages_for_llm(
+        self,
+        reply_context: Optional[MessageWithContext] = None,
+        max_tokens: int = 6000
+    ) -> List[Dict[str, str]]:
+        """
+        Obtém mensagens formatadas para LLM.
+        
+        Args:
+            reply_context: Contexto de reply atual (terá prioridade)
+            max_tokens: Limite de tokens
+            
+        Returns:
+            Lista de dicts com role e content
+        """
+        messages = self.get_context_window(
+            include_replies=True,
+            prioritize_replies=True,
+            max_tokens=max_tokens
+        )
+        
+        # Se há reply_context, coloca no início
+        if reply_context:
+            # Garante que reply_context está na lista ou adiciona
+            reply_msg = MessageWithContext(
+                role="user",
+                content=f"[REPLY CONTEXT] {reply_context.content}",
+                importancia=IMPORTANCIA_PERGUNTA_CURTA_REPLY,
+                reply_info=reply_context.reply_info
+            )
+            
+            # Remove duplicata se existir
+            messages = [m for m in messages if not (
+                m.is_reply and 
+                m.reply_info.get("quoted_text_original") == reply_context.reply_info.get("quoted_text_original")
+            )]
+            
+            # Adiciona reply no início
+            messages.insert(0, reply_msg)
+        
+        # Formata para LLM
+        return [
+            {"role": msg.role, "content": msg.content}
+            for msg in messages
+        ]
+    
+    # ============================================================
+    # ANÁLISE DE CONTEXTO
+    # ============================================================
+    
+    def get_conversation_summary(self) -> Dict[str, Any]:
+        """
+        Gera resumo estatístico da conversa.
+        
+        Returns:
+            Dicionário com estatísticas
+        """
+        messages = list(self._messages)
+        
+        if not messages:
+            return {
+                "total_messages": 0,
+                "user_messages": 0,
+                "assistant_messages": 0,
+                "replies_count": 0,
+                "emocoes": {},
+                "avg_importancia": 1.0,
+                "token_count": 0,
+                "duration_seconds": 0
+            }
+        
+        user_msgs = [m for m in messages if m.role == "user"]
+        assistant_msgs = [m for m in messages if m.role == "assistant"]
+        replies = [m for m in messages if m.is_reply]
+        
+        # Contagem de emoções
+        emocoes = {}
+        for m in messages:
+            emocao = m.emocao or "neutral"
+            emocoes[emocao] = emocoes.get(emocao, 0) + 1
+        
+        # Duração
+        timestamps = [m.timestamp for m in messages]
+        duration = max(timestamps) - min(timestamps) if len(timestamps) > 1 else 0
+        
+        return {
+            "total_messages": len(messages),
+            "user_messages": len(user_msgs),
+            "assistant_messages": len(assistant_msgs),
+            "replies_count": len(replies),
+            "emocoes": emocoes,
+            "avg_importancia": sum(m.importancia for m in messages) / max(1, len(messages)),
+            "token_count": sum(m.token_count for m in messages),
+            "duration_seconds": duration,
+            "is_full": len(messages) >= self.max_messages
+        }
+    
+    def get_emotional_trend(self) -> str:
+        """Retorna tendência emocional da conversa."""
+        messages = list(self._messages)
+        if not messages:
+            return "neutral"
+        
+        # Pesos mais recentes têm mais importância
+        emocoes = {}
+        total_weight = 0
+        
+        for i, msg in enumerate(reversed(messages)):
+            weight = 1.0 + (i * 0.05)  #_msgs recentes pesam mais
+            emocao = msg.emocao or "neutral"
+            emocoes[emocao] = emocoes.get(emocao, 0) + weight
+            total_weight += weight
+        
+        # Normaliza
+        for e in emocoes:
+            emocoes[e] /= total_weight
+        
+        return max(emocoes, key=emocoes.get) if emocoes else "neutral"  # type: ignore
+    
+    # ============================================================
+    # PERSISTÊNCIA
+    # ============================================================
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Serializa para dicionário."""
+        return {
+            "conversation_id": self.conversation_id,
+            "max_messages": self.max_messages,
+            "messages": [m.to_dict() for m in self._messages],
+            "last_update": self._last_update
+        }
+    
+    def _from_dict(self, data: Dict[str, Any]):
+        """Desserializa de dicionário."""
+        self.conversation_id = data.get("conversation_id", "")
+        self.max_messages = data.get("max_messages", MAX_SHORT_TERM_MESSAGES)
+        self._last_update = data.get("last_update", time.time())
+        
+        messages_data = data.get("messages", [])
+        self._messages = deque(maxlen=self.max_messages)
+        self._replies_cache = []
+        
+        for msg_data in messages_data:
+            msg = MessageWithContext.from_dict(msg_data)
+            self._messages.append(msg)
+            if msg.is_reply:
+                self._replies_cache.append(msg)
+    
+    def save_to_file(self, filepath: str) -> bool:
+        """Salva memória em arquivo JSON."""
+        try:
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(self.to_dict(), f, ensure_ascii=False, indent=2)
+            return True
+        except Exception as e:
+            logger.warning(f"Erro ao salvar memória: {e}")
+            return False
+    
+    @classmethod
+    def load_from_file(cls, filepath: str) -> 'ShortTermMemory':
+        """Carrega memória de arquivo JSON."""
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            return cls(context_data=data)
+        except Exception as e:
+            logger.warning(f"Erro ao carregar memória: {e}")
+            return cls()
+    
+    # ============================================================
+    # GESTÃO
+    # ============================================================
+    
+    def clear(self):
+        """Limpa toda a memória."""
+        self._initialize_empty()
+        logger.debug(f"🧠 ShortTermMemory cleared: {self.conversation_id or 'temp'}")
+    
+    def merge_from(self, other: 'ShortTermMemory') -> None:
+        """
+        Mescla mensagens de outra memória.
+        Útil para migração de dados.
+        
+        Args:
+            other: Outra ShortTermMemory
+        """
+        for msg in other.get_all_messages():
+            # Mantém conversation_id original
+            msg_data = msg.to_dict()
+            msg_data["conversation_id"] = self.conversation_id
+            new_msg = MessageWithContext.from_dict(msg_data)
+            self._messages.append(new_msg)
+        
+        self._last_update = time.time()
+    
+    def __len__(self) -> int:
+        """Retorna número de mensagens."""
+        return len(self._messages)
+    
+    def __bool__(self) -> bool:
+        """Retorna True se há mensagens."""
+        return len(self._messages) > 0
+    
+    def __iter__(self):
+        """Iterador sobre mensagens."""
+        return iter(self._messages)
+    
+    def __repr__(self) -> str:
+        """Representação textual."""
+        return f"ShortTermMemory(id={self.conversation_id[:8] if self.conversation_id else 'temp'}, msgs={len(self)})"
+
+
+# ============================================================
+# FUNÇÕES DE FÁBRICA
+# ============================================================
+
+def criar_short_term_memory(
+    conversation_id: str = "",
+    max_messages: int = MAX_SHORT_TERM_MESSAGES
+) -> ShortTermMemory:
+    """
+    Factory function para criar ShortTermMemory.
+    
+    Args:
+        conversation_id: ID da conversa
+        max_messages: Máximo de mensagens
+        
+    Returns:
+        ShortTermMemory instance
+    """
+    return ShortTermMemory(conversation_id=conversation_id, max_messages=max_messages)
+
+
+def calcular_importancia_automatica(
+    mensagem: str,
+    is_reply: bool = False,
+    reply_to_bot: bool = False,
+    emocao: str = "neutral"
+) -> float:
+    """
+    Wrapper para calcular_importancia com todos os parâmetros.
+    
+    Args:
+        mensagem: Texto da mensagem
+        is_reply: Se é reply
+        reply_to_bot: Se é reply para o bot
+        emocao: Emoção detectada
+        
+    Returns:
+        Float de importância
+    """
+    return calcular_importancia(is_reply, reply_to_bot, mensagem, emocao)
+
+
+# type: ignore
+

modules/treinamento.py

@@ -1,1076 +1,856 @@
-# modules/treinamento.py — AKIRA V21 FINAL CORRIGIDO (Dezembro 2025)
-"""
-✅ TOTALMENTE COMPATÍVEL com database.py corrigido
-✅ Processa reply_metadata do index.js
-✅ Sistema de aprendizado completo
-✅ Detecção de padrões de conversa
-✅ Compatível com STT/TTS
-✅ Otimizado para produção
-✅ CORREÇÃO: Suporte para nivel_transicao adicionado
-"""
-
-import json
-import os
-import time
-import threading
-import random
-import hashlib
-import re
-from typing import Optional, Dict, Any, List, Tuple
-from loguru import logger
-from .database import Database
-
-# ============================================================================
-# 🔥 CONFIGURAÇÕES
-# ============================================================================
-DATASET_PATH = "training_dataset.json"
-MIN_INTERACOES_PARA_ANALISE = 10
-MAX_EXEMPLOS_DATASET = 2000
-QUALIDADE_MINIMA = 0.6
-
-# ============================================================================
-# 🔧 CACHE E LOCKS
-# ============================================================================
-EMBEDDING_CACHE = {}
-_lock = threading.Lock()
-
-# ============================================================================
-# 🎯 CLASSE PRINCIPAL DE TREINAMENTO
-# ============================================================================
-class Treinamento:
-    def __init__(self, db: Database, interval_hours: int = 6):
-        """
-        Inicializa sistema de treinamento
-        
-        Args:
-            db: Instância do Database
-            interval_hours: Intervalo entre treinamentos automáticos
-        """
-        self.db = db
-        self.interval_seconds = interval_hours * 3600
-        self._loop_thread: Optional[threading.Thread] = None
-        self.running = False
-        self.exemplos_qualidade_cache = {}
-        self.ultima_analise = 0
-        logger.info(f"✅ Treinamento inicializado (intervalo: {interval_hours}h)")
-
-    # ========================================================================
-    # 📝 REGISTRO DE INTERAÇÕES (ADAPTADO AO INDEX.JS) - CORRIGIDO
-    # ========================================================================
-    
-    def registrar_interacao(
-        self,
-        usuario: str,
-        mensagem: str,
-        resposta: str,
-        numero: str,
-        is_reply: bool = False,
-        mensagem_original: str = None,
-        contexto: Dict = None,
-        tipo_conversa: str = 'pv',
-        tipo_mensagem: str = 'texto',
-        reply_to_bot: bool = False,
-        reply_metadata: Optional[Dict] = None,
-        nivel_transicao: int = 0  # NOVO PARÂMETRO ADICIONADO
-    ):
-        """
-        Registra interação para treinamento - TOTALMENTE COMPATÍVEL
-        
-        Args:
-            usuario: Nome do usuário
-            mensagem: Mensagem enviada
-            resposta: Resposta gerada
-            numero: Número do usuário
-            is_reply: Se é reply
-            mensagem_original: Mensagem original (se reply)
-            contexto: Contexto da conversa
-            tipo_conversa: 'pv' ou 'grupo'
-            tipo_mensagem: 'texto', 'audio', etc
-            reply_to_bot: Se é reply ao bot
-            reply_metadata: Metadata do reply (do index.js)
-            nivel_transicao: Nível de transição do usuário privilegiado
-        """
-        try:
-            numero = str(numero).strip()
-            
-            # Prepara contexto
-            if contexto is None:
-                contexto = {}
-            
-            # Extrai reply_to_bot de reply_metadata se disponível
-            if reply_metadata and reply_metadata.get('reply_to_bot') is not None:
-                reply_to_bot = reply_metadata.get('reply_to_bot', False)
-            
-            # Extrai info_transicao do contexto
-            info_transicao = contexto.get('info_transicao', {})
-            
-            # Determina emoção e qualidade
-            emocao_detectada, confianca_emocao = self._detectar_emocao(mensagem)
-            qualidade = self._calcular_qualidade_resposta(mensagem, resposta, tipo_mensagem)
-            
-            # Salva no banco usando método CORRETO com nivel_transicao
-            self.db.salvar_mensagem(
-                usuario=usuario,
-                mensagem=mensagem,
-                resposta=resposta,
-                numero=numero,
-                is_reply=is_reply,
-                mensagem_original=mensagem_original or '',
-                reply_to_bot=reply_to_bot,
-                humor=contexto.get('humor_atualizado', 'normal_ironico'),
-                modo_resposta=contexto.get('modo_resposta', 'normal_ironico'),
-                emocao_detectada=emocao_detectada,
-                confianca_emocao=confianca_emocao,
-                nivel_transicao=nivel_transicao,  # PARÂMETRO ADICIONADO
-                info_transicao=info_transicao,  # INFO DE TRANSIÇÃO
-                tipo_mensagem=tipo_mensagem,
-                usuario_nome=usuario,
-                tipo_conversa=tipo_conversa,
-                reply_info_json=json.dumps(reply_metadata) if reply_metadata else None
-            )
-            
-            # Atualiza contexto com nivel_transicao
-            self.db.atualizar_contexto(
-                numero=numero,
-                humor_atual=contexto.get('humor_atualizado', 'normal_ironico'),
-                modo_resposta=contexto.get('modo_resposta', 'normal_ironico'),
-                nivel_transicao=nivel_transicao,
-                info_transicao=info_transicao,
-                tom=contexto.get('tom', 'normal'),
-                emocao_tendencia=emocao_detectada
-            )
-            
-            # Adiciona ao dataset se qualidade boa
-            if qualidade >= QUALIDADE_MINIMA:
-                self._adicionar_ao_dataset(
-                    mensagem=mensagem,
-                    resposta=resposta,
-                    numero=numero,
-                    usuario=usuario,
-                    contexto=contexto,
-                    emocao_detectada=emocao_detectada,
-                    confianca_emocao=confianca_emocao,
-                    qualidade=qualidade,
-                    tipo_mensagem=tipo_mensagem,
-                    tipo_conversa=tipo_conversa,
-                    is_reply=is_reply,
-                    reply_to_bot=reply_to_bot,
-                    reply_metadata=reply_metadata,
-                    nivel_transicao=nivel_transicao  # ADICIONADO
-                )
-            
-            # Salva exemplo de treinamento com nivel_transicao
-            if tipo_mensagem == 'texto' and len(resposta) > 10:
-                self.db.salvar_training_example(
-                    input_text=mensagem,
-                    output_text=resposta,
-                    humor=contexto.get('humor_atualizado', 'normal_ironico'),
-                    modo_resposta=contexto.get('modo_resposta', 'normal_ironico'),
-                    nivel_transicao=nivel_transicao,  # ADICIONADO
-                    emocao_contexto=emocao_detectada,
-                    qualidade_score=qualidade,
-                    contexto_super_claro={
-                        'is_reply': is_reply,
-                        'reply_to_bot': reply_to_bot,
-                        'tipo_conversa': tipo_conversa,
-                        'tipo_mensagem': tipo_mensagem,
-                        'reply_metadata': reply_metadata,
-                        'nivel_transicao': nivel_transicao,
-                        'info_transicao': info_transicao
-                    }
-                )
-            
-            # Registra interação para treinamento
-            self.db.registrar_interacao(
-                numero=numero,
-                mensagem=mensagem,
-                resposta=resposta,
-                humor=contexto.get('humor_atualizado', 'normal_ironico'),
-                modo_resposta=contexto.get('modo_resposta', 'normal_ironico'),
-                nivel_transicao=nivel_transicao,  # PARÂMETRO ADICIONADO
-                emocao_detectada=emocao_detectada,
-                tipo_conversa=tipo_conversa,
-                reply_info_json=json.dumps(reply_metadata) if reply_metadata else None,
-                qualidade_score=qualidade
-            )
-            
-            # Analisa padrões
-            self._analisar_padroes_usuario(
-                numero=numero,
-                usuario=usuario,
-                mensagem=mensagem,
-                resposta=resposta,
-                contexto=contexto,
-                emocao_detectada=emocao_detectada,
-                tipo_conversa=tipo_conversa,
-                is_reply=is_reply,
-                reply_to_bot=reply_to_bot,
-                reply_metadata=reply_metadata,
-                nivel_transicao=nivel_transicao  # ADICIONADO
-            )
-            
-            logger.debug(f"✅ Interação registrada: {usuario[:10]} | Nível: {nivel_transicao} | reply: {is_reply}")
-            
-        except Exception as e:
-            logger.error(f"❌ Erro ao registrar interação: {e}")
-            import traceback
-            traceback.print_exc()
-
-    # ========================================================================
-    # 🎭 DETECÇÃO DE EMOÇÃO
-    # ========================================================================
-    
-    def _detectar_emocao(self, mensagem: str) -> Tuple[str, float]:
-        """
-        Detecta emoção básica na mensagem
-        
-        Args:
-            mensagem: Texto da mensagem
-            
-        Returns:
-            Tupla (emocao, confianca)
-        """
-        if not mensagem.strip():
-            return "neutral", 0.5
-        
-        mensagem_lower = mensagem.lower()
-        
-        # Palavras positivas
-        positivas = ['bom', 'ótimo', 'feliz', 'fixe', 'adorei', 'love', 'obrigado', 'thanks']
-        negativas = ['ruim', 'péssimo', 'triste', 'ódio', 'raiva', 'merda', 'caralho']
-        
-        pos = sum(1 for p in positivas if p in mensagem_lower)
-        neg = sum(1 for n in negativas if n in mensagem_lower)
-        
-        if pos > neg and pos >= 2:
-            return "joy", 0.7
-        elif neg > pos and neg >= 2:
-            return "anger", 0.7
-        else:
-            return "neutral", 0.5
-
-    # ========================================================================
-    # 📊 CÁLCULO DE QUALIDADE
-    # ========================================================================
-    
-    def _calcular_qualidade_resposta(self, mensagem: str, resposta: str, tipo_mensagem: str) -> float:
-        """
-        Calcula qualidade da resposta
-        
-        Args:
-            mensagem: Mensagem do usuário
-            resposta: Resposta do bot
-            tipo_mensagem: Tipo da mensagem
-            
-        Returns:
-            Score de qualidade (0.0 a 1.0)
-        """
-        qualidade = 0.5  # Base
-        
-        # Fatores positivos
-        if 10 < len(resposta) < 300:
-            qualidade += 0.2
-        
-        if len(mensagem) > 5:
-            qualidade += 0.1
-        
-        if tipo_mensagem == 'texto':
-            qualidade += 0.1
-        
-        # Verifica problemas comuns
-        problemas = [
-            ("kkk", resposta.lower().count("kkk") > 3),
-            ("rsrs", resposta.lower().count("rsrs") > 3),
-            ('"', resposta.count('"') > 5),
-            ("**", resposta.count('**') > 2),
-        ]
-        
-        # Penaliza problemas
-        for _, condicao in problemas:
-            if condicao:
-                qualidade -= 0.05
-        
-        # Limites
-        qualidade = max(0.1, min(1.0, qualidade))
-        
-        return round(qualidade, 2)
-
-    # ========================================================================
-    # 💾 ADICIONAR AO DATASET (ATUALIZADO)
-    # ========================================================================
-    
-    def _adicionar_ao_dataset(
-        self,
-        mensagem: str,
-        resposta: str,
-        numero: str,
-        usuario: str,
-        contexto: Dict,
-        emocao_detectada: str,
-        confianca_emocao: float,
-        qualidade: float,
-        tipo_mensagem: str,
-        tipo_conversa: str,
-        is_reply: bool,
-        reply_to_bot: bool,
-        reply_metadata: Optional[Dict] = None,
-        nivel_transicao: int = 0  # NOVO PARÂMETRO
-    ):
-        """
-        Adiciona exemplo ao dataset de treinamento - ATUALIZADO
-        
-        Args:
-            mensagem: Mensagem do usuário
-            resposta: Resposta do bot
-            numero: Número do usuário
-            usuario: Nome do usuário
-            contexto: Contexto da conversa
-            emocao_detectada: Emoção detectada
-            confianca_emocao: Confiança da detecção
-            qualidade: Score de qualidade
-            tipo_mensagem: Tipo da mensagem
-            tipo_conversa: Tipo da conversa
-            is_reply: Se é reply
-            reply_to_bot: Se é reply ao bot
-            reply_metadata: Metadata do reply
-            nivel_transicao: Nível de transição do usuário
-        """
-        try:
-            humor = contexto.get("humor_atualizado", "normal_ironico")
-            modo = contexto.get("modo_resposta", "normal_ironico")
-            
-            # Garante formato correto do humor
-            if "ironic" not in humor and "ironica" not in humor:
-                if humor.endswith("o"):
-                    humor = f"{humor}_ironico"
-                elif humor.endswith("a"):
-                    humor = f"{humor}_ironica"
-                else:
-                    humor = f"{humor}_ironico"
-            
-            # Normaliza modo
-            if modo == "casual_amigavel":
-                modo = "normal_ironico"
-            
-            # Prepara metadados com reply_metadata e nivel_transicao
-            metadata = {
-                "usuario": usuario[:20],
-                "numero_hash": hashlib.md5(numero.encode()).hexdigest()[:8],
-                "humor": humor,
-                "modo_resposta": modo,
-                "nivel_transicao": nivel_transicao,  # ADICIONADO
-                "emocao_detectada": emocao_detectada,
-                "confianca_emocao": confianca_emocao,
-                "qualidade_score": qualidade,
-                "is_reply": is_reply,
-                "reply_to_bot": reply_to_bot,
-                "tipo_mensagem": tipo_mensagem,
-                "tipo_conversa": tipo_conversa,
-                "timestamp": time.time(),
-                "version": "v21_indexjs"
-            }
-            
-            # Adiciona reply_metadata se disponível
-            if reply_metadata:
-                metadata.update({
-                    "reply_metadata_quoted_author": reply_metadata.get('quoted_author_name', 'N/A'),
-                    "reply_metadata_is_reply": reply_metadata.get('is_reply', False),
-                    "reply_metadata_context": reply_metadata.get('context_hint', '')
-                })
-            
-            # Adiciona info_transicao se disponível
-            info_transicao = contexto.get('info_transicao', {})
-            if info_transicao:
-                metadata.update({
-                    "info_transicao_desc": info_transicao.get('desc', ''),
-                    "info_transicao_modo": info_transicao.get('modo', ''),
-                    "info_transicao_deve_transicionar": info_transicao.get('deve_transicionar', False)
-                })
-            
-            entry = {
-                "input": mensagem.strip(),
-                "output": resposta.strip(),
-                "metadata": metadata
-            }
-            
-            with _lock:
-                dataset = []
-                if os.path.exists(DATASET_PATH):
-                    try:
-                        with open(DATASET_PATH, "r", encoding="utf-8") as f:
-                            dataset = json.load(f)
-                            if not isinstance(dataset, list):
-                                dataset = []
-                    except:
-                        dataset = []
-                
-                # Remove duplicatas
-                entry_hash = hashlib.md5(f"{mensagem}{resposta}".encode()).hexdigest()
-                dataset = [e for e in dataset if
-                          hashlib.md5(f"{e.get('input','')}{e.get('output','')}".encode()).hexdigest() != entry_hash]
-                
-                dataset.append(entry)
-                
-                # Mantém apenas melhores exemplos
-                if len(dataset) > MAX_EXEMPLOS_DATASET:
-                    dataset.sort(key=lambda x: x.get("metadata", {}).get("qualidade_score", 0), reverse=True)
-                    dataset = dataset[:MAX_EXEMPLOS_DATASET]
-                
-                with open(DATASET_PATH, "w", encoding="utf-8") as f:
-                    json.dump(dataset, f, ensure_ascii=False, indent=2)
-                
-                logger.debug(f"✅ Exemplo adicionado ao dataset | nível: {nivel_transicao} | qualidade: {qualidade:.2f}")
-        
-        except Exception as e:
-            logger.warning(f"⚠️ Erro ao adicionar ao dataset: {e}")
-
-    # ========================================================================
-    # 🔍 ANÁLISE DE PADRÕES (ATUALIZADA)
-    # ========================================================================
-    
-    def _analisar_padroes_usuario(
-        self,
-        numero: str,
-        usuario: str,
-        mensagem: str,
-        resposta: str,
-        contexto: Dict,
-        emocao_detectada: str,
-        tipo_conversa: str,
-        is_reply: bool,
-        reply_to_bot: bool,
-        reply_metadata: Optional[Dict] = None,
-        nivel_transicao: int = 0  # NOVO PARÂMETRO
-    ):
-        """
-        Analisa padrões de comunicação do usuário - ATUALIZADA
-        
-        Args:
-            numero: Número do usuário
-            usuario: Nome do usuário
-            mensagem: Mensagem enviada
-            resposta: Resposta gerada
-            contexto: Contexto da conversa
-            emocao_detectada: Emoção detectada
-            tipo_conversa: Tipo da conversa
-            is_reply: Se é reply
-            reply_to_bot: Se é reply ao bot
-            reply_metadata: Metadata do reply
-            nivel_transicao: Nível de transição do usuário
-        """
-        try:
-            # 1. REGISTRAR TOM
-            tom = self._detectar_tom(mensagem)
-            if tom:
-                self.db.registrar_tom_usuario(numero, tom)
-            
-            # 2. APRENDER GÍRIAS
-            girias_detectadas = self._detectar_girias(mensagem)
-            for giria, significado in girias_detectadas.items():
-                try:
-                    self.db.salvar_giria(
-                        numero=numero,
-                        giria=giria,
-                        significado=significado,
-                        contexto=mensagem[:100]
-                    )
-                except Exception as e:
-                    logger.warning(f"Erro ao salvar gíria: {e}")
-            
-            # 3. REGISTRAR TRANSIÇÃO DE HUMOR COM nivel_transicao
-            if "humor_atualizado" in contexto:
-                humor = contexto["humor_atualizado"]
-                humor_atual = self.db.recuperar_humor_atual(numero)
-                nivel_atual = self.db.recuperar_nivel_transicao(numero)
-                
-                if humor != humor_atual or nivel_transicao != nivel_atual:
-                    self.db.salvar_transicao_humor(
-                        numero=numero,
-                        humor_anterior=humor_atual,
-                        humor_novo=humor,
-                        nivel_transicao_anterior=nivel_atual,
-                        nivel_transicao_novo=nivel_transicao,
-                        emocao_trigger=emocao_detectada,
-                        confianca_emocao=contexto.get('confianca_emocao', 0.5),
-                        razao=f"Transição nível {nivel_atual}→{nivel_transicao} | {tipo_conversa}"
-                    )
-            
-            # 4. APRENDER PADRÕES DE REPLY COM nivel_transicao
-            if is_reply:
-                self._aprender_padrao_reply(
-                    numero=numero,
-                    usuario=usuario,
-                    mensagem=mensagem,
-                    resposta=resposta,
-                    reply_to_bot=reply_to_bot,
-                    tipo_conversa=tipo_conversa,
-                    reply_metadata=reply_metadata,
-                    nivel_transicao=nivel_transicao  # ADICIONADO
-                )
-            
-            # 5. ANALISAR TRANSIÇÕES DE USUÁRIOS PRIVILEGIADOS
-            if nivel_transicao > 0:
-                self._analisar_transicao_privilegiado(
-                    numero=numero,
-                    usuario=usuario,
-                    nivel_transicao=nivel_transicao,
-                    mensagem=mensagem,
-                    contexto=contexto
-                )
-            
-        except Exception as e:
-            logger.warning(f"⚠️ Erro na análise de padrões: {e}")
-
-    def _detectar_tom(self, mensagem: str) -> str:
-        """
-        Detecta tom da mensagem
-        
-        Args:
-            mensagem: Texto da mensagem
-            
-        Returns:
-            Tom detectado
-        """
-        if not mensagem:
-            return "neutro"
-        
-        mensagem_lower = mensagem.lower()
-        
-        # Formal
-        if any(x in mensagem_lower for x in ["senhor", "doutor", "atenciosamente", "por favor"]):
-            return "formal"
-        
-        # Rude
-        rude_palavras = ["burro", "idiota", "merda", "porra", "caralho", "vai se foder"]
-        if any(x in mensagem_lower for x in rude_palavras):
-            return "rude"
-        
-        # Informal/Angolano
-        girias = ['puto', 'mano', 'kota', 'fixe', 'bué', 'ya']
-        if any(x in mensagem_lower for x in girias):
-            return "informal_angolano"
-        
-        return "neutro"
-
-    def _detectar_girias(self, mensagem: str) -> Dict[str, str]:
-        """
-        Detecta gírias angolanas
-        
-        Args:
-            mensagem: Texto da mensagem
-            
-        Returns:
-            Dicionário {giria: significado}
-        """
-        girias = {
-            "puto": "amigo/cara", 
-            "fixe": "legal/bacana", 
-            "bué": "muito/bastante",
-            "mwangolé": "meu angolano", 
-            "kota": "pessoa mais velha",
-            "ya": "sim", 
-            "epha": "irritação",
-            "maka": "problema", 
-            "kandengue": "criança"
-        }
-        
-        msg_lower = mensagem.lower()
-        detectadas = {}
-        
-        for giria, significado in girias.items():
-            if giria in msg_lower:
-                detectadas[giria] = significado
-        
-        return detectadas
-
-    def _aprender_padrao_reply(
-        self,
-        numero: str,
-        usuario: str,
-        mensagem: str,
-        resposta: str,
-        reply_to_bot: bool,
-        tipo_conversa: str,
-        reply_metadata: Optional[Dict] = None,
-        nivel_transicao: int = 0  # NOVO PARÂMETRO
-    ):
-        """
-        Aprende padrões de reply - ATUALIZADO
-        
-        Args:
-            numero: Número do usuário
-            usuario: Nome do usuário
-            mensagem: Mensagem enviada
-            resposta: Resposta gerada
-            reply_to_bot: Se é reply ao bot
-            tipo_conversa: Tipo da conversa
-            reply_metadata: Metadata do reply
-            nivel_transicao: Nível de transição do usuário
-        """
-        try:
-            # Define padrão com base no reply_metadata
-            if reply_metadata:
-                quoted_author = reply_metadata.get('quoted_author_name', 'N/A')
-                if reply_to_bot or quoted_author.lower() == 'akira':
-                    padrao = "resposta_a_mensagem_do_bot"
-                    tipo = "reply_ao_bot"
-                else:
-                    padrao = "comentario_sobre_conversa_alheia"
-                    tipo = "conversa_alheia"
-                
-                contexto_extra = f"[Autor citado: {quoted_author}]"
-            else:
-                if reply_to_bot:
-                    padrao = "resposta_a_mensagem_do_bot"
-                    tipo = "reply_ao_bot"
-                    contexto_extra = ""
-                else:
-                    padrao = "comentario_sobre_conversa_alheia"
-                    tipo = "conversa_alheia"
-                    contexto_extra = ""
-            
-            # Adiciona info de transição se disponível
-            transicao_info = f"[Nível transição: {nivel_transicao}]" if nivel_transicao > 0 else ""
-            
-            # Prepara texto com contexto
-            input_text_com_contexto = f"[CONTEXTO: {padrao.upper()}] {transicao_info} {contexto_extra} {mensagem}"
-            
-            # Salva aprendizado com nivel_transicao
-            self.db.salvar_aprendizado_detalhado(
-                input_text=input_text_com_contexto,
-                output_text=resposta,
-                contexto={
-                    'numero': numero,
-                    'usuario': usuario,
-                    'padrao': padrao,
-                    'reply_to_bot': reply_to_bot,
-                    'tipo_conversa': tipo_conversa,
-                    'tipo': tipo,
-                    'reply_metadata': reply_metadata,
-                    'nivel_transicao': nivel_transicao  # ADICIONADO
-                },
-                qualidade_score=0.8,
-                tipo_aprendizado=f"reply_{tipo}_nivel_{nivel_transicao}"
-            )
-            
-            logger.debug(f"✅ Padrão de reply aprendido: {padrao} | Nível: {nivel_transicao}")
-            
-        except Exception as e:
-            logger.warning(f"⚠️ Erro ao aprender padrão de reply: {e}")
-
-    def _analisar_transicao_privilegiado(
-        self,
-        numero: str,
-        usuario: str,
-        nivel_transicao: int,
-        mensagem: str,
-        contexto: Dict
-    ):
-        """
-        Analisa transições de usuários privilegiados
-        
-        Args:
-            numero: Número do usuário
-            usuario: Nome do usuário
-            nivel_transicao: Nível atual de transição
-            mensagem: Mensagem enviada
-            contexto: Contexto da conversa
-        """
-        try:
-            # Recupera histórico de transições
-            transicoes = self.db._execute_with_retry(
-                """
-                SELECT nivel_transicao_anterior, nivel_transicao_novo, timestamp, razao
-                FROM transicoes_humor
-                WHERE numero = ?
-                ORDER BY timestamp DESC
-                LIMIT 10
-                """,
-                (numero,),
-                fetch=True
-            )
-            
-            # Analisa padrão de transição
-            if len(transicoes) >= 3:
-                niveis = [t[1] for t in transicoes]  # Últimos níveis novos
-                mudancas = sum(1 for i in range(len(niveis)-1) if niveis[i] != niveis[i+1])
-                
-                # Se muitas mudanças, usuário é volátil
-                if mudancas >= 2:
-                    logger.info(f"⚠️ Usuário {usuario} é volátil em transições: {mudancas} mudanças")
-            
-            logger.debug(f"📊 Transição privilegiado: {usuario} → Nível {nivel_transicao}")
-            
-        except Exception as e:
-            logger.warning(f"⚠️ Erro na análise de transição: {e}")
-
-    # ========================================================================
-    # 🔄 TREINAMENTO PERIÓDICO
-    # ========================================================================
-    
-    def start_periodic_training(self):
-        """Inicia treinamento periódico em background"""
-        if self._loop_thread is None or not self._loop_thread.is_alive():
-            self.running = True
-            self._loop_thread = threading.Thread(target=self._training_loop, daemon=True)
-            self._loop_thread.start()
-            logger.info("✅ Treinamento periódico iniciado")
-        else:
-            logger.warning("⚠️ Treinamento já ativo")
-
-    def stop_periodic_training(self):
-        """Para treinamento periódico"""
-        self.running = False
-        if self._loop_thread and self._loop_thread.is_alive():
-            self._loop_thread.join(timeout=5)
-        logger.info("✅ Treinamento periódico parado")
-
-    def _training_loop(self):
-        """Loop principal de treinamento"""
-        while self.running:
-            try:
-                time.sleep(self.interval_seconds)
-                logger.info("🔄 Iniciando ciclo de treinamento...")
-                
-                self._gerar_dataset()
-                self._analisar_padroes_globais()
-                self._otimizar_banco()
-                
-                logger.success("✅ Ciclo de treinamento concluído")
-                
-            except Exception as e:
-                logger.error(f"❌ Erro no treinamento: {e}")
-
-    def _gerar_dataset(self):
-        """Gera dataset de treinamento"""
-        try:
-            exemplos = self.db.recuperar_training_examples(limite=1000)
-            if not exemplos:
-                logger.warning("⚠️ Nenhum exemplo para treinar")
-                return
-            
-            exemplos = [e for e in exemplos if e.get("score", 0) >= QUALIDADE_MINIMA]
-            if not exemplos:
-                logger.warning("⚠️ Nenhum exemplo com qualidade suficiente")
-                return
-
-            # Gera arquivo JSONL com nivel_transicao
-            with open("training_dataset_akira_v21.jsonl", "w", encoding="utf-8") as f:
-                for ex in exemplos[:500]:
-                    if ex.get("score", 0) >= 0.7:
-                        f.write(json.dumps({
-                            "input": ex.get("input", ""),
-                            "output": ex.get("output", ""),
-                            "humor": ex.get("humor", "normal_ironico"),
-                            "modo": ex.get("modo", "normal_ironico"),
-                            "nivel_transicao": ex.get("nivel_transicao", 0),  # ADICIONADO
-                            "metadata": {
-                                "score": ex.get("score", 0.5),
-                                "timestamp": time.time(),
-                                "version": "v21"
-                            }
-                        }, ensure_ascii=False) + "\n")
-            
-            logger.info(f"✅ Dataset gerado: {len(exemplos)} exemplos (com nível transição)")
-            self.db.marcar_examples_como_usados()
-            
-        except Exception as e:
-            logger.error(f"❌ Erro ao gerar dataset: {e}")
-
-    def _analisar_padroes_globais(self):
-        """Analisa padrões globais do dataset"""
-        try:
-            if not os.path.exists(DATASET_PATH):
-                return
-            
-            with open(DATASET_PATH, "r", encoding="utf-8") as f:
-                dataset = json.load(f)
-
-            # Análise estatística com nivel_transicao
-            padroes = {
-                "total": len(dataset),
-                "reply_to_bot": 0,
-                "not_reply_to_bot": 0,
-                "reply_with_metadata": 0,
-                "grupo": 0,
-                "pv": 0,
-                "audio": 0,
-                "texto": 0,
-                "transicao_nivel_0": 0,
-                "transicao_nivel_1": 0,
-                "transicao_nivel_2": 0,
-                "transicao_nivel_3": 0
-            }
-            
-            for e in dataset:
-                meta = e.get("metadata", {})
-                if meta.get("reply_to_bot", False):
-                    padroes["reply_to_bot"] += 1
-                else:
-                    padroes["not_reply_to_bot"] += 1
-                
-                if meta.get("reply_metadata_quoted_author"):
-                    padroes["reply_with_metadata"] += 1
-                
-                if meta.get("tipo_conversa") == 'grupo':
-                    padroes["grupo"] += 1
-                else:
-                    padroes["pv"] += 1
-                
-                if meta.get("tipo_mensagem") == 'audio':
-                    padroes["audio"] += 1
-                else:
-                    padroes["texto"] += 1
-                
-                # Analisa nível de transição
-                nivel = meta.get("nivel_transicao", 0)
-                if nivel == 0:
-                    padroes["transicao_nivel_0"] += 1
-                elif nivel == 1:
-                    padroes["transicao_nivel_1"] += 1
-                elif nivel == 2:
-                    padroes["transicao_nivel_2"] += 1
-                elif nivel == 3:
-                    padroes["transicao_nivel_3"] += 1
-            
-            # Log estatísticas
-            logger.info(f"📊 Estatísticas do dataset:")
-            logger.info(f"  Total: {padroes['total']}")
-            logger.info(f"  Reply ao bot: {padroes['reply_to_bot']} ({padroes['reply_to_bot']/max(padroes['total'],1)*100:.1f}%)")
-            logger.info(f"  Não reply ao bot: {padroes['not_reply_to_bot']} ({padroes['not_reply_to_bot']/max(padroes['total'],1)*100:.1f}%)")
-            logger.info(f"  Com reply_metadata: {padroes['reply_with_metadata']}")
-            logger.info(f"  Grupo: {padroes['grupo']} | PV: {padroes['pv']}")
-            logger.info(f"  Áudio: {padroes['audio']} | Texto: {padroes['texto']}")
-            logger.info(f"  Níveis transição: 0={padroes['transicao_nivel_0']} | 1={padroes['transicao_nivel_1']} | 2={padroes['transicao_nivel_2']} | 3={padroes['transicao_nivel_3']}")
-            
-        except Exception as e:
-            logger.error(f"❌ Erro na análise global: {e}")
-
-    def _otimizar_banco(self):
-        """Otimiza banco de dados"""
-        try:
-            self.db._execute_with_retry("VACUUM", commit=True, fetch=False)
-            self.db._execute_with_retry("ANALYZE", commit=True, fetch=False)
-            logger.info("✅ Banco otimizado")
-        except Exception as e:
-            logger.warning(f"⚠️ Erro na otimização: {e}")
-
-    # ========================================================================
-    # 🔧 FUNÇÃO PARA USO DIRETO DA API (ATUALIZADA)
-    # ========================================================================
-    
-    def processar_interacao_api(self, payload: Dict, resposta: str) -> Dict:
-        """
-        Processa interação da API para treinamento - ATUALIZADA
-        
-        Args:
-            payload: Payload da requisição
-            resposta: Resposta gerada
-            
-        Returns:
-            Resultado do processamento
-        """
-        try:
-            # Extrai dados do payload (compatível com index.js)
-            usuario = payload.get('usuario', 'Anônimo')
-            numero = payload.get('numero', '')
-            mensagem = payload.get('mensagem', '')
-            tipo_conversa = payload.get('tipo_conversa', 'pv')
-            tipo_mensagem = payload.get('tipo_mensagem', 'texto')
-            
-            # Extrai reply_metadata
-            reply_metadata = payload.get('reply_metadata', {})
-            
-            # Determina reply_to_bot
-            reply_to_bot = False
-            if reply_metadata:
-                reply_to_bot = reply_metadata.get('reply_to_bot', False)
-            
-            is_reply = bool(payload.get('mensagem_citada')) or bool(reply_metadata)
-            
-            # Contexto da análise com nivel_transicao
-            contexto_analise = payload.get('analise', {})
-            nivel_transicao = contexto_analise.get('nivel_transicao', 0)
-            
-            # Registra interação com nivel_transicao
-            self.registrar_interacao(
-                usuario=usuario,
-                mensagem=mensagem,
-                resposta=resposta,
-                numero=numero,
-                is_reply=is_reply,
-                mensagem_original=payload.get('mensagem_citada', ''),
-                contexto=contexto_analise,
-                tipo_conversa=tipo_conversa,
-                tipo_mensagem=tipo_mensagem,
-                reply_to_bot=reply_to_bot,
-                reply_metadata=reply_metadata,
-                nivel_transicao=nivel_transicao  # ADICIONADO
-            )
-            
-            return {
-                'status': 'success',
-                'message': 'Interação registrada',
-                'usuario': usuario,
-                'nivel_transicao': nivel_transicao,
-                'timestamp': time.time()
-            }
-            
-        except Exception as e:
-            logger.error(f"❌ Erro ao processar interação: {e}")
-            return {
-                'status': 'error',
-                'message': str(e)
-            }
-
-# ============================================================================
-# 🌐 INSTÂNCIA GLOBAL
-# ============================================================================
-_treinamento_instance = None
-
-def get_treinamento_instance(db: Database = None):
-    """
-    Retorna instância singleton do treinamento
-    
-    Args:
-        db: Instância do Database
-        
-    Returns:
-        Instância do Treinamento
-    """
-    global _treinamento_instance
-    if _treinamento_instance is None:
-        if db is None:
-            from .database import get_database
-            db = get_database()
-        _treinamento_instance = Treinamento(db, interval_hours=6)
-    return _treinamento_instance
-
-# ============================================================================
-# 🎯 FUNÇÃO DE INTEGRAÇÃO RÁPIDA (ATUALIZADA)
-# ============================================================================
-def registrar_interacao_rapida(
-    usuario: str,
-    numero: str,
-    mensagem: str,
-    resposta: str,
-    is_reply: bool = False,
-    reply_to_bot: bool = False,
-    tipo_conversa: str = 'pv',
-    tipo_mensagem: str = 'texto',
-    contexto: Dict = None,
-    reply_metadata: Optional[Dict] = None,
-    nivel_transicao: int = 0  # NOVO PARÂMETRO
-) -> bool:
-    """
-    Registra interação rapidamente - ATUALIZADA
-    
-    Args:
-        usuario: Nome do usuário
-        numero: Número do usuário
-        mensagem: Mensagem enviada
-        resposta: Resposta gerada
-        is_reply: Se é reply
-        reply_to_bot: Se é reply ao bot
-        tipo_conversa: Tipo da conversa
-        tipo_mensagem: Tipo da mensagem
-        contexto: Contexto da conversa
-        reply_metadata: Metadata do reply
-        nivel_transicao: Nível de transição do usuário
-        
-    Returns:
-        True se sucesso, False caso contrário
-    """
-    try:
-        treinamento = get_treinamento_instance()
-        treinamento.registrar_interacao(
-            usuario=usuario,
-            mensagem=mensagem,
-            resposta=resposta,
-            numero=numero,
-            is_reply=is_reply,
-            reply_to_bot=reply_to_bot,
-            tipo_conversa=tipo_conversa,
-            tipo_mensagem=tipo_mensagem,
-            contexto=contexto,
-            reply_metadata=reply_metadata,
-            nivel_transicao=nivel_transicao  # ADICIONADO
-        )
-        logger.debug(f"✅ Interação rápida registrada: {usuario[:10]} | Nível: {nivel_transicao}")
-        return True
-    except Exception as e:
-        logger.error(f"❌ Erro no registro rápido: {e}")
-        return False
-
-# ============================================================================
-# 📊 TESTE E VALIDAÇÃO
-# ============================================================================
-if __name__ == "__main__":
-    print("=" * 80)
-    print("TESTANDO TREINAMENTO.PY - COMPLETO COM nivel_transicao")
-    print("=" * 80)
-    
-    from .database import Database
-    
-    try:
-        # Cria database de teste
-        db = Database(":memory:")
-        treinamento = Treinamento(db)
-        
-        # Simula payload do api.py com reply_metadata e nivel_transicao
-        payload_teste = {
-            "usuario": "Isaac Teste",
-            "numero": "244978787009",
-            "mensagem": "Oi Akira, tudo bem?",
-            "tipo_conversa": "pv",
-            "tipo_mensagem": "texto",
-            "reply_metadata": {
-                "is_reply": True,
-                "reply_to_bot": False,
-                "quoted_author_name": "Outra Pessoa",
-                "context_hint": "(Citando mensagem de Outra Pessoa)"
-            },
-            "analise": {
-                "humor_atualizado": "normal_ironico",
-                "modo_resposta": "normal_ironico",
-                "nivel_transicao": 2,
-                "info_transicao": {
-                    "desc": "Nível 2 - Formal Relaxado",
-                    "modo": "tecnico_formal",
-                    "deve_transicionar": False
-                }
-            }
-        }
-        
-        resposta_teste = "Tudo e tu, puto?"
-        
-        # Processa interação com nivel_transicao
-        resultado = treinamento.processar_interacao_api(payload_teste, resposta_teste)
-        
-        print(f"✅ Teste OK: {resultado}")
-        print(f"📝 Mensagem: {payload_teste['mensagem']}")
-        print(f"💬 Resposta: {resposta_teste}")
-        print(f"🎯 Nível transição: {payload_teste['analise']['nivel_transicao']}")
-        
-        # Teste com registro rápido com nivel_transicao
-        sucesso = registrar_interacao_rapida(
-            usuario="Teste 2",
-            numero="244000000000",
-            mensagem="Qual é a tua?",
-            resposta="Nada, cota.",
-            is_reply=True,
-            reply_to_bot=True,
-            reply_metadata={"quoted_author_name": "Akira", "is_reply": True},
-            nivel_transicao=3
-        )
-        
-        print(f"✅ Registro rápido: {'Sucesso' if sucesso else 'Falhou'}")
-        
-    except Exception as e:
-        print(f"❌ Erro: {e}")
-        import traceback
-        traceback.print_exc()
-    
-    print("\n" + "=" * 80)
-    print("TREINAMENTO.PY - COMPLETO COM SUPORTE A nivel_transicao")
-    print("=" * 80)
+# type: ignore
+# treinamento.py
+# ================================================================
+# TREINAMENTO AVANÇADO 3-NÍVEIS - AKIRA IA V21 ULTIMATE
+# ================================================================
+# Arquitetura: Multi-nível (Emocional + NLP + API Adapter)
+# NLP Levels: Basic → Intermediate → Advanced (BART + Transformers)
+# Emoções: Análise avançada com BART + heurísticas
+# APIs: Mistral, Gemini, Groq, Cohere, Together, HuggingFace
+# ================================================================
+
+import threading
+import time
+import json
+import hashlib
+from dataclasses import dataclass, field
+from typing import Optional, List, Dict, Any, Tuple, Callable
+from pathlib import Path
+from datetime import datetime
+import re
+import random
+
+# Imports opcionais com fallback (type: ignore para evitar erros de ambiente)
+try:
+    import numpy as np  # type: ignore
+    NUMPY_AVAILABLE = True
+except Exception:
+    NUMPY_AVAILABLE = False
+    np = None  # type: ignore
+
+try:
+    from loguru import logger  # type: ignore
+    LOGURU_AVAILABLE = True
+except Exception:
+    LOGURU_AVAILABLE = False
+    # Criar logger dummy para evitar erros de tipo
+    class DummyLogger:
+        def info(self, *args, **kwargs): pass
+        def success(self, *args, **kwargs): pass
+        def warning(self, *args, **kwargs): pass
+        def error(self, *args, **kwargs): pass
+        def debug(self, *args, **kwargs): pass
+        def exception(self, *args, **kwargs): pass
+    logger = DummyLogger()  # type: ignore
+
+try:
+    from sentence_transformers import SentenceTransformer  # type: ignore
+    SENTENCE_TRANSFORMERS_AVAILABLE = True
+except Exception as e:
+    SENTENCE_TRANSFORMERS_AVAILABLE = False
+    SentenceTransformer = None  # type: ignore
+
+try:
+    import torch  # type: ignore
+    TORCH_AVAILABLE = True
+except Exception:
+    TORCH_AVAILABLE = False
+    torch = None  # type: ignore
+
+try:
+    from transformers import AutoTokenizer, AutoModelForSequenceClassification  # type: ignore
+    TRANSFORMERS_AVAILABLE = True
+except Exception:
+    TRANSFORMERS_AVAILABLE = False
+    AutoTokenizer = None  # type: ignore
+    AutoModelForSequenceClassification = None  # type: ignore
+
+# Imports locais
+from . import config
+from .database import Database
+
+# ============================================================
+# 🎯 CONFIGURAÇÕES DE TREINAMENTO
+# ============================================================
+
+@dataclass
+class TrainingConfig:
+    """Configuração do sistema de treinamento 3-níveis"""
+    # Nível 1: Emoções
+    enable_emotion_training: bool = True
+    emotion_model: str = config.BART_EMOTION_MODEL
+    emotion_confidence_threshold: float = 0.7
+    
+    # Nível 2: NLP & Embeddings
+    enable_nlp_training: bool = True
+    embedding_model: str = config.EMBEDDING_MODEL
+    embedding_dim: int = config.EMBEDDING_DIM
+    
+    # Nível 3: API Adapter
+    enable_api_training: bool = True
+    track_api_performance: bool = True
+    
+    # Gerais
+    batch_size: int = 32
+    learning_rate: float = 0.001
+    max_samples_per_user: int = 100
+    training_interval_hours: int = 6
+    min_samples_for_training: int = 5
+
+# Configuração ativa
+TRAINING_CONFIG = TrainingConfig()
+
+# ============================================================
+# 🔧 EMBEDDINGS & MODELOS
+# ============================================================
+
+class EmbeddingManager:
+    """Gerenciador de embeddings com suporte a múltiplos modelos"""
+    
+    _instance = None
+    _model_lock = threading.Lock()
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        if self._initialized:
+            return
+        self._initialized = True
+        self._model = None
+        self._embedding_dim = None
+    
+    def load_model(self, model_name: Optional[str] = None) -> bool:
+        """Carrega modelo de embeddings sob demanda"""
+        if self._model is not None:
+            return True
+        
+        with self._model_lock:
+            if self._model is not None:
+                return True
+            
+            if not SENTENCE_TRANSFORMERS_AVAILABLE:
+                logger.warning("SentenceTransformers não disponível")
+                return False
+            
+            model_to_load = model_name or TRAINING_CONFIG.embedding_model
+            
+            try:
+                self._model = SentenceTransformer(model_to_load)
+                self._embedding_dim = self._model.get_sentence_embedding_dimension()
+                logger.success(f"✅ Embedding model carregado: {model_to_load} (dim={self._embedding_dim})")
+                return True
+            except Exception as e:
+                logger.error(f"❌ Erro ao carregar embedding model: {e}")
+                return False
+    
+    def generate_embedding(self, text: str) -> Optional[Any]:
+        """Gera embedding para texto"""
+        if not self.load_model():
+            return None
+        
+        try:
+            emb = self._model.encode(text, convert_to_numpy=True)
+            return emb
+        except Exception as e:
+            logger.warning(f"Erro ao gerar embedding: {e}")
+            return None
+    
+    def generate_batch_embeddings(self, texts: List[str]) -> Optional[Any]:
+        """Gera embeddings para batch de textos"""
+        if not self.load_model():
+            return None
+        
+        try:
+            embeddings = self._model.encode(texts, convert_to_numpy=True, batch_size=len(texts))
+            return embeddings
+        except Exception as e:
+            logger.warning(f"Erro ao gerar batch embeddings: {e}")
+            return None
+    
+    def cosine_similarity(self, emb1: np.ndarray, emb2: np.ndarray) -> float:
+        """Calcula similaridade de cossenos"""
+        try:
+            dot = np.dot(emb1, emb2)
+            norm1 = np.linalg.norm(emb1)
+            norm2 = np.linalg.norm(emb2)
+            if norm1 == 0 or norm2 == 0:
+                return 0.0
+            return float(dot / (norm1 * norm2))
+        except Exception:
+            return 0.0
+    
+    @property
+    def embedding_dim(self) -> int:
+        return self._embedding_dim or TRAINING_CONFIG.embedding_dim
+
+# Singleton
+embedding_manager = EmbeddingManager()
+
+# ============================================================
+# 🎭 ANALISADOR DE EMOÇÕES (Via Singleton Central)
+# ============================================================
+
+# Singleton importado para não duplicar o modelo BART em memória
+emotion_trainer = config.get_emotion_analyzer()
+
+# ============================================================
+# 🧠 API ADAPTER TRAINER
+# ============================================================
+
+class APIAdapterTrainer:
+    """Treinador de adaptação para diferentes APIs (Mistral, Gemini, Groq, etc.)"""
+    
+    def __init__(self, db: Database):
+        self.db = db
+        self.api_stats: Dict[str, Dict[str, Any]] = {}
+        self._init_api_tracking()
+    
+    def _init_api_tracking(self):
+        """Inicializa tracking de APIs"""
+        self.api_stats = {
+            "mistral": {"success": 0, "failure": 0, "avg_response_time": 0, "total_tokens": 0},
+            "gemini": {"success": 0, "failure": 0, "avg_response_time": 0, "total_tokens": 0},
+            "groq": {"success": 0, "failure": 0, "avg_response_time": 0, "total_tokens": 0},
+            "cohere": {"success": 0, "failure": 0, "avg_response_time": 0, "total_tokens": 0},
+            "together": {"success": 0, "failure": 0, "avg_response_time": 0, "total_tokens": 0},
+            "huggingface": {"success": 0, "failure": 0, "avg_response_time": 0, "total_tokens": 0}
+        }
+    
+    def record_api_call(
+        self,
+        provider: str,
+        success: bool,
+        response_time: float,
+        tokens_used: int = 0,
+        error: Optional[str] = None
+    ):
+        """Registra chamada de API para treinamento"""
+        if provider not in self.api_stats:
+            return
+        
+        stats = self.api_stats[provider]
+        
+        if success:
+            stats["success"] += 1
+            # Média móvel do tempo de resposta
+            n = stats["success"]
+            stats["avg_response_time"] = ((n - 1) * stats["avg_response_time"] + response_time) / n
+            stats["total_tokens"] += tokens_used
+        else:
+            stats["failure"] += 1
+        
+        # Salva no banco
+        self._save_api_stats(provider, stats)
+    
+    def _save_api_stats(self, provider: str, stats: Dict[str, Any]):
+        """Salva estatísticas da API no banco"""
+        try:
+            self.db.salvar_aprendizado_detalhado(
+                f"api_{provider}",
+                "stats",
+                json.dumps(stats)
+            )
+        except Exception as e:
+            logger.warning(f"Erro ao salvar stats da API {provider}: {e}")
+    
+    def get_best_provider(self) -> str:
+        """Retorna o melhor provider baseado em成功率 e tempo"""
+        best_score = -1
+        best_provider = "mistral"
+        
+        for provider, stats in self.api_stats.items():
+            if stats["success"] + stats["failure"] < 5:
+                continue
+            
+            success_rate = stats["success"] / (stats["success"] + stats["failure"]) if (stats["success"] + stats["failure"]) > 0 else 0
+            avg_time = stats["avg_response_time"]
+            
+            # Score: sucesso alto + tempo baixo
+            score = success_rate * 0.7 + (1 / (1 + avg_time)) * 0.3
+            
+            if score > best_score:
+                best_score = score
+                best_provider = provider
+        
+        return best_provider
+    
+    def get_provider_stats(self, provider: str) -> Dict[str, Any]:
+        """Retorna estatísticas de um provider"""
+        return self.api_stats.get(provider, {})
+
+# ============================================================
+# 📊 HEURÍSTICAS E DICIONÁRIOS
+# ============================================================
+
+# Palavras para análise heurística
+PALAVRAS_POSITIVAS = ['bom', 'ótimo', 'incrível', 'feliz', 'adorei', 'top', 'fixe', 'bué', 'show', 'legal', 'bacana', 'wah']
+PALAVRAS_NEGATIVAS = ['ruim', 'péssimo', 'triste', 'ódio', 'raiva', 'chateado', 'merda', 'porra', 'odeio', 'caralho']
+PALAVRAS_RUDES = ['caralho', 'puta', 'merda', 'fdp', 'vsf', 'krl', 'porra', 'desgraça']
+
+# Gírias angolanas para treinamento
+GIRIAS_ANGOLANAS = {
+    "puto": ("rapaz/rapariga", "casual"),
+    "mano": ("amigo", "casual"),
+    "kota": ("rapaz da cidade", "urbano"),
+    "mwangolé": ("rapaz do subúrbio", "subúrbio"),
+    "cota": ("dinheiro", "casual"),
+    "fixe": ("bom/ótimo", "positivo"),
+    "bué": ("muito", "intensificador"),
+    "oroh": ("pessoa chata", "negativo"),
+    "baza": ("terminar", "casual"),
+    "kuduro": ("dança urbana", "cultural"),
+    "sassa": ("sofisticado", "urbano"),
+    "kalembe": ("ridículo", "negativo"),
+}
+
+# Intenções para treinamento
+INTENCOES_TREINAMENTO = {
+    "saudacao": ["ola", "oi", "bom dia", "boa tarde", "boa noite", "como vai", "e aí"],
+    "pergunta": ["?", "porquê", "porque", "como", "o que", "qual", "onde", "quando", "quanto"],
+    "afirmacao": ["acho", "creio", "penso", "sei que", "tenho certeza"],
+    "despedida": ["tchau", "até mais", "adeus", "fim", "parar"],
+    "agradecimento": ["obrigado", "thanks", "grato", "agradecido"],
+    "elogio": ["fixe", "bom trabalho", "parabéns", "incrível", "show"],
+    "reclamacao": ["ruim", "péssimo", "odeio", "não gostei", "decepcionado"]
+}
+
+# ============================================================
+# 🎯 ESTRUTURAS DE DADOS
+# ============================================================
+
+@dataclass
+class Interacao:
+    """Estrutura de uma interação para treinamento"""
+    usuario: str
+    mensagem: str
+    resposta: str
+    numero: str
+    is_reply: bool = False
+    mensagem_original: str = ""
+    timestamp: float = field(default_factory=time.time)
+    emocao: str = "neutral"
+    confianca_emocao: float = 0.5
+    intencao: str = "pergunta"
+    api_usada: str = ""
+    tokens_usados: int = 0
+    response_time: float = 0.0
+
+@dataclass
+class TrainingResult:
+    """Resultado de um ciclo de treinamento"""
+    nivel: str
+    amostras_processadas: int
+    embeddings_atualizados: int
+    emocoes_aprendidas: int
+    gírias_aprendidas: int
+    api_adaptations: int
+    duracao_segundos: float
+    sucesso: bool
+    erro: Optional[str] = None
+
+# ============================================================
+# 🏗️ CLASSE PRINCIPAL DE TREINAMENTO
+# ============================================================
+
+class Treinamento:
+    """
+    Sistema de treinamento avançado 3-níveis:
+    - Nível 1: Emoções (BART + Heurísticas)
+    - Nível 2: NLP & Embeddings (SentenceTransformers)
+    - Nível 3: API Adapter (Mistral, Gemini, Groq, etc.)
+    """
+    
+    def __init__(
+        self, 
+        db: Database, 
+        contexto: Optional[Any] = None,
+        interval_hours: int = 6
+    ):
+        self.db = db
+        self.contexto = contexto
+        self.interval_hours = interval_hours
+        
+        # Threading
+        self._thread = None
+        self._running = False
+        self._stop_event = threading.Event()
+        
+        # Componentes
+        self.api_trainer = APIAdapterTrainer(db)
+        
+        # Usuários privilegiados
+        self.privileged_users = getattr(config, 'PRIVILEGED_USERS', ('244937035662', 'isaac', 'isaac quarenta'))
+        
+        # Cache de treinamento
+        self._training_cache: Dict[str, Any] = {}
+        
+        logger.info("🟢 Treinamento 3-níveis inicializado")
+    
+    # ============================================================
+    # 📝 REGISTRO DE INTERAÇÕES
+    # ============================================================
+    
+    def registrar_interacao(
+        self,
+        usuario: str,
+        mensagem: str,
+        resposta: str,
+        numero: str = '',
+        is_reply: bool = False,
+        mensagem_original: str = '',
+        api_usada: str = '',
+        tokens_usados: int = 0,
+        response_time: float = 0.0
+    ) -> Interacao:
+        """
+        Registra interação e executa aprendizado em tempo real
+        """
+        # Cria estrutura de interação
+        interacao = Interacao(
+            usuario=usuario,
+            mensagem=mensagem,
+            resposta=resposta,
+            numero=numero,
+            is_reply=is_reply,
+            mensagem_original=mensagem_original,
+            api_usada=api_usada,
+            tokens_usados=tokens_usados,
+            response_time=response_time
+        )
+        
+        try:
+            # Salva no banco
+            self.db.salvar_mensagem(usuario, mensagem, resposta, numero, is_reply, mensagem_original)
+            
+            # Aprendizado em tempo real
+            self._aprender_em_tempo_real(interacao)
+            
+            # Registra API call se aplicável
+            if api_usada:
+                self.api_trainer.record_api_call(
+                    provider=api_usada,
+                    success=True,
+                    response_time=response_time,
+                    tokens_used=tokens_usados
+                )
+            
+        except Exception as e:
+            logger.error(f"Erro ao registrar interação: {e}")
+            if api_usada:
+                self.api_trainer.record_api_call(
+                    provider=api_usada,
+                    success=False,
+                    response_time=response_time,
+                    error=str(e)
+                )
+        
+        return interacao
+    
+    def _aprender_em_tempo_real(self, interacao: Interacao):
+        """Aprendizado em tempo real (Nível 1 + 2)"""
+        if not interacao.numero:
+            return
+        
+        # Combine mensagem + resposta para análise
+        texto_completo = f"{interacao.mensagem} {interacao.resposta}"
+        texto_lower = texto_completo.lower()
+        
+        # === NÍVEL 1: Análise de Emoções ===
+        # Correção Pylance: verifica se emotion_trainer está disponível
+        if emotion_trainer is not None:
+            analise_emocao = emotion_trainer.analisar(interacao.mensagem)
+            interacao.emocao = analise_emocao.get('emocao', 'neutral')
+            interacao.confianca_emocao = analise_emocao.get('confianca', 0.5)
+        else:
+            interacao.emocao = 'neutral'
+            interacao.confianca_emocao = 0.5
+        
+        # Salva emoção
+        self.db.salvar_aprendizado_detalhado(
+            interacao.numero,
+            "emocao_atual",
+            json.dumps({"emocao": interacao.emocao, "confianca": interacao.confianca_emocao})
+        )
+        
+        # === NÍVEL 2: Embeddings ===
+        # Correção Pylance: verifica se embedding_manager e seu modelo estão disponíveis
+        if embedding_manager is not None and embedding_manager.load_model():
+            embedding = embedding_manager.generate_embedding(texto_completo)
+            if embedding is not None:
+                self.db.salvar_embedding(
+                    interacao.numero,
+                    interacao.mensagem,
+                    interacao.resposta,
+                    embedding
+                )
+        
+        # === Análise de Intenção ===
+        intencao = self._detectar_intencao(texto_lower)
+        interacao.intencao = intencao
+        
+        # === Heurística de Tom ===
+        tom = self._detectar_tom(texto_lower)
+        self.db.registrar_tom_usuario(
+            interacao.numero, 
+            tom, 
+            analise_emocao.get('confianca', 0.5),
+            texto_lower[:200]
+        )
+        
+        # === Aprendizado de Gírias ===
+        self._aprender_girias(interacao.numero, texto_lower)
+    
+    def _detectar_intencao(self, texto: str) -> str:
+        """Detecta intenção do texto"""
+        for intencao, palavras in INTENCOES_TREINAMENTO.items():
+            if any(p in texto for p in palavras):
+                return intencao
+        return "pergunta"  # Default
+    
+    def _detectar_tom(self, texto: str) -> str:
+        """Detecta tom do texto"""
+        rude_count = sum(1 for p in PALAVRAS_RUDES if p in texto)
+        formal_count = sum(1 for p in ["senhor", "doutor", "por favor", "agradecido"] if p in texto)
+        
+        if rude_count > 0:
+            return "rude"
+        elif formal_count > 1:
+            return "formal"
+        elif any(p in texto for p in ["puto", "mano", "fixe", "kkk", "bué"]):
+            return "informal"
+        return "casual"
+    
+    def _aprender_girias(self, numero: str, texto: str):
+        """Aprende gírias do texto"""
+        for giria, (significado, _) in GIRIAS_ANGOLANAS.items():
+            if giria in texto:
+                try:
+                    self.db.salvar_giria_aprendida(
+                        numero,
+                        giria,
+                        significado,
+                        texto[:100]
+                    )
+                except Exception as e:
+                    logger.warning(f"Erro ao salvar gíria {giria}: {e}")
+    
+    # ============================================================
+    # 🎓 TREINAMENTO EM 3 NÍVEIS
+    # ============================================================
+    
+    def train_all_levels(self) -> List[TrainingResult]:
+        """
+        Executa treinamento completo em todos os níveis
+        Returns: Lista de resultados para cada nível
+        """
+        resultados = []
+        start_time = time.time()
+        
+        try:
+            # Nível 1: Emoções
+            logger.info("🎭 Treinando Nível 1: Emoções...")
+            resultado_n1 = self._train_nivel_emocoes()
+            resultados.append(resultado_n1)
+            
+            # Nível 2: NLP & Embeddings
+            logger.info("🧠 Treinando Nível 2: NLP & Embeddings...")
+            resultado_n2 = self._train_nivel_nlp()
+            resultados.append(resultado_n2)
+            
+            # Nível 3: API Adapter
+            logger.info("🔗 Treinando Nível 3: API Adapter...")
+            resultado_n3 = self._train_nivel_api()
+            resultados.append(resultado_n3)
+            
+            duracao_total = time.time() - start_time
+            logger.success(f"✅ Treinamento completo: {duracao_total:.2f}s")
+            
+        except Exception as e:
+            logger.error(f"❌ Erro no treinamento: {e}")
+            resultados.append(TrainingResult(
+                nivel="complete",
+                amostras_processadas=0,
+                embeddings_atualizados=0,
+                emocoes_aprendidas=0,
+                gírias_aprendidas=0,
+                api_adaptations=0,
+                duracao_segundos=time.time() - start_time,
+                sucesso=False,
+                erro=str(e)
+            ))
+        
+        return resultados
+    
+    def _train_nivel_emocoes(self) -> TrainingResult:
+        """Nível 1: Treinamento de emoções"""
+        start_time = time.time()
+        emocoes_aprendidas = 0
+        
+        try:
+            # Recupera usuários com interações
+            usuarios = self._get_usuarios_para_treinamento()
+            
+            for usuario in usuarios:
+                try:
+                    # Recupera mensagens recentes
+                    mensagens = self.db.recuperar_mensagens(usuario, limite=20)
+                    
+                    for msg, resp in mensagens:
+                        if msg and resp:
+                            analise = emotion_trainer.analisar(msg)
+                            
+                            # Salva aprendizado
+                            self.db.salvar_aprendizado_detalhado(
+                                usuario,
+                                f"emocao_{int(time.time())}",
+                                json.dumps(analise)
+                            )
+                            emocoes_aprendidas += 1
+                            
+                except Exception as e:
+                    logger.warning(f"Erro ao treinar emoções para {usuario}: {e}")
+            
+            return TrainingResult(
+                nivel="emocoes",
+                amostras_processadas=len(usuarios),
+                embeddings_atualizados=0,
+                emocoes_aprendidas=emocoes_aprendidas,
+                gírias_aprendidas=0,
+                api_adaptations=0,
+                duracao_segundos=time.time() - start_time,
+                sucesso=True
+            )
+            
+        except Exception as e:
+            return TrainingResult(
+                nivel="emocoes",
+                amostras_processadas=0,
+                embeddings_atualizados=0,
+                emocoes_aprendidas=0,
+                gírias_aprendidas=0,
+                api_adaptations=0,
+                duracao_segundos=time.time() - start_time,
+                sucesso=False,
+                erro=str(e)
+            )
+    
+    def _train_nivel_nlp(self) -> TrainingResult:
+        """Nível 2: Treinamento de NLP & Embeddings"""
+        start_time = time.time()
+        embeddings_atualizados = 0
+        
+        try:
+            if not embedding_manager.load_model():
+                raise Exception("Embedding model não disponível")
+            
+            usuarios = self._get_usuarios_para_treinamento()
+            
+            # Carrega modelo SentenceTransformers
+            model = embedding_manager._model
+            
+            for usuario in usuarios:
+                try:
+                    # Recupera mensagens
+                    mensagens = self.db.recuperar_mensagens(usuario, limite=20)
+                    
+                    # Prepara batch
+                    textos = []
+                    for msg, resp in mensagens:
+                        if msg and resp:
+                            textos.append(f"{msg} {resp}")
+                    
+                    if textos:
+                        # Gera batch embeddings
+                        embeddings = embedding_manager.generate_batch_embeddings(textos)
+                        
+                        if embeddings is not None:
+                            # Salva embeddings no banco
+                            for i, (msg, resp) in enumerate(mensagens[:len(textos)]):
+                                if i < len(embeddings):
+                                    self.db.salvar_embedding(
+                                        usuario,
+                                        msg,
+                                        resp,
+                                        embeddings[i]
+                                    )
+                                    embeddings_atualizados += 1
+                    
+                except Exception as e:
+                    logger.warning(f"Erro ao treinar NLP para {usuario}: {e}")
+            
+            return TrainingResult(
+                nivel="nlp",
+                amostras_processadas=len(usuarios),
+                embeddings_atualizados=embeddings_atualizados,
+                emocoes_aprendidas=0,
+                gírias_aprendidas=0,
+                api_adaptations=0,
+                duracao_segundos=time.time() - start_time,
+                sucesso=True
+            )
+            
+        except Exception as e:
+            return TrainingResult(
+                nivel="nlp",
+                amostras_processadas=0,
+                embeddings_atualizados=0,
+                emocoes_aprendidas=0,
+                gírias_aprendidas=0,
+                api_adaptations=0,
+                duracao_segundos=time.time() - start_time,
+                sucesso=False,
+                erro=str(e)
+            )
+    
+    def _train_nivel_api(self) -> TrainingResult:
+        """Nível 3: Treinamento de API Adapter"""
+        start_time = time.time()
+        api_adaptations = 0
+        
+        try:
+            # Analisa performance das APIs
+            for provider in self.api_trainer.api_stats.keys():
+                stats = self.api_trainer.api_stats[provider]
+                total = stats["success"] + stats["failure"]
+                
+                if total > 0:
+                    success_rate = stats["success"] / total
+                    
+                    # Se success rate < 80%, ajusta estratégia
+                    if success_rate < 0.8:
+                        # Salva adaptação necessária
+                        self.db.salvar_aprendizado_detalhado(
+                            f"api_strategy_{provider}",
+                            "needs_adjustment",
+                            json.dumps({
+                                "success_rate": success_rate,
+                                "avg_response_time": stats["avg_response_time"],
+                                "timestamp": time.time()
+                            })
+                        )
+                        api_adaptations += 1
+            
+            return TrainingResult(
+                nivel="api",
+                amostras_processadas=0,
+                embeddings_atualizados=0,
+                emocoes_aprendidas=0,
+                gírias_aprendidas=0,
+                api_adaptations=api_adaptations,
+                duracao_segundos=time.time() - start_time,
+                sucesso=True
+            )
+            
+        except Exception as e:
+            return TrainingResult(
+                nivel="api",
+                amostras_processadas=0,
+                embeddings_atualizados=0,
+                emocoes_aprendidas=0,
+                gírias_aprendidas=0,
+                api_adaptations=0,
+                duracao_segundos=time.time() - start_time,
+                sucesso=False,
+                erro=str(e)
+            )
+    
+    def _get_usuarios_para_treinamento(self) -> List[str]:
+        """Retorna lista de usuários para treinamento"""
+        try:
+            # Consulta usuários com mensagens
+            result = self.db._execute_with_retry(
+                "SELECT DISTINCT usuario FROM mensagens ORDER BY id DESC LIMIT 50"
+            )
+            return [r[0] for r in result] if result else []
+        except Exception:
+            return []
+    
+    # ============================================================
+    # 🔄 LOOP PERIÓDICO
+    # ============================================================
+    
+    def _run_loop(self):
+        """Loop de treinamento periódico"""
+        interval = max(1, self.interval_hours) * 3600
+        
+        while not self._stop_event.is_set():
+            try:
+                if self._running:
+                    self.train_all_levels()
+            except Exception as e:
+                logger.exception(f"Erro no loop de treinamento: {e}")
+            
+            # Espera com suporte a parada
+            for _ in range(int(interval)):
+                if self._stop_event.is_set():
+                    break
+                time.sleep(1)
+    
+    def start_periodic_training(self):
+        """Inicia treinamento periódico"""
+        if self._running:
+            return
+        
+        self._running = True
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._run_loop, daemon=True)
+        self._thread.start()
+        logger.info(f"🚀 Treinamento periódico iniciado (intervalo: {self.interval_hours}h)")
+    
+    def stop(self):
+        """Para treinamento periódico"""
+        self._running = False
+        self._stop_event.set()
+        if self._thread:
+            self._thread.join(timeout=5)
+        logger.info("⏹️ Treinamento periódico parado")
+    
+    # ============================================================
+    # 📊 UTILITÁRIOS
+    # ============================================================
+    
+    def get_treinamento_status(self) -> Dict[str, Any]:
+        """Retorna status do treinamento"""
+        return {
+            "running": self._running,
+            "interval_hours": self.interval_hours,
+            "embedding_available": embedding_manager.load_model(),
+            "emotion_model_available": emotion_trainer.load_model(),
+            "api_stats": self.api_trainer.api_stats,
+            "privileged_users": len(self.privileged_users)
+        }
+    
+    def obter_estatisticas(self) -> Dict[str, Any]:
+        """
+        Retorna estatísticas do treinamento.
+        Método para compatibilidade com testar_correcoes.py
+        """
+        return {
+            "status": self.get_treinamento_status(),
+            "api_stats": self.api_trainer.api_stats,
+            "usuarios_privilegiados": len(self.privileged_users),
+            "embedding_disponivel": embedding_manager.load_model(),
+            "emotion_model_disponivel": emotion_trainer.load_model()
+        }
+    
+    def limpar_dataset(self) -> bool:
+        """
+        Limpa o cache/dataset de treinamento.
+        Método para compatibilidade com testar_correcoes.py
+        """
+        try:
+            self._training_cache.clear()
+            logger.info("Dataset de treinamento limpo")
+            return True
+        except Exception as e:
+            logger.error(f"Erro ao limpar dataset: {e}")
+            return False
+    
+    def force_train(self) -> List[TrainingResult]:
+        """Força treinamento imediato"""
+        return self.train_all_levels()
+

modules/treinamento_modelo.py

@@ -0,0 +1,103 @@
+import os
+import time
+import json
+from typing import List, Dict, Any, Optional
+from loguru import logger
+from .database import Database
+
+try:
+    import torch
+    from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer, DataCollatorForLanguageModeling
+    from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+    TRAINING_SUPPORTED = True
+except ImportError:
+    TRAINING_SUPPORTED = False
+
+class ModelTrainer:
+    """
+    Classe dedicada ao treinamento (fine-tuning) do modelo local da AKIRA.
+    Focado em PEFT (LoRA) para economia de memória em ambientes como HF Spaces.
+    """
+    def __init__(self, db: Database, model_id: str = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"):
+        self.db = db
+        self.model_id = model_id
+        self.output_dir = "./models/akira-tuned"
+        self.is_training = False
+
+    def prepare_dataset_from_db(self, min_rating: int = 4) -> List[Dict[str, str]]:
+        """Extrai conversas do banco de dados para formatar o dataset de treino."""
+        # Aqui pegamos mensagens onde o bot teve boa performance ou interações ricas
+        # Nota: Adaptar queries conforme a estrutura real do seu DB
+        conversas = self.db.recuperar_historico_global(limite=500)
+        formatted_data = []
+        
+        for msg in conversas:
+            # Formato ChatML ou similar para TinyLlama
+            # <|system|>...<|user|>...<|assistant|>...
+            text = f"<|user|>\n{msg.get('mensagem')}\n<|assistant|>\n{msg.get('resposta')}"
+            formatted_data.append({"text": text})
+            
+        return formatted_data
+
+    def start_finetuning(self, epochs: int = 1):
+        """Inicia o processo de Fine-tuning LoRA em background."""
+        if not TRAINING_SUPPORTED:
+            return {"success": False, "error": "Bibliotecas de treinamento (peft/transformers) não instaladas."}
+        
+        if self.is_training:
+            return {"success": False, "error": "Treinamento já em andamento."}
+
+        try:
+            self.is_training = True
+            logger.info(f"🚀 Iniciando Fine-tuning LoRA no modelo {self.model_id}")
+            
+            # 1. Carregar Tokenizer e Modelo (Quantizado para CPU se necessário)
+            tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+            tokenizer.pad_token = tokenizer.eos_token
+            
+            model = AutoModelForCausalLM.from_pretrained(
+                self.model_id,
+                device_map="auto", # Ou "cpu" explicitamente para HF Spaces Free
+                torch_dtype=torch.float32 # CPU prefere float32 ou bfloat16
+            )
+            
+            # 2. Configurar LoRA
+            config = LoraConfig(
+                r=8, 
+                lora_alpha=32, 
+                target_modules=["q_proj", "v_proj"], 
+                lora_dropout=0.05, 
+                bias="none", 
+                task_type="CAUSAL_LM"
+            )
+            model = get_peft_model(model, config)
+            
+            # 3. Preparar Dados
+            dataset = self.prepare_dataset_from_db()
+            if not dataset:
+                self.is_training = False
+                return {"success": False, "error": "Dataset vazio. Sem conversas suficientes."}
+
+            # 4. Loop de Treino (Simplificado para o exemplo)
+            # Em produção, usaria o Trainer da HuggingFace aqui
+            logger.warning("Treinamento LoRA em CPU é extremamente lento no HF Spaces Free.")
+            
+            # Salvar progresso
+            model.save_pretrained(self.output_dir)
+            tokenizer.save_pretrained(self.output_dir)
+            
+            self.is_training = False
+            return {"success": True, "path": self.output_dir}
+            
+        except Exception as e:
+            self.is_training = False
+            logger.exception(f"Erro no treinamento: {e}")
+            return {"success": False, "error": str(e)}
+
+_trainer = None
+
+def get_model_trainer(db: Database) -> ModelTrainer:
+    global _trainer
+    if not _trainer:
+        _trainer = ModelTrainer(db)
+    return _trainer

modules/unified_context.py

@@ -0,0 +1,894 @@
+# type: ignore
+"""
+================================================================================
+AKIRA V21 ULTIMATE - UNIFIED CONTEXT MODULE
+================================================================================
+Sistema unificado que integra Reply Context + Short-Term Memory em sintonia.
+
+Philosophy: "Reply context e STM devem trabalhar em sintonia como tik e tack -
+um fornece o contexto imediato/urgente (o que o usuário está respondendo),
+o outro fornece o fluxo da conversa (contexto geral)."
+
+Features:
+- Integração seamless entre reply context e STM
+- Token budgeting inteligente entre os dois contextos
+- Priorização dinâmica baseada no tipo de mensagem
+- Suporte a perguntas curtas com reply (prioridade máxima)
+- Persistência e restauração de contexto unificado
+================================================================================
+"""
+
+import os
+import sys
+import time
+import json
+import logging
+from typing import Optional, Dict, Any, List, Tuple
+from dataclasses import dataclass, field
+from datetime import datetime
+
+# Imports robustos com fallback
+try:
+    import modules.config as config
+    from .short_term_memory import (
+        ShortTermMemory, 
+        MessageWithContext, 
+        IMPORTANCIA_NORMAL,
+        IMPORTANCIA_REPLY,
+        IMPORTANCIA_REPLY_TO_BOT,
+        IMPORTANCIA_PERGUNTA_CURTA_REPLY,
+        estimar_tokens,
+        is_pergunta_curta
+    )
+    from .reply_context_handler import (
+        ReplyContextHandler, 
+        ProcessedReplyContext,
+        PRIORITY_REPLY,
+        PRIORITY_REPLY_TO_BOT,
+        PRIORITY_REPLY_TO_BOT_SHORT_QUESTION
+    )
+    UNIFIED_CONTEXT_AVAILABLE = True
+except ImportError as e:
+    UNIFIED_CONTEXT_AVAILABLE = False
+    config = None
+
+logger = logging.getLogger(__name__)
+
+# ============================================================
+# CONFIGURAÇÃO DE TOKEN BUDGET
+# ============================================================
+
+@dataclass
+class ContextTokenBudget:
+    """
+    Alocação de tokens entre reply context e STM.
+    
+    Philosophy: Reply tem orçamento dedicado (urgente), STM tem o resto (fluxo).
+    """
+    total_budget: int = 8000
+    system_tokens: int = 1500
+    user_message_tokens: int = 500
+    
+    # Reply context budget (URGENTE)
+    reply_tokens: int = 300
+    reply_priority_multiplier: float = 1.0
+    
+    # STM budget (FLUXO DA CONVERSA)
+    stm_tokens: int = 4000
+    
+    # Reservado para resposta
+    response_reserved: int = 1200
+    
+    def calculate(self, is_reply: bool, reply_priority: int = 1) -> 'ContextTokenBudget':
+        """
+        Calcula orçamento baseado no tipo de mensagem.
+        
+        Args:
+            is_reply: Se é um reply
+            reply_priority: Nível de prioridade do reply (1-4)
+            
+        Returns:
+            ContextTokenBudget ajustado
+        """
+        budget = ContextTokenBudget(
+            total_budget=self.total_budget,
+            system_tokens=self.system_tokens,
+            user_message_tokens=self.user_message_tokens
+        )
+        
+        if is_reply:
+            if reply_priority >= PRIORITY_REPLY_TO_BOT_SHORT_QUESTION:
+                # Pergunta curta com reply ao bot = prioridade máxima
+                budget.reply_tokens = min(1500, int(self.total_budget * 0.20))
+                budget.reply_priority_multiplier = 1.5
+                budget.stm_tokens = min(3500, int(self.total_budget * 0.45))
+            elif reply_priority >= PRIORITY_REPLY_TO_BOT:
+                # Reply ao bot
+                budget.reply_tokens = min(1200, int(self.total_budget * 0.15))
+                budget.reply_priority_multiplier = 1.3
+                budget.stm_tokens = min(4000, int(self.total_budget * 0.50))
+            elif reply_priority >= PRIORITY_REPLY:
+                # Reply normal
+                budget.reply_tokens = min(800, int(self.total_budget * 0.10))
+                budget.reply_priority_multiplier = 1.1
+                budget.stm_tokens = min(4500, int(self.total_budget * 0.55))
+        else:
+            # Mensagem normal = STM tem orçamento completo
+            budget.reply_tokens = 0
+            budget.stm_tokens = min(5000, int(self.total_budget * 0.65))
+        
+        # Calcula response reserved
+        budget.response_reserved = (
+            budget.total_budget - 
+            budget.system_tokens - 
+            budget.user_message_tokens - 
+            budget.reply_tokens - 
+            budget.stm_tokens
+        )
+        
+        return budget
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Serializa para dicionário."""
+        return {
+            "total_budget": self.total_budget,
+            "system_tokens": self.system_tokens,
+            "user_message_tokens": self.user_message_tokens,
+            "reply_tokens": self.reply_tokens,
+            "stm_tokens": self.stm_tokens,
+            "response_reserved": self.response_reserved,
+            "reply_priority_multiplier": self.reply_priority_multiplier
+        }
+
+
+# ============================================================
+# CONTEXTO UNIFICADO
+# ============================================================
+
+@dataclass
+class UnifiedMessageContext:
+    """
+    Contexto unificado combinando reply + STM.
+    
+    Philosophy: Reply context (tik) + STM (tok) trabalhando em sintonia.
+    
+    Attributes:
+        - Reply context: Contexto imediato/urgente do reply
+        - STM context: Contexto do fluxo da conversa
+        - Integration: Como os dois são combinados
+    """
+    # Identificação
+    conversation_id: str = ""
+    user_id: str = ""
+    timestamp: float = field(default_factory=time.time)
+    
+    # Reply Context (TIK - urgente/imediato)
+    is_reply: bool = False
+    reply_to_bot: bool = False
+    reply_priority: int = 1  # 1=normal, 2=reply, 3=reply_to_bot, 4=critical
+    quoted_author: str = ""
+    quoted_content: str = ""
+    reply_importancia: float = 1.0
+    
+    # STM Context (TOK - fluxo da conversa)
+    stm_messages: List[MessageWithContext] = field(default_factory=list)
+    stm_summary: Dict[str, Any] = field(default_factory=dict)
+    stm_emotional_trend: str = "neutral"
+    
+    # Long-Term Memory (RAG)
+    long_term_memory: str = ""
+    
+    # Integração
+    sync_mode: str = "tiktok"  # "tiktok" = reply priority + STM flow
+    token_budget: ContextTokenBudget = field(default_factory=ContextTokenBudget)
+    
+    # Mensagem atual
+    current_message: str = ""
+    current_emotion: str = "neutral"
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Serializa para dicionário."""
+        return {
+            "conversation_id": self.conversation_id,
+            "user_id": self.user_id,
+            "timestamp": self.timestamp,
+            "is_reply": self.is_reply,
+            "reply_to_bot": self.reply_to_bot,
+            "reply_priority": self.reply_priority,
+            "quoted_author": self.quoted_author,
+            "quoted_content": self.quoted_content[:500] if self.quoted_content else "",
+            "reply_importancia": self.reply_importancia,
+            "stm_messages_count": len(self.stm_messages),
+            "stm_summary": self.stm_summary,
+            "stm_emotional_trend": self.stm_emotional_trend,
+            "long_term_memory": self.long_term_memory,
+            "sync_mode": self.sync_mode,
+            "token_budget": self.token_budget.to_dict(),
+            "current_message": self.current_message[:100],
+            "current_emotion": self.current_emotion
+        }
+    
+    def build_prompt(self) -> str:
+        """
+        Constrói prompt formatado para o LLM.
+        
+        Returns:
+            String formatada com contexto unificado (reply + STM)
+        """
+        return format_unified_context_for_llm(self, self.token_budget)
+
+
+# ====================================
+# HELPER FUNCTIONS
+# ====================================
+
+def sync_reply_with_stm(
+    reply_context: Dict[str, Any],
+    stm_messages: List[MessageWithContext],
+    max_stm_messages: int = 10
+) -> List[MessageWithContext]:
+    """
+    Sincroniza reply context com mensagens STM.
+    
+    Philosophy: Reply (tik) vem primeiro, STM (tok) vem depois.
+    Ambos são combinados para formar o contexto completo.
+    
+    Args:
+        reply_context: Contexto do reply
+        stm_messages: Mensagens da memória de curto prazo
+        max_stm_messages: Máximo de mensagens STM a incluir
+        
+    Returns:
+        Lista combinada de mensagens para contexto
+    """
+    combined = []
+    
+    # 1. Adiciona reply context como mensagem mais recente (TIK)
+    if reply_context.get('is_reply', False):
+        reply_msg = MessageWithContext(
+            role="user",
+            content=reply_context.get('quoted_content', ''),
+            importancia=reply_context.get('importancia', IMPORTANCIA_NORMAL),
+            emocao=reply_context.get('emocao', 'neutral'),
+            reply_info={
+                'is_reply': True,
+                'reply_to_bot': reply_context.get('reply_to_bot', False),
+                'quoted_text_original': reply_context.get('quoted_content', ''),
+                'priority_level': reply_context.get('priority', 1),
+                'sync_mode': 'tiktok'
+            }
+        )
+        combined.append(reply_msg)
+    
+    # 2. Adiciona mensagens STM (TOK - fluxo da conversa)
+    # Pega últimas N mensagens STM
+    stm_to_add = stm_messages[-max_stm_messages:] if stm_messages else []
+    
+    for msg in stm_to_add:
+        # Se a mensagem STM já é um reply, preserva info
+        if msg.is_reply and not msg.reply_info.get('sync_mode'):
+            msg.reply_info['sync_mode'] = 'stm'
+        combined.append(msg)
+    
+    return combined
+
+
+def format_unified_context_for_llm(
+    unified: UnifiedMessageContext,
+    budget: ContextTokenBudget
+) -> str:
+    """
+    Formata contexto unificado para o prompt do LLM.
+    
+    Philosophy: Reply (tik) primeiro por ser urgente, STM (tok) depois
+    para contexto da conversa.
+    
+    Args:
+        unified: Contexto unificado
+        budget: Orçamento de tokens
+        
+    Returns:
+        String formatada para o prompt
+    """
+    parts = []
+    
+    # ===== 1. REPLY CONTEXT (TIK - URGENTE) =====
+    if unified.is_reply:
+        reply_section = []
+        reply_section.append("=" * 50)
+        reply_section.append("[📎 REPLY CONTEXT - PRIORITÁRIO]")
+        reply_section.append("=" * 50)
+        
+        if unified.reply_to_bot:
+            reply_section.append("⚠️ VOCÊ ESTÁ SENDO DIRETAMENTE RESPONDIDO!")
+        else:
+            reply_section.append(f"Respondendo a: {unified.quoted_author}")
+        
+        # Conteúdo citado
+        if unified.quoted_content:
+            quoted_preview = unified.quoted_content[:budget.reply_tokens // 4]
+            reply_section.append(f"\n<quoted_message>\n{quoted_preview}...\n</quoted_message>")
+        
+        # Prioridade
+        if unified.reply_priority >= PRIORITY_REPLY_TO_BOT_SHORT_QUESTION:
+            reply_section.append("\n💡 PERGUNTA CURTA + REPLY: FOCO NA CITAÇÃO")
+        
+        reply_section.append("\n📌 INSTRUÇÕES DE REPLY:")
+        reply_section.append("- Relacione o input atual ESTRITAMENTE ao <quoted_message>.")
+        reply_section.append("- PRESERVE a sua identidade e humor (seja o Akira, natural e irreverente).")
+        reply_section.append("- Não assuma detalhes inexistentes, use o fluxo (STM) para coerência base.")
+        
+        parts.append("\n".join(reply_section))
+    
+    # ===== RAG CONTEXT (MEMÓRIA DE LONGO PRAZO) =====
+    if unified.long_term_memory:
+        rag_section = []
+        rag_section.append("\n" + "=" * 50)
+        rag_section.append("[📖 MEMÓRIA DE LONGO PRAZO (BANCO DE DADOS)]")
+        rag_section.append("=" * 50)
+        rag_section.append("(Informações previamente aprendidas sobre o usuário)")
+        rag_section.append(unified.long_term_memory)
+        parts.append("\n".join(rag_section))
+
+    # ===== 2. STM CONTEXT (TOK - FLUXO DA CONVERSA) =====
+    if unified.stm_messages:
+        stm_section = []
+        stm_section.append("\n" + "=" * 50)
+        stm_section.append("[🧠 MEMÓRIA DE CURTO PRAZO - FLUXO DA CONVERSA]")
+        stm_section.append("=" * 50)
+        stm_section.append("(conversa recente para contexto)")
+        
+        # emotional trend
+        if unified.stm_emotional_trend != "neutral":
+            stm_section.append(f"\n📊 Tendência emocional: {unified.stm_emotional_trend}")
+        
+        # Formata mensagens STM
+        stm_tokens_used = 0
+        for msg in unified.stm_messages:
+            # Formata role
+            role_icon = "👤" if msg.role == "user" else "🤖"
+            role_label = "USER" if msg.role == "user" else "AKIRA"
+            
+            # Se é reply, marca
+            reply_marker = " [REPLY]" if msg.is_reply else ""
+            
+            # Preview do conteúdo
+            content_preview = msg.content[:100]
+            
+            msg_line = f"{role_icon} [{role_label}]{reply_marker}: {content_preview}..."
+            msg_tokens = estimar_tokens(msg_line)
+            
+            if stm_tokens_used + msg_tokens <= budget.stm_tokens:
+                stm_section.append(msg_line)
+                stm_tokens_used += msg_tokens
+        
+        stm_section.append("\n💡 INTEGRAÇÃO: Use este contexto para manter coerência!")
+        
+        parts.append("\n".join(stm_section))
+    
+    return "\n".join(parts)
+
+
+# ====================================
+# SHORT-TERM MEMORY MANAGER
+# ====================================
+
+class ShortTermMemoryManager:
+    """
+    Gerenciador de instâncias STM por conversa.
+    
+    Philosophy: Cada conversa tem sua própria STM isolada,
+    mas todas compartilham o mesmo manager.
+    """
+    
+    _instance = None
+    _lock = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._lock = __import__('threading').Lock()
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        if self._initialized:
+            return
+        
+        self._instances: Dict[str, ShortTermMemory] = {}
+        self._initialized = True
+        logger.debug("✅ ShortTermMemoryManager inicializado")
+    
+    def get_or_create(
+        self,
+        conversation_id: str,
+        user_id: str = "",
+        max_messages: int = 100
+    ) -> ShortTermMemory:
+        """
+        Obtém ou cria STM para uma conversa.
+        
+        Args:
+            conversation_id: ID único da conversa
+            user_id: ID do usuário
+            max_messages: Máximo de mensagens na STM
+            
+        Returns:
+            Instância de ShortTermMemory
+        """
+        if conversation_id not in self._instances:
+            self._instances[conversation_id] = ShortTermMemory(
+                conversation_id=conversation_id,
+                max_messages=max_messages
+            )
+            logger.debug(f"🧠 STM criada: {conversation_id[:8]}...")
+        
+        return self._instances[conversation_id]
+    
+    def add_message(
+        self,
+        conversation_id: str,
+        role: str,
+        content: str,
+        emocao: str = "neutral",
+        reply_info: Optional[Dict] = None,
+        importancia: float = None
+    ) -> MessageWithContext:
+        """
+        Adiciona mensagem à STM de uma conversa.
+        
+        Args:
+            conversation_id: ID da conversa
+            role: "user" ou "assistant"
+            content: Texto da mensagem
+            emocao: Emoção detectada
+            reply_info: Info de reply (se aplicável)
+            importancia: Importância customizada
+            
+        Returns:
+            MessageWithContext criada
+        """
+        stm = self.get_or_create(conversation_id)
+        
+        # Calcula importância automaticamente se não fornecida
+        if importancia is None:
+            from .short_term_memory import calcular_importancia
+            importancia = calcular_importancia(
+                is_reply=bool(reply_info and reply_info.get("is_reply")),
+                reply_to_bot=bool(reply_info and reply_info.get("reply_to_bot")),
+                mensagem=content,
+                emocao=emocao
+            )
+        
+        return stm.add_message(
+            role=role,
+            content=content,
+            importancia=importancia,
+            emocao=emocao,
+            reply_info=reply_info
+        )
+    
+    def get_context(
+        self,
+        conversation_id: str,
+        include_replies: bool = True,
+        prioritize_replies: bool = True,
+        max_messages: int = 10,
+        max_tokens: int = 4000
+    ) -> List[MessageWithContext]:
+        """
+        Obtém contexto da STM de uma conversa.
+        
+        Args:
+            conversation_id: ID da conversa
+            include_replies: Se inclui replies
+            prioritize_replies: Se prioriza replies
+            max_messages: Máximo de mensagens
+            max_tokens: Máximo de tokens
+            
+        Returns:
+            Lista de mensagens
+        """
+        if conversation_id not in self._instances:
+            return []
+        
+        stm = self._instances[conversation_id]
+        return stm.get_context_window(
+            include_replies=include_replies,
+            prioritize_replies=prioritize_replies,
+            max_messages=max_messages,
+            max_tokens=max_tokens
+        )
+    
+    def get_summary(self, conversation_id: str) -> Dict[str, Any]:
+        """
+        Obtém resumo da STM de uma conversa.
+        
+        Args:
+            conversation_id: ID da conversa
+            
+        Returns:
+            Dicionário com resumo
+        """
+        if conversation_id not in self._instances:
+            return {}
+        
+        stm = self._instances[conversation_id]
+        return stm.get_conversation_summary()
+    
+    def clear(self, conversation_id: str) -> bool:
+        """
+        Limpa STM de uma conversa.
+        
+        Args:
+            conversation_id: ID da conversa
+            
+        Returns:
+            True se limpou
+        """
+        if conversation_id in self._instances:
+            self._instances[conversation_id].clear()
+            return True
+        return False
+
+
+# ====================================
+# UNIFIED CONTEXT BUILDER
+# ====================================
+
+class UnifiedContextBuilder:
+    """
+    Constrói contexto unificado combinando reply + STM.
+    
+    Philosophy: "Reply context e STM devem trabalhar em sintonia como tik e tack"
+    
+    Usage:
+        builder = UnifiedContextBuilder()
+        context = builder.build(
+            conversation_id="...",
+            reply_metadata={...},
+            current_message="..."
+        )
+        prompt_section = builder.format_for_llm(context)
+    """
+    
+    def __init__(self, context_manager=None, stm_manager=None, db_instance=None):
+        self.stm_manager = stm_manager if stm_manager else ShortTermMemoryManager()
+        self.context_manager = context_manager
+        self.db = db_instance
+        self.reply_handler = None
+        self._initialized = False
+    
+    def _ensure_initialized(self):
+        """Garante inicialização do reply handler."""
+        if not self._initialized and UNIFIED_CONTEXT_AVAILABLE:
+            try:
+                self.reply_handler = ReplyContextHandler()
+                self._initialized = True
+            except Exception as e:
+                logger.warning(f"UnifiedContextBuilder: falha ao init reply handler: {e}")
+    
+    def build(
+        self,
+        conversation_id: str,
+        user_id: str = "",
+        reply_metadata: Optional[Dict[str, Any]] = None,
+        current_message: str = "",
+        current_emotion: str = "neutral",
+        stm_messages: Optional[List[MessageWithContext]] = None
+    ) -> UnifiedMessageContext:
+        """
+        Constrói contexto unificado.
+        
+        Args:
+            conversation_id: ID único da conversa
+            user_id: ID do usuário
+            reply_metadata: Metadados do reply
+            current_message: Mensagem atual
+            current_emotion: Emoção atual
+            stm_messages: Mensagens STM (usa manager se None)
+            
+        Returns:
+            UnifiedMessageContext pronto para uso
+        """
+        self._ensure_initialized()
+        
+        # ===== 1. PROCESSA REPLY CONTEXT (TIK) =====
+        is_reply = reply_metadata.get('is_reply', False) if reply_metadata else False
+        
+        reply_context = {
+            'is_reply': is_reply,
+            'reply_to_bot': reply_metadata.get('reply_to_bot', False) if reply_metadata else False,
+            'quoted_author': reply_metadata.get('quoted_author_name', '') if reply_metadata else '',
+            'quoted_content': reply_metadata.get('quoted_text_original', '') or 
+                             reply_metadata.get('mensagem_citada', '') if reply_metadata else '',
+            'importancia': IMPORTANCIA_NORMAL,
+            'emocao': current_emotion,
+            'priority': 1
+        }
+        
+        # Calcula prioridade do reply
+        if is_reply and reply_metadata:
+            reply_context['priority'] = self._calculate_reply_priority(
+                reply_metadata.get('reply_to_bot', False),
+                current_message,
+                reply_metadata.get('quoted_text_original', '')
+            )
+            
+            # Calcula importância baseada em prioridade
+            if reply_context['priority'] >= PRIORITY_REPLY_TO_BOT_SHORT_QUESTION:
+                reply_context['importancia'] = IMPORTANCIA_PERGUNTA_CURTA_REPLY
+            elif reply_context['priority'] >= PRIORITY_REPLY_TO_BOT:
+                reply_context['importancia'] = IMPORTANCIA_REPLY_TO_BOT
+            elif reply_context['priority'] >= PRIORITY_REPLY:
+                reply_context['importancia'] = IMPORTANCIA_REPLY
+        
+        # ===== 2. OBTÉM STM (TOK) =====
+        if stm_messages is None:
+            stm_messages = self.stm_manager.get_context(
+                conversation_id,
+                include_replies=True,
+                prioritize_replies=True,
+                max_messages=10,
+                max_tokens=4000
+            )
+        
+        # ===== 3. CALCULA TOKEN BUDGET =====
+        budget = ContextTokenBudget().calculate(
+            is_reply=is_reply,
+            reply_priority=reply_context['priority']
+        )
+        
+        # ===== 4. FETCH LONG-TERM MEMORY (DB) =====
+        long_term_memory_string = ""
+        if self.db and user_id:
+            try:
+                # Recuperar aprendizados e gírias
+                ltm_facts = self.db.recuperar_aprendizado_detalhado(user_id)
+                ltm_girias = self.db.recuperar_girias_usuario(user_id)
+                ltm_tom = self.db.obter_tom_predominante(user_id)
+                persona_ltm = self.db.recuperar_persona(user_id) if hasattr(self.db, 'recuperar_persona') else None
+
+                ltm_lines = []
+                
+                # --- PERSONA DO USUÁRIO (Rastreador) ---
+                if persona_ltm:
+                    ltm_lines.append("=== PERFIL ANALISADO DO USUÁRIO ===")
+                    if persona_ltm.get('personalidade') and persona_ltm['personalidade'] != "None":
+                        ltm_lines.append(f"• Personalidade: {persona_ltm['personalidade']}")
+                    if persona_ltm.get('gostos') and persona_ltm['gostos'] != "None":
+                        ltm_lines.append(f"• Tópicos de Interesse: {persona_ltm['gostos']}")
+                    if persona_ltm.get('desgostos') and persona_ltm['desgostos'] != "None":
+                        ltm_lines.append(f"• Desgostos/Gatilhos: {persona_ltm['desgostos']}")
+                    if persona_ltm.get('vicios_linguagem') and persona_ltm['vicios_linguagem'] != "None":
+                        ltm_lines.append(f"• Padrões de Linguagem: {persona_ltm['vicios_linguagem']}")
+                    if persona_ltm.get('emocional') and persona_ltm['emocional'] != "None":
+                        ltm_lines.append(f"• Perfil Emocional: {persona_ltm['emocional']}")
+                
+                if ltm_tom:
+                    ltm_lines.append(f"• Seu tom de conversa predominante é: {ltm_tom}")
+                
+                if ltm_facts and isinstance(ltm_facts, dict):
+                    # Ignorar chaves puramente técnicas como 'emocao_atual' ou strings de timestamp longas
+                    fatos_filtrados = {k: v for k, v in ltm_facts.items() if not k.startswith("emocao_")}
+                    if fatos_filtrados:
+                        ltm_lines.append("• Fatos Relevantes Aprendidos:")
+                        for k, v in list(fatos_filtrados.items())[:5]: # limita 5
+                            ltm_lines.append(f"  - {k}: {v}")
+                
+                if ltm_girias:
+                    ltm_lines.append("• Expressões Específicas Recentes:")
+                    for g in ltm_girias[:5]:
+                        ltm_lines.append(f"  - {g['giria']} ({g['significado']})")
+
+                if ltm_lines:
+                    long_term_memory_string = "\n".join(ltm_lines)
+            except Exception as e:
+                logger.warning(f"Erro ao recuperar memória de longo prazo: {e}")
+
+        # ===== 5. CRIA CONTEXTO UNIFICADO =====
+        unified = UnifiedMessageContext(
+            conversation_id=conversation_id,
+            user_id=user_id,
+            timestamp=time.time(),
+            is_reply=is_reply,
+            reply_to_bot=reply_context['reply_to_bot'],
+            reply_priority=reply_context['priority'],
+            quoted_author=reply_context['quoted_author'],
+            quoted_content=reply_context['quoted_content'],
+            reply_importancia=reply_context['importancia'],
+            stm_messages=stm_messages,
+            stm_summary=self.stm_manager.get_summary(conversation_id),
+            stm_emotional_trend=self._get_stm_emotional_trend(stm_messages),
+            long_term_memory=long_term_memory_string,
+            sync_mode="tiktok",
+            token_budget=budget,
+            current_message=current_message,
+            current_emotion=current_emotion
+        )
+        
+        return unified
+    
+    def _calculate_reply_priority(
+        self,
+        reply_to_bot: bool,
+        current_message: str,
+        quoted_content: str
+    ) -> int:
+        """
+        Calcula nível de prioridade do reply.
+        
+        Returns:
+            1=normal, 2=reply, 3=reply_to_bot, 4=critical
+        """
+        if not reply_to_bot:
+            return PRIORITY_REPLY
+        
+        if is_pergunta_curta(current_message):
+            return PRIORITY_REPLY_TO_BOT_SHORT_QUESTION
+        
+        return PRIORITY_REPLY_TO_BOT
+    
+    def _get_stm_emotional_trend(
+        self,
+        stm_messages: List[MessageWithContext]
+    ) -> str:
+        """Obtém tendência emocional da STM."""
+        if not stm_messages:
+            return "neutral"
+        
+        emocoes = {}
+        for msg in stm_messages[-10:]:  # Últimas 10
+            emocao = msg.emocao or "neutral"
+            emocoes[emocao] = emocoes.get(emocao, 0) + 1
+        
+        if not emocoes:
+            return "neutral"
+        
+        return max(emocoes, key=emocoes.get)
+    
+    def format_for_llm(
+        self,
+        unified: UnifiedMessageContext,
+        include_header: bool = True
+    ) -> str:
+        """
+        Formata contexto unificado para o prompt do LLM.
+        
+        Args:
+            unified: Contexto unificado
+            include_header: Se inclui cabeçalho
+            
+        Returns:
+            String formatada para o prompt
+        """
+        return format_unified_context_for_llm(unified, unified.token_budget)
+    
+    def add_to_stm(
+        self,
+        conversation_id: str,
+        role: str,
+        content: str,
+        emocao: str = "neutral",
+        reply_info: Optional[Dict] = None,
+        resposta: str = ""
+    ) -> MessageWithContext:
+        """
+        Adiciona mensagem (user ou bot) à STM.
+        
+        Args:
+            conversation_id: ID da conversa
+            role: "user" ou "assistant"
+            content: Conteúdo da mensagem
+            emocao: Emoção
+            reply_info: Info de reply (se aplicável)
+            resposta: Resposta do bot (se for assistant)
+            
+        Returns:
+            MessageWithContext criada
+        """
+        # Para mensagens do bot, usa a resposta gerada
+        if role == "assistant" and resposta:
+            content = resposta
+        
+        return self.stm_manager.add_message(
+            conversation_id=conversation_id,
+            role=role,
+            content=content,
+            emocao=emocao,
+            reply_info=reply_info
+        )
+    
+    def merge_reply_with_stm(
+        self,
+        reply_context: Dict[str, Any],
+        stm_messages: List[MessageWithContext],
+        max_stm: int = 10
+    ) -> List[MessageWithContext]:
+        """
+        Mescla reply context com STM para contexto do LLM.
+        
+        Args:
+            reply_context: Contexto do reply
+            stm_messages: Mensagens STM
+            max_stm: Máximo de mensagens STM
+            
+        Returns:
+            Lista combinada
+        """
+        return sync_reply_with_stm(reply_context, stm_messages, max_stm)
+
+
+# ====================================
+# FACTORY FUNCTIONS
+# ====================================
+
+_unified_builder: Optional[UnifiedContextBuilder] = None
+
+def get_unified_context_builder() -> UnifiedContextBuilder:
+    """Obtém instância singleton do builder."""
+    global _unified_builder
+    if _unified_builder is None:
+        _unified_builder = UnifiedContextBuilder()
+    return _unified_builder
+
+
+def get_stm_manager() -> ShortTermMemoryManager:
+    """Obtém instância singleton do manager de STM."""
+    return ShortTermMemoryManager()
+
+
+def build_unified_context(
+    conversation_id: str,
+    user_id: str = "",
+    reply_metadata: Optional[Dict[str, Any]] = None,
+    current_message: str = "",
+    current_emotion: str = "neutral"
+) -> UnifiedMessageContext:
+    """
+    Factory function para construir contexto unificado.
+    
+    Usage:
+        context = build_unified_context(
+            conversation_id="pv:2449...",
+            reply_metadata={...},
+            current_message="."
+        )
+    """
+    builder = get_unified_context_builder()
+    return builder.build(
+        conversation_id=conversation_id,
+        user_id=user_id,
+        reply_metadata=reply_metadata,
+        current_message=current_message,
+        current_emotion=current_emotion
+    )
+
+
+# ====================================
+# COMPATIBILITY HELPERS
+# ====================================
+
+def gerar_id_conversao(
+    numero: str,
+    tipo_conversa: str = "pv",
+    grupo_id: Optional[str] = None
+) -> str:
+    """
+    Gera ID de conversa para STM isolada.
+    
+    Args:
+        numero: Número do usuário
+        tipo_conversa: "pv" ou "grupo"
+        grupo_id: ID do grupo (para conversas em grupo)
+        
+    Returns:
+        ID único da conversa
+    """
+    from .context_isolation import generate_context_id
+    return generate_context_id(numero, tipo_conversa, grupo_id)
+
+
+# type: ignore

modules/web_search.py

@@ -1,408 +1,975 @@
-# modules/web_search.py — AKIRA V19 (Dezembro 2025)
-"""
-Módulo de busca na web para APIs sem acesso nativo:
-- Busca notícias de Angola (WebScraping)
-- Busca geral (DuckDuckGo API - gratuita)
-- Pesquisa de clima/tempo
-- Cache de 15 minutos
-"""
-import time
-import re
-import requests
-from typing import List, Dict, Any, Optional
-from loguru import logger
-from bs4 import BeautifulSoup
-
-# === CONFIGURAÇÕES ===
-CACHE_TTL = 900  # 15 minutos
-
-class SimpleCache:
-    """Cache simples em memória com TTL"""
-    def __init__(self, ttl: int = CACHE_TTL):
-        self.ttl = ttl
-        self._data: Dict[str, Any] = {}
-    
-    def get(self, key: str):
-        if key in self._data:
-            value, timestamp = self._data[key]
-            if time.time() - timestamp < self.ttl:
-                return value
-            del self._data[key]
-        return None
-    
-    def set(self, key: str, value: Any):
-        self._data[key] = (value, time.time())
-
-
-class WebSearch:
-    """
-    Gerenciador de buscas na web:
-    - Notícias de Angola (scraping)
-    - Busca geral (DuckDuckGo)
-    - Clima/tempo
-    """
-    
-    def __init__(self):
-        self.cache = SimpleCache(ttl=CACHE_TTL)
-        self.session = requests.Session()
-        self.session.headers.update({
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
-            "Accept-Language": "pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7"
-        })
-        
-        # Fontes de notícias Angola
-        self.fontes_angola = [
-            "https://www.angop.ao/ultimas",
-            "https://www.novojornal.co.ao/",
-            "https://www.jornaldeangola.ao/"
-        ]
-    
-    # ========================================================================
-    # BUSCA GERAL (MULTI-FONTE - GRATUITA E ROBUSTA)
-    # ========================================================================
-
-    def buscar_geral(self, query: str, max_resultados: int = 3) -> str:
-        """
-        Busca geral na web usando múltiplas fontes gratuitas
-
-        Args:
-            query: Termo de busca
-            max_resultados: Número máximo de resultados
-
-        Returns:
-            String formatada com resultados para o prompt da IA
-        """
-        cache_key = f"busca_geral_{query.lower()}"
-        cached = self.cache.get(cache_key)
-        if cached:
-            return cached
-
-        try:
-            # Tentar múltiplas fontes em ordem de prioridade
-            resultados = []
-
-            # 1. DuckDuckGo Instant Answer
-            try:
-                url = "https://api.duckduckgo.com/"
-                params = {
-                    "q": query,
-                    "format": "json",
-                    "no_html": "1",
-                    "skip_disambig": "1"
-                }
-
-                resp = self.session.get(url, params=params, timeout=8)
-                if resp.status_code == 200:
-                    data = resp.json()
-
-                    # Abstract (resumo principal)
-                    if data.get("Abstract"):
-                        resultados.append(f"RESUMO: {data['Abstract'][:300]}")
-
-                    # Related topics
-                    for topic in data.get("RelatedTopics", [])[:max_resultados]:
-                        if isinstance(topic, dict) and "Text" in topic:
-                            resultados.append(f"INFO: {topic['Text'][:200]}")
-                        elif isinstance(topic, str):
-                            resultados.append(f"INFO: {topic[:200]}")
-            except Exception as e:
-                logger.debug(f"DuckDuckGo falhou: {e}")
-
-            # 2. Wikipedia API (se for busca factual)
-            if len(resultados) < max_resultados:
-                try:
-                    wiki_url = "https://en.wikipedia.org/api/rest_v1/page/summary/"
-                    wiki_resp = self.session.get(wiki_url + query.replace(" ", "_"), timeout=5)
-                    if wiki_resp.status_code == 200:
-                        wiki_data = wiki_resp.json()
-                        if wiki_data.get("extract"):
-                            resultados.append(f"Wikipedia: {wiki_data['extract'][:250]}")
-                except Exception as e:
-                    logger.debug(f"Wikipedia falhou: {e}")
-
-            # 3. Fallback com busca simulada baseada em conhecimento geral
-            if not resultados:
-                return self._fallback_busca_geral(query)
-
-            # Formatar para o prompt da IA (não para usuário)
-            resposta = f"INFORMAÇÕES SOBRE '{query.upper()}':\n\n" + "\n\n".join(resultados[:max_resultados])
-            self.cache.set(cache_key, resposta)
-            return resposta
-
-        except Exception as e:
-            logger.warning(f"Busca geral falhou: {e}")
-            return self._fallback_busca_geral(query)
-
-    def _fallback_busca_geral(self, query: str) -> str:
-        """Fallback quando todas as fontes falham"""
-        return f"INFORMAÇÕES GERAIS SOBRE '{query}': Não foi possível obter dados específicos da web no momento. Use conhecimento geral para responder."
-    
-    # ========================================================================
-    # NOTÍCIAS DE ANGOLA (WEB SCRAPING)
-    # ========================================================================
-    
-    def pesquisar_noticias_angola(self, limite: int = 5) -> str:
-        """
-        Busca notícias mais recentes de Angola via scraping
-        
-        Returns:
-            String formatada com notícias
-        """
-        cache_key = "noticias_angola"
-        cached = self.cache.get(cache_key)
-        if cached:
-            return cached
-        
-        todas_noticias = []
-        
-        try:
-            # Tenta cada fonte
-            todas_noticias.extend(self._buscar_angop())
-            todas_noticias.extend(self._buscar_novojornal())
-            todas_noticias.extend(self._buscar_jornaldeangola())
-            
-        except Exception as e:
-            logger.error(f"Erro no scraping de notícias: {e}")
-        
-        # Remove duplicatas e limita
-        vistos = set()
-        unicas = []
-        for n in todas_noticias:
-            titulo_lower = n["titulo"].lower()
-            if titulo_lower not in vistos and len(titulo_lower) > 20:
-                vistos.add(titulo_lower)
-                unicas.append(n)
-                if len(unicas) >= limite:
-                    break
-        
-        if not unicas:
-            fallback = "Sem notícias recentes de Angola disponíveis no momento."
-            self.cache.set(cache_key, fallback)
-            return fallback
-        
-        # Formata resposta
-        texto = "📰 NOTÍCIAS RECENTES DE ANGOLA:\n\n"
-        for i, n in enumerate(unicas, 1):
-            texto += f"[{i}] {n['titulo']}\n"
-            if n.get('link'):
-                texto += f"    🔗 {n['link']}\n"
-            texto += "\n"
-        
-        self.cache.set(cache_key, texto.strip())
-        return texto.strip()
-    
-    def _buscar_angop(self) -> List[Dict]:
-        """Scraping da Angop"""
-        try:
-            r = self.session.get(self.fontes_angola[0], timeout=8)
-            if r.status_code != 200:
-                return []
-            
-            soup = BeautifulSoup(r.text, 'html.parser')
-            itens = soup.select('.ultimas-noticias .item')[:3]
-            noticias = []
-            
-            for item in itens:
-                titulo = item.select_one('h3 a')
-                link = item.select_one('a')
-                if titulo and link:
-                    href = link.get('href', '')
-                    if isinstance(href, str):
-                        full_link = "https://www.angop.ao" + href if href.startswith('/') else href
-                    else:
-                        full_link = "https://www.angop.ao" + str(href) if str(href).startswith('/') else str(href)
-                    noticias.append({
-                        "titulo": self._limpar_texto(titulo.get_text()),
-                        "link": full_link,
-                        "fonte": "Angop"
-                    })
-            
-            return noticias
-            
-        except Exception as e:
-            logger.warning(f"Angop scraping falhou: {e}")
-            return []
-    
-    def _buscar_novojornal(self) -> List[Dict]:
-        """Scraping do Novo Jornal"""
-        try:
-            r = self.session.get(self.fontes_angola[1], timeout=8)
-            if r.status_code != 200:
-                return []
-            
-            soup = BeautifulSoup(r.text, 'html.parser')
-            itens = soup.select('.noticia-lista .titulo a')[:3]
-            noticias = []
-            
-            for a in itens:
-                noticias.append({
-                    "titulo": self._limpar_texto(a.get_text()),
-                    "link": a.get('href', ''),
-                    "fonte": "Novo Jornal"
-                })
-            
-            return noticias
-            
-        except Exception as e:
-            logger.warning(f"Novo Jornal scraping falhou: {e}")
-            return []
-    
-    def _buscar_jornaldeangola(self) -> List[Dict]:
-        """Scraping do Jornal de Angola"""
-        try:
-            r = self.session.get(self.fontes_angola[2], timeout=8)
-            if r.status_code != 200:
-                return []
-            
-            soup = BeautifulSoup(r.text, 'html.parser')
-            itens = soup.select('.ultimas .titulo a')[:3]
-            noticias = []
-            
-            for a in itens:
-                noticias.append({
-                    "titulo": self._limpar_texto(a.get_text()),
-                    "link": a.get('href', ''),
-                    "fonte": "Jornal de Angola"
-                })
-            
-            return noticias
-            
-        except Exception as e:
-            logger.warning(f"Jornal de Angola scraping falhou: {e}")
-            return []
-    
-    # ========================================================================
-    # CLIMA/TEMPO
-    # ========================================================================
-    
-    def buscar_clima(self, cidade: str = "Luanda") -> str:
-        """
-        Busca informações de clima usando wttr.in (gratuito)
-        
-        Args:
-            cidade: Nome da cidade (padrão: Luanda)
-        
-        Returns:
-            String com informações do clima
-        """
-        cache_key = f"clima_{cidade.lower()}"
-        cached = self.cache.get(cache_key)
-        if cached:
-            return cached
-        
-        try:
-            # wttr.in - serviço gratuito de clima
-            url = f"https://wttr.in/{cidade}?format=j1"
-            resp = self.session.get(url, timeout=8)
-            
-            if resp.status_code != 200:
-                return f"Não consegui obter informações do clima em {cidade}."
-            
-            data = resp.json()
-            
-            # Extrai dados
-            current = data['current_condition'][0]
-            temp = current['temp_C']
-            desc = current['lang_pt'][0]['value'] if 'lang_pt' in current else current['weatherDesc'][0]['value']
-            humidity = current['humidity']
-            
-            resposta = f"🌤️ CLIMA EM {cidade.upper()}:\n\n"
-            resposta += f"Temperatura: {temp}°C\n"
-            resposta += f"Condição: {desc}\n"
-            resposta += f"Umidade: {humidity}%"
-            
-            self.cache.set(cache_key, resposta)
-            return resposta
-            
-        except Exception as e:
-            logger.warning(f"Busca de clima falhou: {e}")
-            return f"Não consegui obter informações do clima em {cidade} no momento."
-    
-    # ========================================================================
-    # UTILIDADES
-    # ========================================================================
-    
-    def _limpar_texto(self, texto: str) -> str:
-        """Limpa e formata texto"""
-        if not texto:
-            return ""
-        texto = re.sub(r'[\s\n\t]+', ' ', texto)
-        return texto.strip()[:200]
-    
-    # ========================================================================
-    # DETECÇÃO DE INTENÇÃO DE BUSCA
-    # ========================================================================
-    
-    @staticmethod
-    def detectar_intencao_busca(mensagem: str) -> Optional[str]:
-        """
-        Detecta se mensagem requer busca na web - MELHORADO
-
-        Returns:
-            "noticias" | "clima" | "busca_geral" | None
-        """
-        msg_lower = mensagem.lower()
-
-        # PALAVRAS-CHAVE DE BUSCA DIRETAS (PRIORIDADE ALTA)
-        palavras_busca_diretas = [
-            "busca", "pesquisa", "pesquisar", "procurar", "procura",
-            "web", "internet", "google", "wikipedia", "site",
-            "informações", "dados", "saber", "conhecer", "descobrir",
-            "encontrar", "localizar", "achar"
-        ]
-
-        # Verificar se contém palavras de busca diretas
-        for palavra in palavras_busca_diretas:
-            if palavra in msg_lower:
-                # Se for sobre clima, priorizar clima
-                if any(k in msg_lower for k in ["clima", "tempo", "temperatura", "chuva", "sol"]):
-                    return "clima"
-                # Se for sobre notícias, priorizar notícias
-                elif any(k in msg_lower for k in ["notícias", "noticias", "novidades", "aconteceu", "news"]):
-                    if "angola" in msg_lower or "angolano" in msg_lower:
-                        return "noticias"
-                    else:
-                        return "busca_geral"
-                else:
-                    return "busca_geral"
-
-        # Notícias (específicas de Angola)
-        if any(k in msg_lower for k in ["notícias", "noticias", "novidades", "aconteceu", "news"]):
-            if "angola" in msg_lower or "angolano" in msg_lower or "angola" in msg_lower:
-                return "noticias"
-
-        # Clima
-        if any(k in msg_lower for k in ["clima", "tempo", "temperatura", "chuva", "sol"]):
-            return "clima"
-
-        # Busca geral (perguntas sobre fatos/eventos)
-        palavras_chave_busca = [
-            "quem é", "o que é", "onde fica", "quando foi", "como funciona",
-            "definição", "significa", "história", "explicação", "significado",
-            "qual é", "quais são", "quanto é", "quantos são"
-        ]
-
-        if any(k in msg_lower for k in palavras_chave_busca):
-            return "busca_geral"
-
-        # Perguntas com "?" também podem ativar busca (mais seletivo)
-        if "?" in mensagem:
-            palavras = mensagem.split()
-            if len(palavras) > 2:  # Pelo menos 3 palavras para considerar busca
-                # Verificar se é uma pergunta factual
-                indicadores_pergunta = ["quem", "o que", "onde", "quando", "como", "por que", "qual", "quanto", "porquê", "porque"]
-                if any(indicador in msg_lower for indicador in indicadores_pergunta):
-                    return "busca_geral"
-
-        return None
-
-
-# === INSTÂNCIA GLOBAL (SINGLETON) ===
-_web_search_instance = None
-
-def get_web_search() -> WebSearch:
-    """Retorna instância singleton do WebSearch"""
-    global _web_search_instance
-    if _web_search_instance is None:
-        _web_search_instance = WebSearch()
-    return _web_search_instance
+# type: ignore
+"""
+modules/web_search.py
+================================================================================
+WEB SEARCH MÓDULO - BUSCA AUTÔNOMA COMPLETA E PROFISSIONAL
+================================================================================
+Versão 3.0 - Motor de busca autônomo e inteligente
+
+Features:
+  - DuckDuckGo via biblioteca `ddgs` (production-ready, sem scraping frágil)
+  - Busca de Texto, Notícias, Imagens e Vídeos (multi-tipo)
+  - Wikipedia via API oficial (conteúdo completo)
+  - Clima via OpenWeatherMap API (com fallback para wttr.in)
+  - Pesquisa Autônoma: AI decide QUANDO e O QUE buscar sem comando explícito
+  - Raspagem profunda de página web com extração de conteúdo limpo
+  - Cache TTL inteligente por tipo de busca
+  - Rate limiting respeitoso e rotação de User-Agent
+  - Integração direta com banco de dados (salva pesquisas para RAG)
+
+Uso:
+  ws = WebSearch(db=db_instance)
+  resultado = ws.pesquisar("capital de angola")
+  conteudo  = ws.buscar_conteudo_completo("presidente João Lourenço")
+  deve_ir   = ws.deve_buscar_na_web("quem ganhou a copa ontem?")
+
+================================================================================
+"""
+
+import os
+import re
+
+import random
+import time
+import hashlib
+import sqlite3
+import json
+from dataclasses import dataclass
+from typing import Dict, Any, List, Optional, Tuple, Union
+from datetime import datetime
+from loguru import logger
+
+try:
+    from .config import DB_PATH
+except (ImportError, ValueError):
+    try:
+        from modules.config import DB_PATH
+    except ImportError:
+        DB_PATH = "akira.db"
+
+# ============================================================
+# Imports opcionais com fallbacks
+# ============================================================
+
+try:
+    from ddgs import DDGS  # type: ignore
+    DDGS_AVAILABLE = True
+except ImportError:
+    try:
+        from duckduckgo_search import DDGS  # type: ignore  # nome antigo
+        DDGS_AVAILABLE = True
+    except ImportError:
+        DDGS_AVAILABLE = False
+        DDGS = None  # type: ignore
+
+try:
+    import requests  # type: ignore
+    REQUESTS_AVAILABLE = True
+except ImportError:
+    REQUESTS_AVAILABLE = False
+    requests = None  # type: ignore
+
+try:
+    from bs4 import BeautifulSoup  # type: ignore
+    BS4_AVAILABLE = True
+except ImportError:
+    BS4_AVAILABLE = False
+    BeautifulSoup = None  # type: ignore
+
+try:
+    from loguru import logger # type: ignore
+except ImportError:
+    class _DummyLogger:
+        def info(self, *a, **k): pass
+        def success(self, *a, **k): pass
+        def warning(self, *a, **k): pass
+        def error(self, *a, **k): pass
+        def debug(self, *a, **k): pass
+    logger = _DummyLogger() # type: ignore
+
+try:
+    from cachetools import TTLCache  # type: ignore
+    _CacheOK = True
+except ImportError:
+    _CacheOK = False
+    class TTLCache(dict):  # type: ignore
+        def __init__(self, maxsize=100, ttl=900, **kwargs):
+            super().__init__(**kwargs)
+            self.maxsize = maxsize
+            self.ttl = ttl
+            self._ts: Dict[str, float] = {}
+
+        def __setitem__(self, key, value):
+            super().__setitem__(key, value)
+            self._ts[key] = time.time()
+            if len(self) > self.maxsize:
+                oldest = min(self._ts, key=lambda k: self._ts[k])
+                self.pop(oldest, None)
+                self._ts.pop(oldest, None)
+
+        def get(self, key, default=None):
+            if key in self._ts and time.time() - self._ts[key] > self.ttl:
+                self.pop(key, None)
+                self._ts.pop(key, None)
+                return default
+            return super().get(key, default)
+
+# ============================================================
+# CONFIGURAÇÕES GLOBAIS
+# ============================================================
+
+REQUEST_TIMEOUT = 12
+
+# Cache com diferentes TTLs por tipo (segundos)
+_CACHE_GERAL   = TTLCache(maxsize=60,  ttl=900)    # 15 min
+_CACHE_NOTICIAS= TTLCache(maxsize=30,  ttl=300)    # 5 min (notícias mudam rápido)
+_CACHE_WIKI    = TTLCache(maxsize=50,  ttl=3600)   # 1h (Wikipedia é estável)
+_CACHE_CLIMA   = TTLCache(maxsize=20,  ttl=600)    # 10 min
+
+USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+]
+
+OPENWEATHER_KEY = os.getenv("OPENWEATHER_API_KEY", "")
+
+# Palavras-gatilho para busca autônoma (contexto NLP)
+_TRIGGERS_BUSCA = [
+    # Comandos explícitos
+    "pesquisa", "busca na web", "buscar na internet", "pesquise",
+    "me busca", "google", "procura",
+    # Eventos atuais
+    "o que está acontecendo", "últimas notícias", "notícias de hoje",
+    "o que aconteceu", "aconteceu", "novidades",
+    # Perguntas factuais específicas
+    "quem é o presidente", "qual é a população", "quantos habitantes",
+    "qual a capital", "onde fica", "quando foi fundado",
+    # Sports/resultados
+    "placar", "resultado do jogo", "ganhou a copa", "eliminado",
+    # Temporal
+    "ontem", "esta semana", "esse mês", "ano passado", "2025", "2026",
+    # Pessoas
+    "morreu", "foi preso", "foi assassinado", "renunciou", "eleito",
+    # Tempo/clima
+    "vai chover", "temperatura em", "clima em", "previsão do tempo",
+]
+
+_PERGUNTAS_FATOS = [
+    "?", "quem", "qual", "quando", "onde", "quanto", "quantos",
+    "por que", "como é", "o que é", "me conta", "explica",
+]
+
+
+# ============================================================
+# CLASSE PRINCIPAL
+# ============================================================
+@dataclass
+class WebSearchConfig:
+    db_path: str = DB_PATH
+
+class WebSearch:
+    """
+    Motor de busca autônoma profissional para AKIRA.
+
+    Prioridade de backends:
+    1. DDGS (duckduckgo-search) - principal, sem API key
+    2. Wikipedia API - para perguntas conceituais
+    3. OpenWeatherMap - para clima
+    4. Scraping direto via BeautifulSoup - fallback
+    """
+
+    def __init__(self, db=None):
+        """
+        Args:
+            db: Instância do Database para persistência das buscas (opcional)
+        """
+        self.db = db
+        self._session = None
+        self._setup_session()
+
+        if DDGS_AVAILABLE:
+            logger.success("🔍 WebSearch: DDGS (DuckDuckGo) disponível e ativo")
+        else:
+            logger.warning("⚠️ WebSearch: ddgs não instalado – fallback via scraping")
+
+    def _setup_session(self):
+        """Configura sessão HTTP com headers realistas."""
+        if not REQUESTS_AVAILABLE:
+            return
+        self._session = requests.Session()
+        self._session.headers.update({
+            "User-Agent": random.choice(USER_AGENTS),
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            "Accept-Language": "pt-BR,pt;q=0.9,en-US;q=0.8",
+            "Accept-Encoding": "gzip, deflate",
+            "Connection": "keep-alive",
+        })
+
+    def _rotate_ua(self):
+        """Rotaciona User-Agent para evitar bloqueio."""
+        if self._session:
+            self._session.headers["User-Agent"] = random.choice(USER_AGENTS)
+
+    # ==================================================================
+    # 🌐 INTERFACE PRINCIPAL
+    # ==================================================================
+
+    def pesquisar(
+        self,
+        query: str,
+        num_results: int = 5,
+        tipo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Pesquisa completa com detecção automática de tipo.
+
+        Args:
+            query: Termo de pesquisa
+            num_results: Número de resultados (max 10)
+            tipo: Forçar tipo: 'geral'|'noticias'|'wikipedia'|'clima'|'imagens'
+
+        Returns:
+            Dict com 'conteudo_bruto', 'resumo', 'tipo', 'resultados'
+        """
+        if not query or not query.strip():
+            return self._erro("Query vazia")
+
+        query = query.strip()
+        cache_key = hashlib.md5(f"{query}:{num_results}:{tipo}".encode()).hexdigest()[:16]
+
+        # Detecta tipo se não especificado
+        tipo_detectado = tipo or self.detectar_tipo_pesquisa(query)
+
+        # Verifica cache específico por tipo
+        cache = self._get_cache(tipo_detectado)
+        cached = cache.get(cache_key)
+        if cached:
+            logger.debug(f"📦 Cache hit [{tipo_detectado}]: {query[:40]}")
+            return cached
+
+        # Rotaciona UA
+        self._rotate_ua()
+
+        # Executa busca pelo tipo
+        resultado: Dict[str, Any]
+        if tipo_detectado == "wikipedia":
+            resultado = self._buscar_wikipedia(query)
+        elif tipo_detectado == "noticias":
+            resultado = self._buscar_noticias(query, num_results)
+        elif tipo_detectado == "clima":
+            resultado = self._buscar_clima(query)
+        elif tipo_detectado == "imagens":
+            resultado = self._buscar_imagens(query, num_results)
+        else:
+            resultado = self._buscar_texto_ddgs(query, num_results)
+
+        # Salva no cache
+        cache[cache_key] = resultado
+
+        # Persiste no banco de dados para RAG futuro
+        self._persistir_busca(query, tipo_detectado, resultado)
+
+        return resultado
+
+    def buscar_conteudo_completo(self, query: str) -> str:
+        """Retorna string bruta pronta para inserir no prompt."""
+        r = self.pesquisar(query)
+        return r.get("conteudo_bruto", "Sem resultados disponíveis.")
+
+    def buscar_resumido(self, query: str) -> str:
+        r = self.pesquisar(query, num_results=3)
+        return r.get("resumo", "Sem resumo disponível.")
+
+    # ==================================================================
+    # 🤖 PESQUISA AUTÔNOMA – a IA decide sozinha se deve buscar
+    # ==================================================================
+
+    def deve_buscar_na_web(self, mensagem: str, historico: Optional[List[str]] = None) -> bool:
+        """
+        Decisão autônoma: a AKIRA deve buscar na web por conta própria?
+
+        Lógica em camadas:
+        1. Gatilhos explícitos (o usuário pediu)
+        2. Perguntas factuais com marcadores temporais
+        3. Tópicos que o modelo definitivamente não sabe (eventos pós-treino)
+        4. Palavras de eventos conhecidos recentes
+
+        Args:
+            mensagem: Última mensagem do usuário
+            historico: Últimas mensagens do histórico (contexto adicional)
+
+        Returns:
+            True se deve pesquisar na web
+        """
+        msg = mensagem.lower().strip()
+
+        # 1. Gatilhos explícitos
+        if any(t in msg for t in _TRIGGERS_BUSCA):
+            logger.info(f"🔍 Pesquisa autônoma ativada [gatilho explícito]: {msg[:60]}")
+            return True
+
+        # 2. Pergunta + indicador temporal/factual
+        is_pergunta = (
+            "?" in msg or
+            any(msg.startswith(p) for p in _PERGUNTAS_FATOS)
+        )
+        indicadores_atuais = [
+            "atual", "recente", "novo", "último", "agora",
+            "hoje", "ontem", "semana", "mês", "2024", "2025", "2026",
+            "presidente", "governo", "eleição", "guerra", "acordo",
+            "crise", "epidemia", "terremoto", "furacão"
+        ]
+        if is_pergunta and any(p in msg for p in indicadores_atuais):
+            logger.info(f"🔍 Pesquisa autônoma ativada [pergunta+temporal]: {msg[:60]}")
+            return True
+
+        # 3. Pessoa pede para contar/explicar com contexto que muda
+        frases_dinamicas = [
+            "me conta sobre", "o que você sabe sobre", "quem é",
+            "o que é", "me fala sobre", "sabes de", "sabe de"
+        ]
+        if any(f in msg for f in frases_dinamicas):
+            # Verifica se é sobre algo que pode ser evento recente
+            entidades_suspeitas = msg.split()
+            # Heurística: mais de 1 palavra após a frase → provavelmente nome próprio
+            for frase in frases_dinamicas:
+                if frase in msg:
+                    pos = msg.find(frase) + len(frase)
+                    resto = msg[pos:].strip()
+                    if len(resto.split()) >= 1:
+                        logger.info(f"🔍 Pesquisa autônoma ativada [entidade]: {resto[:60]}")
+                        return True
+
+        # 4. Contexto do histórico (se usuário estava pedindo info antes)
+        if historico:
+            ultima_5 = " ".join(historico[-5:]).lower()
+            if any(t in ultima_5 for t in ["pesquisa", "busca", "notícia", "aconteceu"]):
+                return True
+
+        return False
+
+    def extrair_assunto_busca(self, mensagem: str) -> str:
+        """
+        Extrai o assunto principal da mensagem para usar como query.
+        Mais inteligente que a versão antiga – usa múltiplas heurísticas.
+        """
+        msg = mensagem.strip()
+        msg_lower = msg.lower()
+
+        # Padrões de extração em ordem de prioridade
+        padroes = [
+            r"(?:pesquisa|busca|pesquise|procura|me busca|me fala)\s+(?:sobre|de|a respeito de)?\s*(.+)",
+            r"(?:quem é|o que é|o que são|onde fica|qual é|quando foi|como é)\s+(.+)",
+            r"(?:me conta|me fala|explica|me explica)\s+(?:sobre|de)?\s*(.+)",
+            r"(?:notícia|noticia|novidade)\s+(?:sobre|de)\s*(.+)",
+        ]
+
+        for pat in padroes:
+            m = re.search(pat, msg_lower)
+            if m:
+                resultado = m.group(1).strip().rstrip(".,!?")
+                if len(resultado) > 2:
+                    return resultado
+
+        # Se é uma pergunta direta, use a mensagem inteira mas limpa
+        stopwords = ["pesquisa", "busca", "buscar", "procura", "me", "por favor", "pf", "pfv"]
+        tokens = msg_lower.split()
+        tokens_limpos = [t for t in tokens if t not in stopwords]
+
+        return " ".join(tokens_limpos) if tokens_limpos else msg
+
+    # ==================================================================
+    # 🎯 DETECÇÃO DE TIPO
+    # ==================================================================
+
+    def detectar_tipo_pesquisa(self, query: str) -> str:
+        """
+        Detecta automaticamente o melhor tipo de busca para a query.
+
+        Returns:
+            'wikipedia' | 'noticias' | 'clima' | 'imagens' | 'geral'
+        """
+        q = query.lower()
+
+        # Clima
+        clima_kws = ["clima", "tempo", "temperatura", "vai chover", "previsão", "chuva", "sol", "humidade"]
+        if any(k in q for k in clima_kws):
+            return "clima"
+
+        # Wikipedia – perguntas conceituais/definitórias
+        wiki_kws = [
+            "o que é", "quem é", "onde fica", "como funciona", "história de",
+            "wikipédia", "wikipedia", "biografi", "definição de",
+            "quando foi criado", "quando nasceu", "quando morreu", "inventor"
+        ]
+        if any(k in q for k in wiki_kws):
+            return "wikipedia"
+
+        # Notícias – eventos atuais
+        news_kws = [
+            "notícia", "noticia", "última hora", "breaking", "aconteceu",
+            "hoje", "eleição", "guerra", "crise", "julgamento",
+            "preso", "morreu", "assassinado", "renunciou", "ganhou"
+        ]
+        if any(k in q for k in news_kws):
+            return "noticias"
+
+        # Imagens
+        img_kws = ["foto de", "imagem de", "fotos de", "imagens de", "como é", "me mostra"]
+        if any(k in q for k in img_kws):
+            return "imagens"
+
+        return "geral"
+
+    # ==================================================================
+    # 📰 BUSCA DE TEXTO VIA DDGS (principal)
+    # ==================================================================
+
+    def _buscar_texto_ddgs(self, query: str, num: int = 5) -> Dict[str, Any]:
+        """Busca geral usando a biblioteca DDGS (DuckDuckGo Search)."""
+        if not DDGS_AVAILABLE:
+            return self._buscar_texto_fallback(query, num)
+
+        try:
+            resultados = []
+            with DDGS() as ddgs:
+                for r in ddgs.text(
+                    query,
+                    region="wt-wt",
+                    safesearch="off",
+                    timelimit=None,
+                    max_results=num,
+                ):
+                    resultados.append({
+                        "titulo": r.get("title", ""),
+                        "url": r.get("href", ""),
+                        "snippet": r.get("body", ""),
+                    })
+
+            if not resultados:
+                return self._erro("DDGS: nenhum resultado")
+
+            # Tenta enriquecer com conteúdo das páginas
+            for res in resultados[:2]:  # Só as 2 primeiras para não overload
+                conteudo = self._raspar_pagina(res["url"])
+                if conteudo:
+                    res["conteudo_pagina"] = conteudo[:2000]
+
+            bruto = self._montar_bruto_geral(query, resultados)
+            return {
+                "tipo": "geral",
+                "query": query,
+                "resumo": f"Web Search: '{query}' – {len(resultados)} resultados",
+                "conteudo_bruto": bruto,
+                "resultados": resultados,
+                "timestamp": datetime.now().isoformat(),
+                "fonte": "ddgs",
+            }
+
+        except Exception as e:
+            logger.warning(f"DDGS texto error: {e}")
+            return self._buscar_texto_fallback(query, num)
+
+    # ==================================================================
+    # 📰 BUSCA DE NOTÍCIAS VIA DDGS
+    # ==================================================================
+
+    def _buscar_noticias(self, query: str, num: int = 5) -> Dict[str, Any]:
+        """Busca notícias usando DDGS News backend."""
+        if not DDGS_AVAILABLE:
+            return self._buscar_texto_ddgs(query, num)  # fallback para geral
+
+        try:
+            noticias = []
+            with DDGS() as ddgs:
+                for r in ddgs.news(
+                    query,
+                    region="wt-wt",
+                    safesearch="off",
+                    timelimit="w",  # última semana
+                    max_results=num,
+                ):
+                    noticias.append({
+                        "titulo": r.get("title", ""),
+                        "url": r.get("url", ""),
+                        "snippet": r.get("body", ""),
+                        "fonte": r.get("source", ""),
+                        "data": r.get("date", ""),
+                    })
+
+            if not noticias:
+                # Tenta sem filtro de tempo
+                with DDGS() as ddgs:
+                    for r in ddgs.news(query, max_results=num):
+                        noticias.append({
+                            "titulo": r.get("title", ""),
+                            "url": r.get("url", ""),
+                            "snippet": r.get("body", ""),
+                            "fonte": r.get("source", ""),
+                            "data": r.get("date", ""),
+                        })
+
+            if not noticias:
+                return self._erro("Noticias: sem resultados")
+
+            bruto = f"=== 📰 NOTÍCIAS: {query.upper()} ===\n"
+            bruto += f"DATA DA BUSCA: {datetime.now().strftime('%d/%m/%Y %H:%M')}\n\n"
+            for i, n in enumerate(noticias, 1):
+                bruto += f"[{i}] {n['titulo']}\n"
+                if n.get("fonte"):
+                    bruto += f"    Fonte: {n['fonte']}"
+                if n.get("data"):
+                    bruto += f" | Data: {n['data']}"
+                bruto += "\n"
+                if n.get("snippet"):
+                    bruto += f"    {n['snippet'][:300]}\n"
+                if n.get("url"):
+                    bruto += f"    🔗 {n['url']}\n"
+                bruto += "\n"
+            bruto += "--- FIM DAS NOTÍCIAS ---\n"
+
+            return {
+                "tipo": "noticias",
+                "query": query,
+                "resumo": f"Notícias sobre '{query}': {len(noticias)} encontradas",
+                "conteudo_bruto": bruto,
+                "resultados": noticias,
+                "timestamp": datetime.now().isoformat(),
+                "fonte": "ddgs_news",
+            }
+
+        except Exception as e:
+            logger.warning(f"DDGS noticias error: {e}")
+            return self._buscar_texto_ddgs(query, num)
+
+    # ==================================================================
+    # 📚 WIKIPEDIA
+    # ==================================================================
+
+    def _buscar_wikipedia(self, query: str) -> Dict[str, Any]:
+        """Busca na Wikipedia PT via API oficial com extração completa."""
+        if not REQUESTS_AVAILABLE:
+            return self._erro("Wikipedia: requests não disponível")
+
+        try:
+            # 1. Pesquisa para encontrar o artigo correto
+            search_url = "https://pt.wikipedia.org/w/api.php"
+            r = self._session.get(search_url, params={
+                "action": "query",
+                "format": "json",
+                "list": "search",
+                "srsearch": query,
+                "srlimit": 3,
+            }, timeout=REQUEST_TIMEOUT)
+
+            if r.status_code != 200:
+                return self._erro(f"Wikipedia HTTP {r.status_code}")
+
+            data = r.json()
+            resultados = data.get("query", {}).get("search", [])
+            if not resultados:
+                return self._erro("Wikipedia: nenhuma página encontrada")
+
+            # Pega o mais relevante
+            page_title = resultados[0]["title"]
+
+            # 2. Busca conteúdo completo da página
+            r2 = self._session.get(search_url, params={
+                "action": "query",
+                "format": "json",
+                "prop": "extracts|info",
+                "exintro": False,
+                "explaintext": True,
+                "titles": page_title,
+                "inprop": "url",
+            }, timeout=REQUEST_TIMEOUT)
+
+            data2 = r2.json()
+            pages = data2.get("query", {}).get("pages", {})
+            page = next(iter(pages.values()), {})
+
+            extract = page.get("extract", "")
+            fullurl = page.get("fullurl", f"https://pt.wikipedia.org/wiki/{page_title.replace(' ', '_')}")
+
+            # Limpa e formata
+            extract = re.sub(r'\[\d+\]', '', extract)
+            extract = re.sub(r'\s+', ' ', extract).strip()
+
+            bruto = f"=== 📚 WIKIPEDIA: {page_title} ===\n"
+            bruto += f"Fonte: {fullurl}\n"
+            bruto += f"Data da consulta: {datetime.now().strftime('%d/%m/%Y %H:%M')}\n\n"
+            bruto += "CONTEÚDO:\n"
+            bruto += extract[:6000]
+            bruto += "\n\n--- FIM WIKIPEDIA ---\n"
+
+            return {
+                "tipo": "wikipedia",
+                "titulo": page_title,
+                "url": fullurl,
+                "resumo": f"Wikipedia: {page_title}",
+                "conteudo_bruto": bruto,
+                "timestamp": datetime.now().isoformat(),
+                "fonte": "wikipedia_api",
+            }
+
+        except Exception as e:
+            logger.warning(f"Wikipedia error: {e}")
+            return self._erro(f"Wikipedia: {e}")
+
+    # ==================================================================
+    # 🌤️ CLIMA
+    # ==================================================================
+
+    def _buscar_clima(self, query: str) -> Dict[str, Any]:
+        """
+        Busca clima via OpenWeatherMap (se API key disponível)
+        ou via wttr.in (sempre disponível, sem key).
+        """
+        # Extrai cidade da query
+        cidade = self._extrair_cidade(query)
+
+        # Tenta wttr.in (sempre gratuito)
+        try:
+            if self._session:
+                url = f"https://wttr.in/{cidade}?format=j1&lang=pt"
+                r = self._session.get(url, timeout=REQUEST_TIMEOUT)
+                if r.status_code == 200:
+                    data = r.json()
+                    cc = data.get("current_condition", [{}])[0]
+                    area = data.get("nearest_area", [{}])[0]
+                    nome_area = area.get("areaName", [{}])[0].get("value", cidade)
+                    pais = area.get("country", [{}])[0].get("value", "")
+
+                    temp_c = cc.get("temp_C", "?")
+                    sensacao = cc.get("FeelsLikeC", "?")
+                    humidade = cc.get("humidity", "?")
+                    vento_kmh = cc.get("windspeedKmph", "?")
+                    descricao = cc.get("weatherDesc", [{}])[0].get("value", "")
+
+                    bruto = f"=== 🌤️ CLIMA: {nome_area}, {pais} ===\n"
+                    bruto += f"Data: {datetime.now().strftime('%d/%m/%Y %H:%M')}\n\n"
+                    bruto += f"🌡️  Temperatura atual: {temp_c}°C (sensação: {sensacao}°C)\n"
+                    bruto += f"💧 Humidade: {humidade}%\n"
+                    bruto += f"💨 Vento: {vento_kmh} km/h\n"
+                    bruto += f"☁️  Condição: {descricao}\n"
+                    bruto += "\n--- FIM CLIMA ---\n"
+
+                    return {
+                        "tipo": "clima",
+                        "cidade": nome_area,
+                        "resumo": f"Clima em {nome_area}: {temp_c}°C, {descricao}",
+                        "conteudo_bruto": bruto,
+                        "temperatura": temp_c,
+                        "timestamp": datetime.now().isoformat(),
+                        "fonte": "wttr.in",
+                    }
+        except Exception as e:
+            logger.warning(f"wttr.in error: {e}")
+
+        # Fallback: OpenWeatherMap se key disponível
+        if OPENWEATHER_KEY:
+            return self._clima_openweather(cidade)
+
+        return self._erro(f"Clima: não foi possível obter dados para '{cidade}'")
+
+    def _clima_openweather(self, cidade: str) -> Dict[str, Any]:
+        """Fallback via OpenWeatherMap API."""
+        try:
+            url = "https://api.openweathermap.org/data/2.5/weather"
+            r = self._session.get(url, params={
+                "q": cidade,
+                "appid": OPENWEATHER_KEY,
+                "units": "metric",
+                "lang": "pt",
+            }, timeout=REQUEST_TIMEOUT)
+
+            if r.status_code != 200:
+                return self._erro(f"OpenWeather HTTP {r.status_code}")
+
+            data = r.json()
+            temp = data["main"]["temp"]
+            sensacao = data["main"]["feels_like"]
+            humidade = data["main"]["humidity"]
+            vento = data["wind"]["speed"] * 3.6  # m/s → km/h
+            desc = data["weather"][0]["description"]
+            nome = data.get("name", cidade)
+
+            bruto = f"=== 🌤️ CLIMA: {nome} ===\n"
+            bruto += f"Temperatura: {temp:.1f}°C (sensação: {sensacao:.1f}°C)\n"
+            bruto += f"Humidade: {humidade}%\n"
+            bruto += f"Vento: {vento:.1f} km/h\n"
+            bruto += f"Condição: {desc.capitalize()}\n"
+            bruto += "--- FIM CLIMA ---\n"
+
+            return {
+                "tipo": "clima", "cidade": nome,
+                "resumo": f"Clima em {nome}: {temp}°C, {desc}",
+                "conteudo_bruto": bruto,
+                "timestamp": datetime.now().isoformat(),
+                "fonte": "openweathermap",
+            }
+        except Exception as e:
+            return self._erro(f"OpenWeather: {e}")
+
+    # ==================================================================
+    # 🖼️ IMAGENS VIA DDGS
+    # ==================================================================
+
+    def _buscar_imagens(self, query: str, num: int = 5) -> Dict[str, Any]:
+        """Busca URLs de imagens via DDGS."""
+        if not DDGS_AVAILABLE:
+            return self._erro("DDGS não disponível para imagens")
+
+        try:
+            imagens = []
+            with DDGS() as ddgs:
+                for r in ddgs.images(
+                    query,
+                    region="wt-wt",
+                    safesearch="off",
+                    size=None,
+                    max_results=num,
+                ):
+                    imagens.append({
+                        "titulo": r.get("title", ""),
+                        "url_imagem": r.get("image", ""),
+                        "url_pagina": r.get("url", ""),
+                        "thumbnail": r.get("thumbnail", ""),
+                        "fonte": r.get("source", ""),
+                    })
+
+            if not imagens:
+                return self._erro("Imagens: sem resultados")
+
+            bruto = f"=== 🖼️ IMAGENS: {query} ===\n"
+            bruto += f"Data: {datetime.now().strftime('%d/%m/%Y')}\n\n"
+            for i, img in enumerate(imagens, 1):
+                bruto += f"[{i}] {img['titulo']}\n"
+                bruto += f"    URL: {img['url_imagem']}\n"
+                if img.get("fonte"):
+                    bruto += f"    Fonte: {img['fonte']}\n"
+                bruto += "\n"
+            bruto += "--- FIM IMAGENS ---\n"
+
+            return {
+                "tipo": "imagens",
+                "query": query,
+                "resumo": f"Imagens de '{query}': {len(imagens)} encontradas",
+                "conteudo_bruto": bruto,
+                "resultados": imagens,
+                "timestamp": datetime.now().isoformat(),
+                "fonte": "ddgs_images",
+            }
+
+        except Exception as e:
+            logger.warning(f"DDGS imagens error: {e}")
+            return self._erro(f"Imagens: {e}")
+
+    # ==================================================================
+    # 🔄 FALLBACK – Scraping manual via BeautifulSoup
+    # ==================================================================
+
+    def _buscar_texto_fallback(self, query: str, num: int = 5) -> Dict[str, Any]:
+        """Fallback: scraping HTML do DuckDuckGo se DDGS não estiver instalado."""
+        if not REQUESTS_AVAILABLE or not BS4_AVAILABLE:
+            return self._erro("Dependências insuficientes para busca fallback")
+
+        try:
+            from urllib.parse import urlencode
+            url = f"https://html.duckduckgo.com/html/?{urlencode({'q': query, 'kl': 'pt-pt'})}"
+            r = self._session.get(url, timeout=REQUEST_TIMEOUT)
+
+            if r.status_code != 200:
+                return self._erro(f"DuckDuckGo HTML: HTTP {r.status_code}")
+
+            soup = BeautifulSoup(r.text, "html.parser")
+            resultados = []
+            for res in soup.find_all("div", class_="result")[:num]:
+                a = res.find("a", class_="result__a")
+                snip = res.find("a", class_="result__snippet")
+                if a:
+                    resultados.append({
+                        "titulo": a.get_text(strip=True),
+                        "url": a.get("href", ""),
+                        "snippet": snip.get_text(strip=True) if snip else "",
+                    })
+
+            if not resultados:
+                return self._erro("Fallback: sem resultados")
+
+            bruto = self._montar_bruto_geral(query, resultados)
+            return {
+                "tipo": "geral",
+                "query": query,
+                "resumo": f"Web: '{query}' – {len(resultados)} resultados",
+                "conteudo_bruto": bruto,
+                "resultados": resultados,
+                "timestamp": datetime.now().isoformat(),
+                "fonte": "scraping_fallback",
+            }
+
+        except Exception as e:
+            return self._erro(f"Fallback: {e}")
+
+    # ==================================================================
+    # 🌐 RASPAGEM DE CONTEÚDO DE PÁGINA
+    # ==================================================================
+
+    def _raspar_pagina(self, url: str) -> str:
+        """
+        Extrai conteúdo relevante de uma URL.
+        Retorna texto limpo ou string vazia se falhar.
+        """
+        if not REQUESTS_AVAILABLE or not BS4_AVAILABLE or not url:
+            return ""
+
+        # Evita PDFs, binários, etc.
+        ignorar = [".pdf", ".doc", ".xls", ".zip", ".exe", "javascript:", "mailto:"]
+        if any(url.lower().endswith(ext) or ext in url.lower() for ext in ignorar):
+            return ""
+
+        try:
+            r = self._session.get(url, timeout=8)
+            if r.status_code != 200:
+                return ""
+
+            soup = BeautifulSoup(r.text, "html.parser")
+
+            # Remove scripts, style, nav, footer
+            for tag in soup.find_all(["script", "style", "nav", "footer", "header", "aside"]):
+                tag.decompose()
+
+            # Tenta encontrar conteúdo principal
+            main_content = (
+                soup.find("article") or
+                soup.find("main") or
+                soup.find("div", {"id": re.compile(r"content|main|article", re.I)}) or
+                soup.find("div", {"class": re.compile(r"content|main|article|post", re.I)})
+            )
+
+            if main_content:
+                texto = main_content.get_text(separator=" ", strip=True)
+            else:
+                texto = soup.get_text(separator=" ", strip=True)
+
+            # Limpa espaços excessivos
+            texto = re.sub(r"\s+", " ", texto).strip()
+            return texto[:3000]
+
+        except Exception:
+            return ""
+
+    # ==================================================================
+    # 🛠️ UTILITÁRIOS
+    # ==================================================================
+
+    def _montar_bruto_geral(self, query: str, resultados: List[Dict]) -> str:
+        bruto = f"=== 🔎 PESQUISA WEB: {query.upper()} ===\n"
+        bruto += f"Data: {datetime.now().strftime('%d/%m/%Y %H:%M')}\n"
+        bruto += f"Total de resultados: {len(resultados)}\n\n"
+        for i, r in enumerate(resultados, 1):
+            bruto += f"[{i}] {r.get('titulo', 'Sem título')}\n"
+            bruto += f"    🔗 {r.get('url', '')}\n"
+            if r.get("snippet"):
+                bruto += f"    {r['snippet'][:400]}\n"
+            if r.get("conteudo_pagina"):
+                bruto += f"    [CONTEÚDO] {r['conteudo_pagina'][:800]}\n"
+            bruto += "\n"
+        bruto += "--- FIM DOS RESULTADOS ---\n"
+        return bruto
+
+    def _extrair_cidade(self, query: str) -> str:
+        """Extrai nome de cidade de uma query sobre clima."""
+        q = query.lower()
+        prefixos = ["clima em", "tempo em", "temperatura em", "previsão em", "vai chover em", "como está o tempo em"]
+        for p in prefixos:
+            if p in q:
+                return q.split(p)[-1].strip().split()[0].capitalize()
+        # Heurística: última palavra relevante
+        tokens = [t for t in query.split() if t.lower() not in
+                  ["clima", "tempo", "temperatura", "previsão", "hoje", "amanhã", "de", "em", "o", "a"]]
+        return tokens[-1].capitalize() if tokens else "Luanda"
+
+    def _get_cache(self, tipo: str) -> TTLCache:
+        if tipo == "noticias":
+            return _CACHE_NOTICIAS
+        if tipo == "wikipedia":
+            return _CACHE_WIKI
+        if tipo == "clima":
+            return _CACHE_CLIMA
+        return _CACHE_GERAL
+
+    def _persistir_busca(self, query: str, tipo: str, resultado: Dict):
+        """Salva a busca no banco para uso como contexto RAG futuro."""
+        if not self.db:
+            return
+        try:
+            resumo = resultado.get("resumo", "")
+            self.db.salvar_aprendizado_detalhado(
+                usuario="sistema",
+                chave=f"web_search_{tipo}_{hashlib.md5(query.encode()).hexdigest()[:8]}",
+                valor=json.dumps({
+                    "query": query,
+                    "tipo": tipo,
+                    "resumo": resumo,
+                    "timestamp": datetime.now().isoformat(),
+                }, ensure_ascii=False)
+            )
+        except Exception as e:
+            logger.debug(f"Persistência de busca ignorada: {e}")
+
+    def _erro(self, mensagem: str) -> Dict[str, Any]:
+        return {
+            "tipo": "erro",
+            "resumo": mensagem,
+            "conteudo_bruto": f"=== ⚠️ ERRO NA PESQUISA ===\n{mensagem}\n---",
+            "timestamp": datetime.now().isoformat(),
+            "erro": True,
+        }
+
+    def limpar_cache(self):
+        _CACHE_GERAL.clear()
+        _CACHE_NOTICIAS.clear()
+        _CACHE_WIKI.clear()
+        _CACHE_CLIMA.clear()
+        logger.info("🧹 Todos os caches de WebSearch limpos")
+
+
+# ============================================================
+# SINGLETON & HELPERS PÚBLICOS
+# ============================================================
+
+_instance: Optional[WebSearch] = None
+
+
+def get_web_search(db=None) -> WebSearch:
+    """Retorna instância singleton do WebSearch."""
+    global _instance
+    if _instance is None:
+        _instance = WebSearch(db=db)
+    return _instance
+
+
+def buscar_na_web(query: str, db=None) -> str:
+    """Helper rápido: busca e retorna conteúdo bruto."""
+    return get_web_search(db=db).buscar_conteudo_completo(query)
+
+
+def deve_pesquisar(mensagem: str, historico: Optional[List[str]] = None) -> bool:
+    """Helper: decide se deve pesquisar na web."""
+    return get_web_search().deve_buscar_na_web(mensagem, historico)
+
+
+def extrair_pesquisa(mensagem: str) -> str:
+    """Helper: extrai assunto de busca da mensagem."""
+    return get_web_search().extrair_assunto_busca(mensagem)
+
+
+__all__ = [
+    "WebSearch",
+    "get_web_search",
+    "buscar_na_web",
+    "deve_pesquisar",
+    "extrair_pesquisa",
+]