Update modules/database.py

modules/database.py

@@ -1,15 +1,18 @@
-# modules/database.py — AKIRA V19 FINAL (Dezembro 2025)
+# modules/database.py — AKIRA V20 FINAL (Dezembro 2025)
 """
 Banco de dados SQLite para Akira IA.
-✅ ERRO DE DIRETÓRIO CORRIGIDO
-✅ Isolamento PV/Grupo
-✅ Todas as tabelas e métodos
+✅ ISOLAMENTO TOTAL PV/GRUPO (criptográfico)
+✅ Controle de humor multinível
+✅ Sistema de transição de humor
+✅ Reply context tracking
+✅ Training dataset integration
 """
 import sqlite3
 import time
 import os
 import json
 import pickle
+import hashlib
 from typing import Optional, List, Dict, Any, Tuple
 from loguru import logger
 
@@ -20,17 +23,44 @@ class Database:
         self.max_retries = 5
         self.retry_delay = 0.1
         
-        # === CORRIGIDO: Verifica se há diretório antes de criar ===
+        # Cria diretório se necessário
         db_dir = os.path.dirname(db_path)
-        if db_dir:  # Apenas cria se houver diretório no caminho
+        if db_dir:
             os.makedirs(db_dir, exist_ok=True)
         
         self._init_db()
         self._ensure_all_columns_and_indexes()
 
+    # ================================================================
+    # ISOLAMENTO CRIPTOGRÁFICO (NOVO)
+    # ================================================================
+    
+    def _gerar_contexto_id(self, numero: str, tipo: str) -> str:
+        """
+        Gera ID único e isolado para contexto.
+        
+        Args:
+            numero: Número do usuário/grupo
+            tipo: 'pv' ou 'grupo'
+        
+        Returns:
+            Hash único isolando completamente PV de Grupo
+        """
+        # Detecta automaticamente se é grupo
+        if "@g.us" in numero or "120363" in numero:
+            tipo = "grupo"
+        else:
+            tipo = "pv"
+        
+        # Hash único: SHA256(numero + tipo + salt)
+        salt = "AKIRA_CONTEXT_ISOLATION_V20"
+        raw = f"{numero}|{tipo}|{salt}"
+        return hashlib.sha256(raw.encode()).hexdigest()
+
     # ================================================================
     # CONEXÃO COM RETRY + WAL
     # ================================================================
+    
     def _get_connection(self) -> sqlite3.Connection:
         for attempt in range(self.max_retries):
             try:
@@ -67,12 +97,13 @@ class Database:
                 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 (tentativa {attempt+1}): {e}") 
+                logger.error(f"Erro SQL (tentativa {attempt+1}): {e}")
                 raise
 
     # ================================================================
     # INICIALIZAÇÃO + TABELAS
     # ================================================================
+    
     def _init_db(self):
         try:
             with self._get_connection() as conn:
@@ -85,44 +116,87 @@ class Database:
                         dado TEXT,
                         valor TEXT
                     );
-                    CREATE TABLE IF NOT EXISTS exemplos (
+                    
+                    CREATE TABLE IF NOT EXISTS mensagens (
                         id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        tipo TEXT NOT NULL,
-                        entrada TEXT NOT NULL,
-                        resposta TEXT NOT NULL
+                        usuario TEXT NOT NULL,
+                        mensagem TEXT NOT NULL,
+                        resposta TEXT NOT NULL,
+                        numero TEXT,
+                        contexto_id TEXT NOT NULL,
+                        tipo_contexto TEXT DEFAULT 'pv',
+                        is_reply BOOLEAN DEFAULT 0,
+                        mensagem_original TEXT,
+                        reply_to_bot BOOLEAN DEFAULT 0,
+                        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
                     );
-                    CREATE TABLE IF NOT EXISTS info_geral (
-                        chave TEXT PRIMARY KEY,
-                        valor TEXT NOT NULL
+                    
+                    CREATE TABLE IF NOT EXISTS humor_historico (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        contexto_id TEXT NOT NULL,
+                        humor_anterior TEXT,
+                        humor_novo TEXT NOT NULL,
+                        razao_mudanca TEXT,
+                        intensidade REAL DEFAULT 1.0,
+                        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
                     );
-                    CREATE TABLE IF NOT EXISTS estilos (
-                        numero_usuario TEXT PRIMARY KEY,
-                        estilo TEXT NOT NULL
+                    
+                    CREATE TABLE IF NOT EXISTS modo_resposta_historico (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        contexto_id TEXT NOT NULL,
+                        modo_usado TEXT NOT NULL,
+                        tom_usuario TEXT,
+                        contexto_mensagem TEXT,
+                        sucesso BOOLEAN DEFAULT 1,
+                        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
                     );
-                    CREATE TABLE IF NOT EXISTS preferencias_tom (
-                        numero_usuario TEXT PRIMARY KEY,
-                        tom TEXT NOT NULL
+                    
+                    CREATE TABLE IF NOT EXISTS reply_context (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        contexto_id TEXT NOT NULL,
+                        mensagem_id TEXT NOT NULL,
+                        autor_original TEXT NOT NULL,
+                        conteudo_original TEXT NOT NULL,
+                        eh_resposta_a_bot BOOLEAN DEFAULT 0,
+                        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
                     );
-                    CREATE TABLE IF NOT EXISTS afinidades (
-                        numero_usuario TEXT PRIMARY KEY,
-                        afinidade REAL NOT NULL
+                    
+                    CREATE TABLE IF NOT EXISTS contexto (
+                        contexto_id TEXT PRIMARY KEY,
+                        numero TEXT NOT NULL,
+                        tipo_contexto TEXT NOT NULL,
+                        historico TEXT,
+                        humor_atual TEXT DEFAULT 'normal',
+                        modo_resposta_atual TEXT DEFAULT 'casual_amigavel',
+                        termos TEXT,
+                        girias TEXT,
+                        tom TEXT DEFAULT 'normal',
+                        ultima_atualizacao DATETIME DEFAULT CURRENT_TIMESTAMP
                     );
-                    CREATE TABLE IF NOT EXISTS termos (
+                    
+                    CREATE TABLE IF NOT EXISTS girias_aprendidas (
                         id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero_usuario TEXT NOT NULL,
-                        termo TEXT NOT NULL,
-                        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                        contexto_id TEXT NOT NULL,
+                        giria TEXT NOT NULL,
+                        significado TEXT NOT NULL,
+                        contexto TEXT,
+                        frequencia INTEGER DEFAULT 1,
+                        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
                     );
-                    CREATE TABLE IF NOT EXISTS aprendizados (
+                    
+                    CREATE TABLE IF NOT EXISTS tom_usuario (
                         id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero_usuario TEXT NOT NULL,
-                        chave TEXT NOT NULL,
-                        valor TEXT NOT NULL,
+                        contexto_id TEXT NOT NULL,
+                        tom_detectado TEXT NOT NULL,
+                        intensidade REAL DEFAULT 0.5,
+                        contexto TEXT,
                         created_at DATETIME DEFAULT CURRENT_TIMESTAMP
                     );
+                    
                     CREATE TABLE IF NOT EXISTS aprendizado_detalhado (
                         id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero_usuario TEXT NOT NULL,
+                        contexto_id TEXT NOT NULL,
                         tipo TEXT NOT NULL,
                         chave TEXT NOT NULL,
                         valor TEXT NOT NULL,
@@ -132,190 +206,395 @@ class Database:
                         criado_em DATETIME DEFAULT CURRENT_TIMESTAMP,
                         atualizado_em DATETIME DEFAULT CURRENT_TIMESTAMP
                     );
-                    CREATE TABLE IF NOT EXISTS vocabulario_patenteado (
-                        termo TEXT PRIMARY KEY,
-                        definicao TEXT NOT NULL,
-                        uso TEXT NOT NULL,
-                        exemplo TEXT NOT NULL
-                    );
-                    CREATE TABLE IF NOT EXISTS usuarios_privilegiados (
-                        numero_usuario TEXT PRIMARY KEY,
-                        nome TEXT NOT NULL
-                    );
-                    CREATE TABLE IF NOT EXISTS whatsapp_ids (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        whatsapp_id TEXT NOT NULL,
-                        sender_number TEXT NOT NULL,
-                        UNIQUE (whatsapp_id, sender_number)
-                    );
+                    
                     CREATE TABLE IF NOT EXISTS embeddings (
                         id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero_usuario TEXT,
+                        contexto_id TEXT NOT NULL,
                         source_type TEXT,
                         texto TEXT,
-                        embedding BLOB NOT NULL
-                    );
-                    CREATE TABLE IF NOT EXISTS mensagens (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        usuario TEXT NOT NULL,
-                        mensagem TEXT NOT NULL,
-                        resposta TEXT NOT NULL,
-                        numero TEXT,
-                        is_reply BOOLEAN DEFAULT 0,
-                        mensagem_original TEXT,
+                        embedding BLOB NOT NULL,
                         created_at DATETIME DEFAULT CURRENT_TIMESTAMP
                     );
-                    CREATE TABLE IF NOT EXISTS emocao_exemplos (
+                    
+                    CREATE TABLE IF NOT EXISTS training_examples (
                         id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        emocao TEXT NOT NULL,
-                        entrada TEXT NOT NULL,
-                        resposta TEXT NOT NULL,
-                        tom TEXT NOT NULL,
+                        input_text TEXT NOT NULL,
+                        output_text TEXT NOT NULL,
+                        humor TEXT NOT NULL,
+                        modo_resposta TEXT NOT NULL,
+                        qualidade_score REAL DEFAULT 1.0,
+                        usado_treino BOOLEAN DEFAULT 0,
                         created_at DATETIME DEFAULT CURRENT_TIMESTAMP
                     );
-                    CREATE TABLE IF NOT EXISTS girias_aprendidas (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero_usuario TEXT NOT NULL,
-                        giria TEXT NOT NULL,
-                        significado TEXT NOT NULL,
-                        contexto TEXT,
-                        frequencia INTEGER DEFAULT 1,
-                        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-                    );
-                    CREATE TABLE IF NOT EXISTS tom_usuario (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero_usuario TEXT NOT NULL,
-                        tom_detectado TEXT NOT NULL,
-                        intensidade REAL DEFAULT 0.5,
-                        contexto TEXT,
-                        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                    
+                    CREATE TABLE IF NOT EXISTS usuarios_privilegiados (
+                        numero_usuario TEXT PRIMARY KEY,
+                        nome TEXT NOT NULL,
+                        tom_inicial TEXT DEFAULT 'formal'
                     );
-                    CREATE TABLE IF NOT EXISTS adaptacao_dinamica (
+                    
+                    -- Tabelas legadas (mantidas para compatibilidade)
+                    CREATE TABLE IF NOT EXISTS aprendizados (
                         id INTEGER PRIMARY KEY AUTOINCREMENT,
                         numero_usuario TEXT NOT NULL,
-                        tipo_adaptacao TEXT NOT NULL,
-                        valor_anterior TEXT,
-                        valor_novo TEXT,
-                        razao TEXT,
+                        chave TEXT NOT NULL,
+                        valor TEXT NOT NULL,
                         created_at DATETIME DEFAULT CURRENT_TIMESTAMP
                     );
-                    CREATE TABLE IF NOT EXISTS pronomes_por_tom (
-                        tom TEXT PRIMARY KEY,
-                        pronomes TEXT NOT NULL
-                    );
-                    CREATE TABLE IF NOT EXISTS contexto (
-                        user_key TEXT PRIMARY KEY,
-                        historico TEXT,
-                        emocao_atual TEXT,
-                        termos TEXT,
-                        girias TEXT,
-                        tom TEXT
-                    );
-                ''')
-                c.executescript('''
-                    INSERT OR IGNORE INTO pronomes_por_tom (tom, pronomes) VALUES
-                    ('formal', 'Sr., ilustre, boss, maior, homem'),
-                    ('rude', 'parvo, estúpido, burro, analfabeto, desperdício de esperma'),
-                    ('casual', 'mano, puto, cota, mwangolé, kota'),
-                    ('neutro', 'amigo, parceiro, camarada');
                 ''')
+                
                 conn.commit()
-            logger.info(f"Banco inicializado: {self.db_path}")
+            logger.info(f"✅ Banco inicializado: {self.db_path}")
         except Exception as e:
-            logger.error(f"Erro ao criar tabelas: {e}")
+            logger.error(f"❌ Erro ao criar tabelas: {e}")
             raise
 
     # ================================================================
-    # MIGRAÇÃO AUTOMÁTICA — GARANTE COLUNAS
+    # MIGRAÇÃO AUTOMÁTICA
     # ================================================================
+    
     def _ensure_all_columns_and_indexes(self):
         try:
             with self._get_connection() as conn:
                 c = conn.cursor()
 
-                c.execute("PRAGMA table_info(embeddings)")
+                # Verifica colunas de mensagens
+                c.execute("PRAGMA table_info(mensagens)")
                 cols = {row[1] for row in c.fetchall()}
                 
-                # Migração 1: Adicionar numero_usuario
-                if 'numero_usuario' not in cols:
-                    c.execute("ALTER TABLE embeddings ADD COLUMN numero_usuario TEXT")
-                    logger.info("Coluna 'numero_usuario' adicionada em 'embeddings'")
-
-                # Migração 2: Adicionar source_type
-                if 'source_type' not in cols:
-                    c.execute("ALTER TABLE embeddings ADD COLUMN source_type TEXT DEFAULT 'conversa'")
-                    logger.info("Coluna 'source_type' adicionada em 'embeddings'")
+                if 'contexto_id' not in cols:
+                    c.execute("ALTER TABLE mensagens ADD COLUMN contexto_id TEXT DEFAULT ''")
+                    logger.info("✅ Coluna 'contexto_id' adicionada em 'mensagens'")
+                
+                if 'tipo_contexto' not in cols:
+                    c.execute("ALTER TABLE mensagens ADD COLUMN tipo_contexto TEXT DEFAULT 'pv'")
+                    logger.info("✅ Coluna 'tipo_contexto' adicionada")
+                
+                if 'reply_to_bot' not in cols:
+                    c.execute("ALTER TABLE mensagens ADD COLUMN reply_to_bot BOOLEAN DEFAULT 0")
+                    logger.info("✅ Coluna 'reply_to_bot' adicionada")
 
-                # Migração 3: Adicionar texto
-                if 'texto' not in cols:
-                    c.execute("ALTER TABLE embeddings ADD COLUMN texto TEXT DEFAULT ''")
-                    logger.info("Coluna 'texto' adicionada em 'embeddings'")
+                # Migra dados antigos para usar contexto_id
+                c.execute("""
+                    UPDATE mensagens 
+                    SET contexto_id = numero || '_pv'
+                    WHERE contexto_id = '' OR contexto_id IS NULL
+                """)
 
-                # Índices
+                # Índices otimizados
                 c.executescript('''
-                    CREATE INDEX IF NOT EXISTS idx_mensagens_numero ON mensagens(numero);
-                    CREATE INDEX IF NOT EXISTS idx_girias_usuario ON girias_aprendidas(numero_usuario);
-                    CREATE INDEX IF NOT EXISTS idx_aprendizados_usuario ON aprendizados(numero_usuario);
-                    CREATE INDEX IF NOT EXISTS idx_aprendizado_detalhado_usuario ON aprendizado_detalhado(numero_usuario);
+                    CREATE INDEX IF NOT EXISTS idx_mensagens_contexto ON mensagens(contexto_id);
+                    CREATE INDEX IF NOT EXISTS idx_contexto_id ON contexto(contexto_id);
+                    CREATE INDEX IF NOT EXISTS idx_humor_contexto ON humor_historico(contexto_id);
+                    CREATE INDEX IF NOT EXISTS idx_girias_contexto ON girias_aprendidas(contexto_id);
+                    CREATE INDEX IF NOT EXISTS idx_tom_contexto ON tom_usuario(contexto_id);
+                    CREATE INDEX IF NOT EXISTS idx_reply_contexto ON reply_context(contexto_id);
+                    CREATE INDEX IF NOT EXISTS idx_training_quality ON training_examples(qualidade_score DESC);
                 ''')
+                
                 conn.commit()
+                logger.info("✅ Migração de colunas/índices concluída")
+                
         except Exception as e:
-            logger.error(f"Erro na migração: {e}")
+            logger.error(f"❌ Erro na migração: {e}")
 
     # ================================================================
-    # MÉTODOS DE RECUPERAÇÃO (COM ISOLAMENTO PV/GRUPO)
+    # MÉTODOS DE RECUPERAÇÃO (COM ISOLAMENTO ABSOLUTO)
     # ================================================================
     
-    def recuperar_mensagens(self, usuario: str, limite: int = 5) -> List[Tuple]:
+    def recuperar_mensagens(self, numero: str, limite: int = 10) -> List[Tuple]:
         """
-        Recupera mensagens COM ISOLAMENTO:
-        - Grupos: apenas mensagens deste grupo
-        - PV: apenas mensagens privadas (exclui grupos)
+        Recupera mensagens COM ISOLAMENTO TOTAL.
+        Usa contexto_id para garantir que PV nunca vaza para grupo.
         """
-        is_grupo = usuario.endswith("@g.us") or "120363" in usuario
-        
-        if is_grupo:
-            # Grupos: busca apenas mensagens DESTE grupo específico
-            query = """
-                SELECT mensagem, resposta 
-                FROM mensagens 
-                WHERE numero=? 
-                ORDER BY id DESC 
-                LIMIT ?
-            """
-            return self._execute_with_retry(query, (usuario, limite)) or []
-        else:
-            # PV: busca apenas mensagens privadas (exclui grupos)
-            query = """
-                SELECT mensagem, resposta 
-                FROM mensagens 
-                WHERE (usuario=? OR numero=?) 
-                AND numero NOT LIKE '%@g.us%'
-                AND numero NOT LIKE '%120363%'
-                ORDER BY id DESC 
-                LIMIT ?
-            """
-            return self._execute_with_retry(query, (usuario, usuario, limite)) or []
-
-    def recuperar_girias_usuario(self, numero_usuario: str) -> List[Dict[str, Any]]:
-        rows = self._execute_with_retry(
-            "SELECT giria, significado, contexto, frequencia FROM girias_aprendidas WHERE numero_usuario=?",
-            (numero_usuario,)
-        ) or []
-        return [{'giria': r[0], 'significado': r[1], 'contexto': r[2], 'frequencia': r[3]} for r in rows]
+        contexto_id = self._gerar_contexto_id(numero, 'auto')
+        
+        query = """
+            SELECT mensagem, resposta, is_reply, mensagem_original, reply_to_bot
+            FROM mensagens 
+            WHERE contexto_id = ?
+            ORDER BY id DESC 
+            LIMIT ?
+        """
+        
+        results = self._execute_with_retry(query, (contexto_id, limite))
+        return results if results else []
+    
+    def recuperar_humor_atual(self, numero: str) -> str:
+        """Recupera humor atual do contexto isolado"""
+        contexto_id = self._gerar_contexto_id(numero, 'auto')
+        
+        query = "SELECT humor_atual FROM contexto WHERE contexto_id = ?"
+        result = self._execute_with_retry(query, (contexto_id,))
+        
+        if result and result[0][0]:
+            return result[0][0]
+        
+        return "normal"
+    
+    def recuperar_historico_humor(self, numero: str, limite: int = 5) -> List[Dict]:
+        """Recupera histórico de transições de humor"""
+        contexto_id = self._gerar_contexto_id(numero, 'auto')
+        
+        query = """
+            SELECT humor_anterior, humor_novo, razao_mudanca, intensidade, created_at
+            FROM humor_historico
+            WHERE contexto_id = ?
+            ORDER BY id DESC
+            LIMIT ?
+        """
+        
+        results = self._execute_with_retry(query, (contexto_id, limite))
+        
+        if not results:
+            return []
+        
+        return [
+            {
+                "anterior": r[0],
+                "novo": r[1],
+                "razao": r[2],
+                "intensidade": r[3],
+                "timestamp": r[4]
+            }
+            for r in results
+        ]
+    
+    def recuperar_modo_resposta(self, numero: str) -> str:
+        """Recupera modo de resposta atual"""
+        contexto_id = self._gerar_contexto_id(numero, 'auto')
+        
+        query = "SELECT modo_resposta_atual FROM contexto WHERE contexto_id = ?"
+        result = self._execute_with_retry(query, (contexto_id,))
+        
+        if result and result[0][0]:
+            return result[0][0]
+        
+        return "casual_amigavel"
 
-    def recuperar_aprendizado_detalhado(self, numero_usuario: str) -> Dict[str, str]:
+    def recuperar_girias_usuario(self, numero: str) -> List[Dict[str, Any]]:
+        """Recupera gírias aprendidas (isolado por contexto)"""
+        contexto_id = self._gerar_contexto_id(numero, 'auto')
+        
         rows = self._execute_with_retry(
-            "SELECT chave, valor FROM aprendizados WHERE numero_usuario=?",
-            (numero_usuario,)
+            """SELECT giria, significado, contexto, frequencia 
+               FROM girias_aprendidas 
+               WHERE contexto_id = ?
+               ORDER BY frequencia DESC
+               LIMIT 20""",
+            (contexto_id,)
         ) or []
-        return {r[0]: r[1] for r in rows}
+        
+        return [
+            {
+                'giria': r[0],
+                'significado': r[1],
+                'contexto': r[2],
+                'frequencia': r[3]
+            }
+            for r in rows
+        ]
 
     # ================================================================
-    # MÉTODOS DE SALVAMENTO
+    # MÉTODOS DE SALVAMENTO (COM ISOLAMENTO)
     # ================================================================
     
+    def salvar_mensagem(
+        self,
+        usuario: str,
+        mensagem: str,
+        resposta: str,
+        numero: str = None,
+        is_reply: bool = False,
+        mensagem_original: str = None,
+        reply_to_bot: bool = False
+    ):
+        """Salva mensagem com contexto isolado"""
+        numero_final = numero or usuario
+        contexto_id = self._gerar_contexto_id(numero_final, 'auto')
+        
+        # Detecta tipo
+        tipo_contexto = "grupo" if ("@g.us" in numero_final or "120363" in numero_final) else "pv"
+        
+        query = """
+            INSERT INTO mensagens 
+            (usuario, mensagem, resposta, numero, contexto_id, tipo_contexto, is_reply, mensagem_original, reply_to_bot)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """
+        
+        self._execute_with_retry(
+            query,
+            (usuario, mensagem, resposta, numero_final, contexto_id, tipo_contexto, 
+             int(is_reply), mensagem_original, int(reply_to_bot)),
+            commit=True
+        )
+        
+        logger.debug(f"✅ Mensagem salva: contexto_id={contexto_id[:8]}..., tipo={tipo_contexto}")
+    
+    def salvar_transicao_humor(
+        self,
+        numero: str,
+        humor_anterior: str,
+        humor_novo: str,
+        razao: str = "",
+        intensidade: float = 1.0
+    ):
+        """Registra transição de humor"""
+        contexto_id = self._gerar_contexto_id(numero, 'auto')
+        
+        query = """
+            INSERT INTO humor_historico
+            (contexto_id, humor_anterior, humor_novo, razao_mudanca, intensidade)
+            VALUES (?, ?, ?, ?, ?)
+        """
+        
+        self._execute_with_retry(
+            query,
+            (contexto_id, humor_anterior, humor_novo, razao, intensidade),
+            commit=True
+        )
+        
+        # Atualiza contexto
+        self._execute_with_retry(
+            "UPDATE contexto SET humor_atual = ? WHERE contexto_id = ?",
+            (humor_novo, contexto_id),
+            commit=True
+        )
+    
+    def salvar_reply_context(
+        self,
+        numero: str,
+        mensagem_id: str,
+        autor_original: str,
+        conteudo_original: str,
+        eh_resposta_a_bot: bool
+    ):
+        """Salva contexto de reply"""
+        contexto_id = self._gerar_contexto_id(numero, 'auto')
+        
+        query = """
+            INSERT INTO reply_context
+            (contexto_id, mensagem_id, autor_original, conteudo_original, eh_resposta_a_bot)
+            VALUES (?, ?, ?, ?, ?)
+        """
+        
+        self._execute_with_retry(
+            query,
+            (contexto_id, mensagem_id, autor_original, conteudo_original, int(eh_resposta_a_bot)),
+            commit=True
+        )
+    
+    def salvar_training_example(
+        self,
+        input_text: str,
+        output_text: str,
+        humor: str,
+        modo_resposta: str,
+        qualidade_score: float = 1.0
+    ):
+        """Salva exemplo para training dataset"""
+        query = """
+            INSERT INTO training_examples
+            (input_text, output_text, humor, modo_resposta, qualidade_score)
+            VALUES (?, ?, ?, ?, ?)
+        """
+        
+        self._execute_with_retry(
+            query,
+            (input_text[:500], output_text[:500], humor, modo_resposta, qualidade_score),
+            commit=True
+        )
+    
+    def recuperar_training_examples(self, limite: int = 100) -> List[Dict]:
+        """Recupera exemplos para treinamento"""
+        query = """
+            SELECT input_text, output_text, humor, modo_resposta, qualidade_score
+            FROM training_examples
+            WHERE usado_treino = 0
+            ORDER BY qualidade_score DESC
+            LIMIT ?
+        """
+        
+        results = self._execute_with_retry(query, (limite,))
+        
+        if not results:
+            return []
+        
+        return [
+            {
+                "input": r[0],
+                "output": r[1],
+                "humor": r[2],
+                "modo": r[3],
+                "score": r[4]
+            }
+            for r in results
+        ]
+    
+    def marcar_examples_como_usados(self):
+        """Marca exemplos como já usados no treinamento"""
+        self._execute_with_retry(
+            "UPDATE training_examples SET usado_treino = 1 WHERE usado_treino = 0",
+            commit=True
+        )
+
+    def salvar_contexto(
+        self,
+        numero: str,
+        historico: str = "",
+        humor_atual: str = "normal",
+        modo_resposta: str = "casual_amigavel",
+        termos: str = "",
+        girias: str = "",
+        tom: str = "normal"
+    ):
+        """Salva contexto completo"""
+        contexto_id = self._gerar_contexto_id(numero, 'auto')
+        tipo_contexto = "grupo" if ("@g.us" in numero or "120363" in numero) else "pv"
+        
+        query = """
+            INSERT OR REPLACE INTO contexto
+            (contexto_id, numero, tipo_contexto, historico, humor_atual, modo_resposta_atual, termos, girias, tom, ultima_atualizacao)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+        """
+        
+        self._execute_with_retry(
+            query,
+            (contexto_id, numero, tipo_contexto, historico, humor_atual, modo_resposta, termos, girias, tom),
+            commit=True
+        )
+    
+    def carregar_contexto(self, numero: str) -> Dict[str, Any]:
+        """Carrega contexto completo"""
+        contexto_id = self._gerar_contexto_id(numero, 'auto')
+        
+        rows = self._execute_with_retry(
+            """SELECT historico, humor_atual, modo_resposta_atual, termos, girias, tom 
+               FROM contexto 
+               WHERE contexto_id = ?""",
+            (contexto_id,)
+        )
+        
+        if not rows:
+            return {
+                "historico": "",
+                "humor_atual": "normal",
+                "modo_resposta": "casual_amigavel",
+                "termos": "",
+                "girias": "",
+                "tom": "normal"
+            }
+        
+        row = rows[0]
+        return {
+            "historico": row[0] or "",
+            "humor_atual": row[1] or "normal",
+            "modo_resposta": row[2] or "casual_amigavel",
+            "termos": row[3] or "",
+            "girias": row[4] or "",
+            "tom": row[5] or "normal"
+        }
+    
     def salvar_aprendizado_detalhado(
         self,
         numero_usuario: str,
@@ -326,89 +605,43 @@ class Database:
         confianca: float = 1.0,
         contexto: Optional[str] = None
     ):
-        """Salva aprendizado com valor OBRIGATÓRIO"""
+        """Salva aprendizado com contexto isolado"""
+        contexto_id = self._gerar_contexto_id(numero_usuario, 'auto')
+        
         self._execute_with_retry(
             """INSERT INTO aprendizado_detalhado
-               (numero_usuario, tipo, chave, valor, fonte, confianca, contexto)
+               (contexto_id, tipo, chave, valor, fonte, confianca, contexto)
                VALUES (?, ?, ?, ?, ?, ?, ?)""",
-            (numero_usuario, tipo, chave, valor, fonte, confianca, contexto),
+            (contexto_id, tipo, chave, valor, fonte, confianca, contexto),
             commit=True
         )
-
-    def salvar_mensagem(self, usuario, mensagem, resposta, numero=None, is_reply=False, mensagem_original=None):
-        cols = ['usuario', 'mensagem', 'resposta']
-        vals = [usuario, mensagem, resposta]
-        if numero: 
-            cols.append('numero')
-            vals.append(numero)
-        if is_reply is not None: 
-            cols.append('is_reply')
-            vals.append(int(is_reply))
-        if mensagem_original: 
-            cols.append('mensagem_original')
-            vals.append(mensagem_original)
-        
-        placeholders = ', '.join(['?' for _ in cols])
-        query = f"INSERT INTO mensagens ({', '.join(cols)}) VALUES ({placeholders})"
-        self._execute_with_retry(query, tuple(vals), commit=True)
-
-    def salvar_embedding(self, numero_usuario: str, mensagem: str, resposta: str, embedding, texto: str = ""):
-        try:
-            embedding_blob = sqlite3.Binary(pickle.dumps(embedding))
-            texto_final = texto or f"{mensagem} {resposta}"
-            self._execute_with_retry(
-                "INSERT INTO embeddings (numero_usuario, source_type, texto, embedding) VALUES (?, ?, ?, ?)",
-                (numero_usuario, 'conversa', texto_final[:500], embedding_blob),
-                commit=True
-            )
-        except Exception as e:
-            logger.warning(f"Erro ao salvar embedding: {e}")
-
-    def salvar_contexto(self, user_key: str, historico: str, emocao_atual: str, termos: str, girias: str, tom: str):
+    
+    def registrar_tom_usuario(self, numero_usuario: str, tom: str, intensidade: float = 0.5, contexto: str = ""):
+        """Registra tom detectado (isolado)"""
+        contexto_id = self._gerar_contexto_id(numero_usuario, 'auto')
+        
         try:
             self._execute_with_retry(
-                """INSERT OR REPLACE INTO contexto
-                   (user_key, historico, emocao_atual, termos, girias, tom)
-                   VALUES (?, ?, ?, ?, ?, ?)""",
-                (user_key, historico, emocao_atual, termos, girias, tom),
+                """INSERT INTO tom_usuario 
+                   (contexto_id, tom_detectado, intensidade, contexto) 
+                   VALUES (?, ?, ?, ?)""",
+                (contexto_id, tom, intensidade, contexto[:100]),
                 commit=True
             )
         except Exception as e:
-            logger.error(f"Falha ao salvar contexto: {e}")
-
-    def carregar_contexto(self, user_key: str) -> Dict[str, Any]:
-        rows = self._execute_with_retry(
-            "SELECT historico, emocao_atual, termos, girias, tom FROM contexto WHERE user_key=?",
-            (user_key,)
-        )
-        if not rows:
-            return {"historico": "", "emocao_atual": "{}", "termos": "", "girias": "", "tom": "neutro"}
-        row = rows[0]
-        try:
-            emocao_dict = json.loads(row[1]) if row[1] else {}
-        except:
-            emocao_dict = {}
-        return {
-            "historico": row[0] or "",
-            "emocao_atual": emocao_dict,
-            "termos": row[2] or "",
-            "girias": row[3] or "",
-            "tom": row[4] or "neutro"
-        }
-    
-    # ================================================================
-    # MÉTODO ADICIONAL: REGISTRAR TOM DO USUÁRIO
-    # ================================================================
+            logger.warning(f"Erro ao registrar tom: {e}")
     
-    def registrar_tom_usuario(self, numero_usuario: str, tom: str, intensidade: float = 0.5, contexto: str = ""):
-        """Registra tom detectado do usuário"""
+    def salvar_embedding(self, numero_usuario: str, mensagem: str, resposta: str, embedding, texto: str = ""):
+        """Salva embedding isolado"""
         try:
+            contexto_id = self._gerar_contexto_id(numero_usuario, 'auto')
+            embedding_blob = sqlite3.Binary(pickle.dumps(embedding))
+            texto_final = texto or f"{mensagem} {resposta}"
+            
             self._execute_with_retry(
-                """INSERT INTO tom_usuario 
-                   (numero_usuario, tom_detectado, intensidade, contexto) 
-                   VALUES (?, ?, ?, ?)""",
-                (numero_usuario, tom, intensidade, contexto[:100]),
+                "INSERT INTO embeddings (contexto_id, source_type, texto, embedding) VALUES (?, ?, ?, ?)",
+                (contexto_id, 'conversa', texto_final[:500], embedding_blob),
                 commit=True
             )
         except Exception as e:
-            logger.warning(f"Erro ao registrar tom: {e}")
+            logger.warning(f"Erro ao salvar embedding: {e}")