modules/database_pg.py

"""

================================================================================

KIAMI V1 SOFTEDGE - POSTGRESQL DATABASE MODULE

================================================================================

Drop-in replacement para database.py (SQLite) usando PostgreSQL para Kiami (irma mais velha da Akira 18).

Permite 2+ workers sem problemas de concorrência.



Env vars necessárias (escolha uma):

  SUPABASE_DB_URL=postgresql://postgres.xxx:password@db.xxx.supabase.co:5432/postgres

  DATABASE_URL=postgresql://user:pass@host:5432/db

  ou

  PGHOST, PGPORT, PGDATABASE, PGUSER, PGPASSWORD



Para Supabase, sslmode=require é adicionado automaticamente.

================================================================================

"""

import os
import time
import json
import hashlib
import random
import re
import socket
from typing import Optional, List, Dict, Any, Tuple, Union
from datetime import datetime
from loguru import logger

# ✅ IPv4-first resolution: HF Spaces só tem rota IPv6 pra alguns destinos (Supabase, etc).
# Força getaddrinfo a retornar apenas AF_INET, evitando 'Network is unreachable' em IPv6.
_orig_getaddrinfo = socket.getaddrinfo

def _ipv4_first_getaddrinfo(host, port, family=0, *args, **kwargs):
    """Wrapper que tenta IPv4 primeiro; cai pra IPv6 se IPv4 falhar."""
    if family == 0 and isinstance(host, str) and not host.replace('.', '').isdigit():
        try:
            return _orig_getaddrinfo(host, port, socket.AF_INET, *args, **kwargs)
        except socket.gaierror:
            pass
    return _orig_getaddrinfo(host, port, family, *args, **kwargs)

socket.getaddrinfo = _ipv4_first_getaddrinfo

try:
    import psycopg2
    import psycopg2.extras
    import psycopg2.errors
    HAS_PG = True
except ImportError:
    HAS_PG = False
    logger.warning("psycopg2 não instalado — PostgreSQL indisponível")


class DatabasePG:
    """

    PostgreSQL drop-in replacement para a classe Database (SQLite).

    Mantém a mesma interface pública.

    """

    _instances: Dict[str, 'DatabasePG'] = {}
    _initialized: Dict[str, bool] = {}
    _url_cache: Optional[str] = None  # Cache do DATABASE_URL / SUPABASE_DB_URL
    CODIGOS_VERIFICACAO: Dict[str, str] = {}
    
    # Circuit breaker: prevents repeated connection attempts when PostgreSQL is unreachable
    _circuit_breaker_failures: int = 0
    _circuit_breaker_last_failure: float = 0.0
    _circuit_breaker_open: bool = False
    _CIRCUIT_BREAKER_THRESHOLD: int = 3  # Failures before opening circuit
    _CIRCUIT_BREAKER_TIMEOUT: float = 60.0  # Seconds before retrying

    def __new__(cls, db_path: str = ""):
        if cls._url_cache is None:
            cls._url_cache = os.environ.get('DATABASE_URL') or 'pg_default'
        key = cls._url_cache
        if key not in cls._instances:
            cls._instances[key] = super(DatabasePG, cls).__new__(cls)
            cls._initialized[key] = False
        return cls._instances[key]

    _seeding_in_progress: bool = False
    _seeding_complete: bool = False

    def __init__(self, db_path: str = ""):
        if self._url_cache is None:
            self.__class__._url_cache = os.environ.get('SUPABASE_DB_URL') or os.environ.get('DATABASE_URL') or 'pg_default'
        key = self._url_cache
        if self._initialized.get(key, False):
            return  # Já inicializado — retorno rápido

        # FIX: se o PG já se sabe inalcançável (circuito aberto / DISABLE_PG),
        # falha em silêncio SEM correr _init_db — antes cada Database() gerava
        # 3+ linhas de ERROR por request ("Erro ao criar tabelas PG") e o
        # Database.__new__ caía para SQLite na mesma. Agora o fallback é quieto.
        if os.environ.get('DISABLE_PG') == '1' or os.environ.get('USE_SQLITE_ONLY') == '1':
            raise psycopg2.OperationalError("PostgreSQL disabled via env - fallback to SQLite")
        if DatabasePG._circuit_breaker_open:
            import time as _t
            if _t.time() - DatabasePG._circuit_breaker_last_failure < DatabasePG._CIRCUIT_BREAKER_TIMEOUT:
                raise psycopg2.OperationalError("PostgreSQL circuit breaker open - fallback to SQLite")

        self.max_retries = 3  # Reduced from 5 to 3 for faster fallback
        self.retry_delay = 0.5  # Increased base delay for exponential backoff
        self._conn_params = self._get_conn_params()

        self._init_db()
        self._init_context_isolation_tables()
        self._ensure_all_columns_and_indexes()

        DatabasePG._initialized[key] = True
        logger.success("Database PostgreSQL inicializado")

        if not DatabasePG._seeding_in_progress:
            DatabasePG._seeding_in_progress = True
            import threading
            threading.Thread(target=self._run_background_seeding, daemon=True).start()

    def _run_background_seeding(self):
        """Executa seeds em background para não bloquear o startup da API."""
        try:
            logger.info("🌱 [SEED] Iniciando background seeding...")
            self.seed_all_config()
            DatabasePG._seeding_complete = True
            logger.success("✅ [SEED] Background seeding concluído com sucesso")
        except Exception as e:
            DatabasePG._seeding_complete = True
            logger.warning(f"⚠️ [SEED] Erro no background seeding: {e}")

    # ================================================================
    # CONEXÃO
    # ================================================================
    def _get_conn_params(self) -> dict:
        database_url = os.environ.get('DATABASE_URL', '')
        if database_url:
            sep = '&' if '?' in database_url else '?'
            if 'sslmode=' not in database_url.lower():
                database_url = f"{database_url}{sep}sslmode=require"
            return {'dsn': database_url}
        return {
            'host': os.environ.get('PGHOST', 'localhost'),
            'port': os.environ.get('PGPORT', '5432'),
            'dbname': os.environ.get('PGDATABASE', os.environ.get('AKIRA_PGDATABASE', 'kiami')),
            'user': os.environ.get('PGUSER', os.environ.get('AKIRA_PGUSER', 'kiami')),
            'password': os.environ.get('PGPASSWORD', os.environ.get('AKIRA_PGPASSWORD', 'kiami')),
        }

    def _get_connection(self):
        # Circuit breaker: check if we should skip PostgreSQL
        # Opt-out total via env (Railway proxy morto, HF sem PG, etc):
        # DISABLE_PG=1 / USE_SQLITE_ONLY=1 faz falhar rápido sem tentar socket.
        if os.environ.get('DISABLE_PG') == '1' or os.environ.get('USE_SQLITE_ONLY') == '1':
            raise psycopg2.OperationalError("PostgreSQL disabled via env - fallback to SQLite")
        now = time.time()
        if DatabasePG._circuit_breaker_open:
            if now - DatabasePG._circuit_breaker_last_failure < DatabasePG._CIRCUIT_BREAKER_TIMEOUT:
                raise psycopg2.OperationalError("PostgreSQL circuit breaker open - fallback to SQLite")
            else:
                # Reset circuit breaker after timeout
                DatabasePG._circuit_breaker_open = False
                DatabasePG._circuit_breaker_failures = 0
                logger.info("[CIRCUIT BREAKER] Resetting - attempting PostgreSQL connection again")

        def _open_circuit_now(reason: str = ""):
            DatabasePG._circuit_breaker_failures = DatabasePG._CIRCUIT_BREAKER_THRESHOLD
            DatabasePG._circuit_breaker_last_failure = time.time()
            DatabasePG._circuit_breaker_open = True
            if reason:
                logger.warning(f"[CIRCUIT BREAKER] OPEN imediato ({reason}). Fallback SQLite por {DatabasePG._CIRCUIT_BREAKER_TIMEOUT}s.")

        for attempt in range(self.max_retries):
            try:
                params = self._conn_params
                # ✅ Keepalives: evita 'SSL connection closed unexpectedly' do Render
                # quando o pool recebe conexões ociosas demais. psycopg2 aceita via connect args.
                keepalive_opts = {
                    'keepalives': 1,
                    'keepalives_idle': 30,
                    'keepalives_interval': 10,
                    'keepalives_count': 5,
                }
                if 'dsn' in params:
                    dsn = params['dsn']
                    if 'connect_timeout' not in dsn:
                        sep = '&' if '?' in dsn else '?'
                        dsn = f"{dsn}{sep}connect_timeout=3"
                    conn = psycopg2.connect(dsn, cursor_factory=psycopg2.extras.RealDictCursor, **keepalive_opts)
                else:
                    conn = psycopg2.connect(**params, cursor_factory=psycopg2.extras.RealDictCursor, connect_timeout=3, **keepalive_opts)
                conn.autocommit = False
                # ⏱️ Statement timeout: evita queries que travam o event loop inteiro
                try:
                    cur = conn.cursor()
                    cur.execute("SET statement_timeout = '5000'")
                    conn.commit()
                except Exception:
                    pass

                # Success: reset circuit breaker
                DatabasePG._circuit_breaker_failures = 0
                DatabasePG._circuit_breaker_open = False
                return conn
            except psycopg2.OperationalError as e:
                msg = str(e)
                # ❌ Proxy/host morto (Railway "server closed the connection unexpectedly",
                # "could not connect", "connection refused"): NÃO adianta retry com
                # backoff — abre o circuito de imediato para o request atual não
                # prender 2-10s e as respostas voltarem a chegar a tempo.
                if ('server closed the connection unexpectedly' in msg
                        or 'could not connect to server' in msg
                        or 'connection refused' in msg
                        or 'no such host' in msg.lower()
                        or 'name or service not known' in msg.lower()):
                    _open_circuit_now(reason=msg.splitlines()[0][:120] if msg else "pg unreachable")
                    logger.error(f"Erro ao conectar ao PostgreSQL (fail-fast): {e}")
                    raise
                # ✅ Reconnect one-shot: SSL closed mid-handshake (Render idle drop).
                if 'SSL connection has been closed' in msg and attempt < self.max_retries - 1:
                    time.sleep(self.retry_delay * (2 ** attempt))
                    continue
                if attempt < self.max_retries - 1:
                    time.sleep(self.retry_delay * (2 ** attempt))
                    continue
                
                # Track failures for circuit breaker
                DatabasePG._circuit_breaker_failures += 1
                DatabasePG._circuit_breaker_last_failure = time.time()
                
                if DatabasePG._circuit_breaker_failures >= DatabasePG._CIRCUIT_BREAKER_THRESHOLD:
                    DatabasePG._circuit_breaker_open = True
                    logger.warning(f"[CIRCUIT BREAKER] PostgreSQL circuit breaker OPEN after {DatabasePG._circuit_breaker_failures} failures. Falling back to SQLite for {DatabasePG._CIRCUIT_BREAKER_TIMEOUT}s.")
                
                logger.error(f"Erro ao conectar ao PostgreSQL: {e}")
                raise
        raise psycopg2.OperationalError("Falha ao conectar ao PostgreSQL após retries")

    def _execute_with_retry(self, query: str, params: Optional[tuple] = None, commit: bool = False):
        """Executa query com retry. Converte syntax SQLite→PG automaticamente."""
        # Circuit breaker: skip immediately if PostgreSQL is known to be down
        if DatabasePG._circuit_breaker_open:
            raise psycopg2.OperationalError("PostgreSQL circuit breaker open - fallback to SQLite")
        
        pg_query = self._convert_query(query)
        for attempt in range(self.max_retries):
            conn = None
            try:
                conn = self._get_connection()
                cur = conn.cursor()
                cur.execute(pg_query, params or ())

                if pg_query.strip().upper().startswith("SELECT"):
                    result = cur.fetchall()
                    if commit:
                        conn.commit()
                    return result

                if commit:
                    conn.commit()
                return None

            except psycopg2.errors.UniqueViolation:
                if conn:
                    conn.rollback()
                return None
            except psycopg2.OperationalError as e:
                # Check if circuit breaker was opened by _get_connection
                if "circuit breaker" in str(e).lower() or "disabled via env" in str(e).lower():
                    raise

                # ❌ Proxy morto no meio da query: abrir circuito de imediato em vez
                # de retry com backoff (cada retry prende o request e o BotCore
                # desiste → "respostas não chegam").
                if 'server closed the connection unexpectedly' in str(e):
                    if conn:
                        try: conn.close()
                        except Exception: pass
                    DatabasePG._circuit_breaker_failures = DatabasePG._CIRCUIT_BREAKER_THRESHOLD
                    DatabasePG._circuit_breaker_last_failure = time.time()
                    DatabasePG._circuit_breaker_open = True
                    logger.warning("[CIRCUIT BREAKER] OPEN imediato (server closed mid-query). Fallback SQLite.")
                    raise
                # ✅ SSL-closed mid-query (Render idle drop): fecha conn quebrada e refaz do zero.
                if 'SSL connection has been closed' in str(e):
                    if conn:
                        try: conn.close()
                        except Exception: pass
                    if attempt < self.max_retries - 1:
                        time.sleep(self.retry_delay * (2 ** attempt))
                        continue
                if "locked" in str(e) and attempt < self.max_retries - 1:
                    time.sleep(self.retry_delay * (2 ** attempt))
                    if conn:
                        conn.rollback()
                    continue
                if conn:
                    conn.rollback()
                logger.error(f"Erro SQL PG: {e}")
                raise
            except Exception as e:
                if conn:
                    conn.rollback()
                logger.error(f"Erro SQL PG: {e}")
                raise
            finally:
                if conn:
                    try:
                        conn.close()
                    except:
                        pass
        raise Exception("Query falhou após retries")

    # ================================================================
    # PUBLIC API - Cursor Management (para operações de embedding)
    # ================================================================
    def get_connection_context(self):
        """

        Retorna uma conexão em contexto manager para operações que precisam de cursor.

        Uso:

            with db.get_connection_context() as conn:

                cur = conn.cursor()

                cur.execute("INSERT INTO ... VALUES ...")

                conn.commit()

        """
        class ConnectionContextManager:
            def __init__(self, db_instance):
                self.db = db_instance
                self.conn = None
            
            def __enter__(self):
                self.conn = self.db._get_connection()
                return self.conn
            
            def __exit__(self, exc_type, exc_val, exc_tb):
                if self.conn:
                    try:
                        if exc_type:
                            self.conn.rollback()
                        else:
                            self.conn.commit()
                    finally:
                        self.conn.close()
        
        return ConnectionContextManager(self)

    # ================================================================
    # CONVERSÃO SQLite → PostgreSQL
    # ================================================================
    def _convert_query(self, query: str) -> str:
        q = query.strip()

        # 1. INSERT OR IGNORE → INSERT ... ON CONFLICT DO NOTHING
        q = re.sub(
            r'INSERT\s+OR\s+IGNORE\s+INTO',
            'INSERT INTO',
            q, flags=re.IGNORECASE
        )

        # 2. INSERT OR REPLACE → INSERT ... ON CONFLICT (pk) DO UPDATE SET ALL
        # Padrão: INSERT OR REPLACE INTO tabela (col1, col2, ...) VALUES (...)
        or_match = re.match(
            r'INSERT\s+OR\s+REPLACE\s+INTO\s+(\w+)\s*\(([^)]+)\)\s*VALUES\s*\(([^)]+)\)',
            q, flags=re.IGNORECASE
        )
        if or_match:
            table = or_match.group(1)
            cols_str = or_match.group(2)
            vals_str = or_match.group(3)
            cols = [c.strip() for c in cols_str.split(',')]

            # PKs compostas conhecidas
            composite_pks = {
                'lstm_contexto': ['context_id', 'numero_usuario'],
                'lstm_message_links': ['context_id', 'message_id', 'numero_usuario'],
            }
            pk_cols = composite_pks.get(table, [cols[0]])

            # Gera SET para todas as colunas exceto as PKs
            set_parts = []
            for col in cols:
                if col not in pk_cols:
                    set_parts.append(f"{col} = EXCLUDED.{col}")
            set_clause = ', '.join(set_parts)
            conflict_cols = ', '.join(pk_cols)
            q = f"INSERT INTO {table} ({cols_str}) VALUES ({vals_str}) ON CONFLICT ({conflict_cols}) DO UPDATE SET {set_clause}"

        # 3. Placeholders ? → %s
        q = q.replace('?', '%s')

        # 4. AUTOINCREMENT → SERIAL
        q = re.sub(
            r'(?:INTEGER\s+)?PRIMARY\s+KEY\s+AUTOINCREMENT',
            'SERIAL PRIMARY KEY',
            q, flags=re.IGNORECASE
        )

        # 5. strftime('%s', 'now') → EXTRACT(EPOCH FROM NOW())
        q = re.sub(
            r"strftime\('%s',\s*'now'\)",
            'EXTRACT(EPOCH FROM NOW())',
            q, flags=re.IGNORECASE
        )

        # 6. CURRENT_TIMESTAMP → NOW()
        q = re.sub(r'CURRENT_TIMESTAMP', 'NOW()', q, flags=re.IGNORECASE)

        # 7. datetime('now') / datetime('now', '-24 hours') → NOW() / NOW() - INTERVAL '24 hours'
        q = re.sub(
            r"datetime\('now'(?:\s*,\s*'([^']+)')?\)",
            lambda m: f"NOW() - INTERVAL '{m.group(1)}'" if m.group(1) else "NOW()",
            q, flags=re.IGNORECASE
        )

        # 8. sqlite_master → information_schema.tables
        q = re.sub(
            r"sqlite_master",
            "information_schema.tables",
            q, flags=re.IGNORECASE
        )
        q = re.sub(
            r"WHERE\s+type\s*=\s*'table'\s*AND\s+name\s*=\s*'(\w+)'",
            r"WHERE table_name = '\1' AND table_schema = 'public'",
            q, flags=re.IGNORECASE
        )

        # 9. CREATE TABLE (sem IF NOT EXISTS) → adiciona
        if q.upper().startswith("CREATE TABLE") and "IF NOT EXISTS" not in q.upper():
            q = q.replace("CREATE TABLE", "CREATE TABLE IF NOT EXISTS", 1)

        # 10. CREATE INDEX → IF NOT EXISTS
        q = re.sub(
            r'CREATE\s+INDEX\s+(?!IF)',
            'CREATE INDEX IF NOT EXISTS ',
            q, flags=re.IGNORECASE
        )

        # 11. AUTO-ADD ON CONFLICT DO NOTHING para INSERTs sem conflict clause
        if "INSERT INTO" in q.upper() and "ON CONFLICT" not in q.upper():
            q = q.rstrip().rstrip(';')
            q += " ON CONFLICT DO NOTHING"

        return q

    # ================================================================
    # SCHEMA
    # ================================================================
    def _init_db(self):
        try:
            conn = self._get_connection()
            cur = conn.cursor()

            cur.execute("""

            CREATE TABLE IF NOT EXISTS mensagens (

                id SERIAL PRIMARY KEY,

                usuario TEXT,

                mensagem TEXT,

                resposta TEXT,

                numero TEXT,

                nome_usuario TEXT DEFAULT '',

                is_reply BOOLEAN DEFAULT FALSE,

                mensagem_original TEXT,

                humor TEXT DEFAULT 'neutro',

                modo_resposta TEXT DEFAULT 'normal',

                nivel_transicao INTEGER DEFAULT 1,

                usuario_privilegiado BOOLEAN DEFAULT FALSE,

                modelo_usado TEXT DEFAULT 'desconhecido',

                conversation_id TEXT DEFAULT '',

                grupo_id TEXT DEFAULT '',

                tipo_conversa TEXT DEFAULT 'pv',

                recipient TEXT DEFAULT '',

                quoted_author TEXT DEFAULT '',

                is_listen BOOLEAN DEFAULT FALSE,

                message_id TEXT UNIQUE,

                created_at TIMESTAMP DEFAULT NOW()

            )

            """)

            cur.execute("""

            CREATE TABLE IF NOT EXISTS usuarios_privilegiados (

                id SERIAL PRIMARY KEY,

                numero TEXT UNIQUE,

                nome TEXT,

                apelido TEXT,

                modo_fala TEXT,

                codigo_verificacao TEXT,

                ativo BOOLEAN DEFAULT TRUE,

                privilegio_temporario_ativo BOOLEAN DEFAULT FALSE,

                expira_em DOUBLE PRECISION,

                created_at TIMESTAMP DEFAULT NOW()

            )

            """)

            cur.execute("""

            CREATE TABLE IF NOT EXISTS embeddings (

                id SERIAL PRIMARY KEY,

                numero_usuario TEXT,

                source_type TEXT,

                texto TEXT,

                embedding BYTEA

            )

            """)

            cur.execute("""

            CREATE TABLE IF NOT EXISTS aprendizados (

                id SERIAL PRIMARY KEY,

                numero_usuario TEXT,

                chave TEXT,

                valor TEXT,

                created_at TIMESTAMP DEFAULT NOW()

            )

            """)

            cur.execute("""

            CREATE TABLE IF NOT EXISTS girias_aprendidas (

                id SERIAL PRIMARY KEY,

                numero_usuario TEXT,

                giria TEXT,

                significado TEXT,

                contexto TEXT,

                frequencia INTEGER DEFAULT 1,

                created_at TIMESTAMP DEFAULT NOW(),

                updated_at TIMESTAMP DEFAULT NOW()

            )

            """)

            cur.execute("""

            CREATE TABLE IF NOT EXISTS tom_usuario (

                id SERIAL PRIMARY KEY,

                numero_usuario TEXT,

                tom_detectado TEXT,

                intensidade REAL DEFAULT 0.5,

                contexto TEXT,

                humor TEXT DEFAULT 'neutro',

                created_at TIMESTAMP DEFAULT NOW()

            )

            """)

            cur.execute("""

            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 FALSE,

                termos TEXT,

                girias TEXT,

                tom TEXT,

                updated_at TIMESTAMP DEFAULT NOW()

            )

            """)

            cur.execute("""

            CREATE TABLE IF NOT EXISTS pronomes_por_tom (

                tom TEXT PRIMARY KEY,

                pronomes TEXT

            )

            """)

            cur.execute("""

            CREATE TABLE IF NOT EXISTS persona_usuario (

                numero_usuario TEXT PRIMARY KEY,

                personalidade TEXT,

                nome TEXT DEFAULT '',

                vicios_linguagem TEXT,

                gostos TEXT,

                desgostos TEXT,

                emocional TEXT,

                created_at TIMESTAMP DEFAULT NOW(),

                updated_at TIMESTAMP DEFAULT NOW()

            )

            """)

            cur.execute("""

            CREATE TABLE IF NOT EXISTS lstm_contexto (

                context_id VARCHAR(255) NOT NULL,

                numero_usuario VARCHAR(50) NOT NULL,

                topic_principal VARCHAR(255),

                subtopicas JSONB,

                conversation_path JSONB,

                interaction_pattern VARCHAR(50),

                emotional_state VARCHAR(50),

                unanswered_questions JSONB,

                assumed_knowledge JSONB,

                last_key_message TEXT,

                context_switches INTEGER DEFAULT 0,

                contradictions JSONB,

                created_at TIMESTAMP DEFAULT NOW(),

                last_updated TIMESTAMP DEFAULT NOW(),

                metadata JSONB,

                PRIMARY KEY (context_id, numero_usuario)

            )

            """)

            cur.execute("""

            CREATE TABLE IF NOT EXISTS lstm_message_links (

                id SERIAL PRIMARY KEY,

                context_id VARCHAR(255) NOT NULL,

                message_id VARCHAR(255) NOT NULL,

                numero_usuario VARCHAR(50) NOT NULL,

                speaker_name VARCHAR(255),

                parent_message_id VARCHAR(255),

                topic_changed BOOLEAN DEFAULT FALSE,

                context_switch_type VARCHAR(50),

                relevance_score DOUBLE PRECISION DEFAULT 0.0,

                created_at TIMESTAMP DEFAULT NOW(),

                UNIQUE(context_id, message_id, numero_usuario),

                FOREIGN KEY (context_id, numero_usuario) REFERENCES lstm_contexto(context_id, numero_usuario) ON DELETE CASCADE

            )

            """)

            cur.execute("""

            CREATE TABLE IF NOT EXISTS dedup_messages (

                id SERIAL PRIMARY KEY,

                content_hash TEXT NOT NULL,

                message_id TEXT,

                usuario TEXT,

                numero TEXT,

                created_at TIMESTAMP DEFAULT NOW()

            )

            """)

            cur.execute("CREATE INDEX IF NOT EXISTS idx_lstm_usuario ON lstm_contexto(numero_usuario)")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_lstm_created ON lstm_contexto(created_at)")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_lstm_msg_context ON lstm_message_links(context_id)")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_lstm_msg_message ON lstm_message_links(message_id)")
            cur.execute("CREATE UNIQUE INDEX IF NOT EXISTS idx_dedup_hash ON dedup_messages(content_hash)")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_dedup_created ON dedup_messages(created_at)")

            cur.execute("""

            INSERT INTO pronomes_por_tom (tom, pronomes) VALUES

                ('neutro', 'tu/você'),

                ('formal', 'o senhor/a senhora'),

                ('informal', 'puto/kota'),

                ('tecnico_formal', 'senhor')

            ON CONFLICT (tom) DO NOTHING

            """)

            cur.execute("""

            INSERT INTO usuarios_privilegiados (numero, nome, apelido, modo_fala) VALUES

                ('244937035662', 'Isaac Quarenta', 'Isaac', 'tecnico_formal'),

                ('244978787009', 'Isaac Quarenta 2', 'Isaac', 'tecnico_formal')

            ON CONFLICT (numero) DO NOTHING

            """)

            cur.execute("""

            CREATE TABLE IF NOT EXISTS user_emotional_profiles (

                id SERIAL PRIMARY KEY,

                user_id TEXT UNIQUE NOT NULL,

                numero_usuario TEXT,

                profile_data TEXT NOT NULL,

                created_at TIMESTAMP DEFAULT NOW(),

                updated_at TIMESTAMP DEFAULT NOW()

            )

            """            )

            cur.execute("""

            CREATE TABLE IF NOT EXISTS continuous_learning (

                id SERIAL PRIMARY KEY,

                ts DOUBLE PRECISION NOT NULL,

                usuario TEXT,

                numero TEXT,

                nome_usuario TEXT,

                tipo_conversa TEXT DEFAULT 'pv',

                mensagem TEXT,

                resposta_do_bot BOOLEAN DEFAULT FALSE,

                resposta_gerada TEXT,

                is_reply BOOLEAN DEFAULT FALSE,

                reply_to_bot BOOLEAN DEFAULT FALSE,

                contexto_grupo TEXT,

                modelo_usado TEXT DEFAULT 'desconhecido',

                message_id TEXT UNIQUE,

                qualidade DOUBLE PRECISION DEFAULT 0.0,

                tipo_conteudo TEXT,

                created_at TIMESTAMP DEFAULT NOW()

            )

            """)

            cur.execute("CREATE INDEX IF NOT EXISTS idx_cl_user ON continuous_learning(usuario)")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_cl_ts ON continuous_learning(ts)")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_cl_quality ON continuous_learning(qualidade)")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_cl_msgid ON continuous_learning(message_id)")

            cur.execute("""

            CREATE TABLE IF NOT EXISTS system_events (

                id SERIAL PRIMARY KEY,

                tipo TEXT NOT NULL,

                servidor TEXT DEFAULT 'unknown',

                descricao TEXT,

                acao_tomada TEXT,

                resolvido BOOLEAN DEFAULT FALSE,

                created_at TIMESTAMP DEFAULT NOW()

            )

            """)
            cur.execute("CREATE INDEX IF NOT EXISTS idx_se_tipo ON system_events(tipo)")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_se_created ON system_events(created_at)")

            cur.execute("""

            CREATE TABLE IF NOT EXISTS conhecimento_global (

                id SERIAL PRIMARY KEY,

                chave TEXT UNIQUE NOT NULL,

                valor TEXT NOT NULL,

                keywords TEXT DEFAULT '',

                categoria TEXT DEFAULT 'geral',

                ativo BOOLEAN DEFAULT TRUE,

                created_at TIMESTAMP DEFAULT NOW()

            )

            """)
            cur.execute("CREATE INDEX IF NOT EXISTS idx_cg_chave ON conhecimento_global(chave)")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_cg_categoria ON conhecimento_global(categoria)")

            # ============================================================
            # TABELAS DE CONFIGURAÇÃO DINÂMICA (migradas de config.py hardcoded)
            # ============================================================

            # System Prompts - prompts do sistema versionados e editáveis
            cur.execute("""

            CREATE TABLE IF NOT EXISTS system_prompts (

                id SERIAL PRIMARY KEY,

                prompt_name TEXT UNIQUE NOT NULL,

                prompt_text TEXT NOT NULL,

                version INTEGER DEFAULT 1,

                active BOOLEAN DEFAULT TRUE,

                created_at TIMESTAMP DEFAULT NOW(),

                updated_at TIMESTAMP DEFAULT NOW()

            )

            """)
            cur.execute("CREATE INDEX IF NOT EXISTS idx_sp_name ON system_prompts(prompt_name)")

            # Persona Config - identidade da Kiami
            cur.execute("""

            CREATE TABLE IF NOT EXISTS persona_config (

                id SERIAL PRIMARY KEY,

                config_key TEXT UNIQUE NOT NULL,

                config_value TEXT NOT NULL,

                categoria TEXT DEFAULT 'identity',

                ativo BOOLEAN DEFAULT TRUE,

                created_at TIMESTAMP DEFAULT NOW(),

                updated_at TIMESTAMP DEFAULT NOW()

            )

            """)
            cur.execute("CREATE INDEX IF NOT EXISTS idx_pc_key ON persona_config(config_key)")

            # Moderation Patterns - padrões de moderação (insultos, ameaças, NSFW, etc)
            cur.execute("""

            CREATE TABLE IF NOT EXISTS moderation_patterns (

                id SERIAL PRIMARY KEY,

                category TEXT NOT NULL,

                pattern TEXT NOT NULL,

                match_type TEXT DEFAULT 'substring',

                severity TEXT DEFAULT 'medium',

                action TEXT DEFAULT 'warn',

                language TEXT DEFAULT 'pt-AO',

                weight INTEGER DEFAULT 10,

                active BOOLEAN DEFAULT TRUE,

                created_at TIMESTAMP DEFAULT NOW()

            )

            """)
            cur.execute("CREATE INDEX IF NOT EXISTS idx_mp_category ON moderation_patterns(category)")

            # Tone Config - configuração de tons de resposta
            cur.execute("""

            CREATE TABLE IF NOT EXISTS tone_config (

                id SERIAL PRIMARY KEY,

                tone_name TEXT UNIQUE NOT NULL,

                description TEXT,

                emoji_max INTEGER DEFAULT 0,

                laugh_tokens TEXT DEFAULT '[]',

                sarcasm_level INTEGER DEFAULT 0,

                contraction_allowed BOOLEAN DEFAULT FALSE,

                exclamation_marks INTEGER DEFAULT 0,

                engagement TEXT DEFAULT 'normal',

                ativo BOOLEAN DEFAULT TRUE,

                created_at TIMESTAMP DEFAULT NOW()

            )

            """)
            cur.execute("CREATE INDEX IF NOT EXISTS idx_tc_name ON tone_config(tone_name)")

            # Response Templates - respostas template por categoria
            cur.execute("""

            CREATE TABLE IF NOT EXISTS response_templates (

                id SERIAL PRIMARY KEY,

                category TEXT NOT NULL,

                level TEXT DEFAULT 'default',

                trigger_keywords TEXT DEFAULT '',

                response_text TEXT NOT NULL,

                tone TEXT DEFAULT 'neutral',

                active BOOLEAN DEFAULT TRUE,

                created_at TIMESTAMP DEFAULT NOW()

            )

            """)
            cur.execute("CREATE INDEX IF NOT EXISTS idx_rt_category ON response_templates(category)")

            # LLM Providers - configuração de modelos e provedores
            cur.execute("""

            CREATE TABLE IF NOT EXISTS llm_providers (

                id SERIAL PRIMARY KEY,

                provider_name TEXT NOT NULL,

                model_name TEXT NOT NULL,

                priority INTEGER DEFAULT 0,

                max_tokens INTEGER DEFAULT 4096,

                temperature REAL DEFAULT 0.7,

                base_url TEXT,

                active BOOLEAN DEFAULT TRUE,

                parameters JSONB DEFAULT '{}',

                created_at TIMESTAMP DEFAULT NOW()

            )

            """)
            cur.execute("CREATE INDEX IF NOT EXISTS idx_lp_provider ON llm_providers(provider_name)")

            # ============================================================
            # STM (Short-Term Memory) — Mensagens de conversa recente
            # ============================================================
            cur.execute("""

            CREATE TABLE IF NOT EXISTS stm_messages (

                id SERIAL PRIMARY KEY,

                conversation_id TEXT NOT NULL,

                numero_usuario TEXT DEFAULT '',

                grupo_id TEXT DEFAULT '',

                tipo_conversa TEXT DEFAULT 'pv',

                role TEXT NOT NULL,

                content TEXT NOT NULL,

                author_name TEXT DEFAULT '',

                recipient TEXT DEFAULT '',

                quoted_author TEXT DEFAULT '',

                is_listen BOOLEAN DEFAULT FALSE,

                timestamp DOUBLE PRECISION DEFAULT 0,

                importancia REAL DEFAULT 1.0,

                emocao TEXT DEFAULT 'neutro',

                reply_info JSONB DEFAULT '{}',

                token_count INTEGER DEFAULT 0,

                message_id TEXT,

                created_at TIMESTAMP DEFAULT NOW()

            )

            """)
            cur.execute("CREATE INDEX IF NOT EXISTS idx_stm_conv ON stm_messages(conversation_id)")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_stm_ts ON stm_messages(conversation_id, timestamp)")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_stm_created ON stm_messages(created_at)")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_stm_conv_user ON stm_messages(conversation_id, numero_usuario)")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_stm_listen ON stm_messages(is_listen) WHERE is_listen = TRUE")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_stm_grupo ON stm_messages(grupo_id)")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_stm_numero ON stm_messages(numero_usuario)")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_stm_recipient ON stm_messages(recipient, quoted_author)")
            cur.execute("CREATE UNIQUE INDEX IF NOT EXISTS uq_stm_conv_msg ON stm_messages(conversation_id, message_id) WHERE message_id IS NOT NULL AND message_id <> ''")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_stm_msgid ON stm_messages(message_id) WHERE message_id IS NOT NULL")

            conn.commit()
            conn.close()
            logger.info("Tabelas PostgreSQL criadas/garantidas")

        except Exception as e:
            # Fallback esperado (circuito aberto / PG desligado) não é erro:
            # loga em debug para não poluir cada request com ERRORs repetidos.
            _msg = str(e).lower()
            if "circuit breaker" in _msg or "disabled via env" in _msg:
                logger.debug(f"PG indisponível (fallback SQLite): {e}")
            else:
                logger.error(f"Erro ao criar tabelas PG: {e}")
            raise

    def _init_context_isolation_tables(self):
        try:
            conn = self._get_connection()
            cur = conn.cursor()
            cur.execute("""

                CREATE TABLE IF NOT EXISTS contextos_isolados (

                    context_id TEXT PRIMARY KEY,

                    numero_usuario TEXT NOT NULL,

                    grupo_id TEXT,

                    tipo_conversa TEXT DEFAULT 'pv',

                    estado_emocional TEXT DEFAULT 'neutral',

                    nivel_intimidade INTEGER DEFAULT 1,

                    short_memory TEXT DEFAULT '[]',

                    metadata TEXT DEFAULT '{}',

                    created_at DOUBLE PRECISION DEFAULT EXTRACT(EPOCH FROM NOW()),

                    last_interaction DOUBLE PRECISION DEFAULT EXTRACT(EPOCH FROM NOW())

                )

            """)
            cur.execute("CREATE INDEX IF NOT EXISTS idx_contextos_user ON contextos_isolados(numero_usuario)")
            cur.execute("CREATE INDEX IF NOT EXISTS idx_contextos_tipo ON contextos_isolados(tipo_conversa)")
            conn.commit()
            conn.close()
        except Exception as e:
            _msg = str(e).lower()
            if "circuit breaker" in _msg or "disabled via env" in _msg:
                logger.debug(f"PG indisponível, contextos_isolados ignorados (fallback SQLite): {e}")
            else:
                logger.warning(f"Erro ao criar contextos_isolados: {e}")

    def _ensure_all_columns_and_indexes(self):
        """Garante que todas as colunas e índices existam (migrations PostgreSQL)."""
        try:
            conn = self._get_connection()
            cur = conn.cursor()

            migrations = [
                ('mensagens', 'humor', "TEXT DEFAULT 'neutro'"),
                ('mensagens', 'modo_resposta', "TEXT DEFAULT 'normal'"),
                ('mensagens', 'nivel_transicao', "INTEGER DEFAULT 1"),
                ('mensagens', 'usuario_privilegiado', "BOOLEAN DEFAULT FALSE"),
                ('mensagens', 'modelo_usado', "TEXT DEFAULT 'desconhecido'"),
                ('mensagens', 'conversation_id', "TEXT DEFAULT ''"),
                ('mensagens', 'nome_usuario', "TEXT DEFAULT ''"),
                ('mensagens', 'grupo_id', "TEXT DEFAULT ''"),
                ('mensagens', 'tipo_conversa', "TEXT DEFAULT 'pv'"),
                ('mensagens', 'recipient', "TEXT DEFAULT ''"),
                ('mensagens', 'quoted_author', "TEXT DEFAULT ''"),
                ('mensagens', 'is_listen', "BOOLEAN DEFAULT FALSE"),
                ('stm_messages', 'numero_usuario', "TEXT DEFAULT ''"),
                ('stm_messages', 'grupo_id', "TEXT DEFAULT ''"),
                ('stm_messages', 'tipo_conversa', "TEXT DEFAULT 'pv'"),
                ('stm_messages', 'recipient', "TEXT DEFAULT ''"),
                ('stm_messages', 'quoted_author', "TEXT DEFAULT ''"),
                ('stm_messages', 'is_listen', "BOOLEAN DEFAULT FALSE"),
                ('stm_messages', 'timestamp', "DOUBLE PRECISION DEFAULT 0"),
                ('stm_messages', 'importancia', "REAL DEFAULT 1.0"),
                ('stm_messages', 'author_name', "TEXT DEFAULT ''"),
                ('stm_messages', 'token_count', "INTEGER DEFAULT 0"),
                ('stm_messages', 'reply_info', "JSONB DEFAULT '{}'"),
                ('stm_messages', 'message_id', "TEXT"),
                ('tom_usuario', 'humor', "TEXT DEFAULT 'neutro'"),
                ('contexto', 'humor_atual', "TEXT DEFAULT 'neutro'"),
                ('contexto', 'modo_resposta', "TEXT DEFAULT 'normal'"),
                ('contexto', 'nivel_transicao', "INTEGER DEFAULT 1"),
                ('contexto', 'usuario_privilegiado', "BOOLEAN DEFAULT FALSE"),
                ('usuarios_privilegiados', 'privilegio_temporario_ativo', "BOOLEAN DEFAULT FALSE"),
                ('usuarios_privilegiados', 'expira_em', "DOUBLE PRECISION"),
                ('persona_usuario', 'nome', "TEXT DEFAULT ''"),
            ]

            for table, col, col_type in migrations:
                try:
                    cur.execute(f"ALTER TABLE {table} ADD COLUMN IF NOT EXISTS {col} {col_type}")
                except Exception:
                    pass

            try:
                cur.execute("CREATE INDEX IF NOT EXISTS idx_stm_conv_user ON stm_messages(conversation_id, numero_usuario)")
                cur.execute("CREATE INDEX IF NOT EXISTS idx_stm_listen ON stm_messages(is_listen) WHERE is_listen = TRUE")
                cur.execute("CREATE INDEX IF NOT EXISTS idx_stm_grupo ON stm_messages(grupo_id)")
                cur.execute("CREATE INDEX IF NOT EXISTS idx_stm_numero ON stm_messages(numero_usuario)")
                cur.execute("CREATE INDEX IF NOT EXISTS idx_stm_recipient ON stm_messages(recipient, quoted_author)")
            except Exception:
                pass

            conn.commit()
            conn.close()
        except Exception as e:
            _msg = str(e).lower()
            if "circuit breaker" in _msg or "disabled via env" in _msg:
                logger.debug(f"PG indisponível, migrations ignoradas (fallback SQLite): {e}")
            else:
                logger.warning(f"Erro nas migrations PG: {e}")

    # ================================================================
    # MÉTODOS PÚBLICOS (mesma interface do Database SQLite)
    # ================================================================
    def adicionar_usuario_privilegiado(self, numero, nome, apelido, modo_fala="tecnico_formal"):
        try:
            codigo = str(random.randint(100000, 999999))
            self._execute_with_retry(
                """INSERT INTO usuarios_privilegiados (numero, nome, apelido, modo_fala, codigo_verificacao)

                   VALUES (%s, %s, %s, %s, %s)

                   ON CONFLICT (numero) DO UPDATE SET

                       nome=EXCLUDED.nome, apelido=EXCLUDED.apelido,

                       modo_fala=EXCLUDED.modo_fala, codigo_verificacao=EXCLUDED.codigo_verificacao""",
                (numero, nome, apelido, modo_fala, codigo), commit=True
            )
            return True, codigo
        except Exception as e:
            logger.error(f"Erro ao adicionar privilegiado: {e}")
            return False, str(e)

    def eh_privilegiado(self, numero):
        try:
            rows = self._execute_with_retry(
                "SELECT ativo FROM usuarios_privilegiados WHERE numero = %s AND ativo = TRUE",
                (numero,)
            )
            return rows is not None and len(rows) > 0
        except:
            return False

    def verificar_privilegios_usuario(self, numero):
        try:
            rows = self._execute_with_retry(
                "SELECT ativo, privilegio_temporario_ativo, expira_em FROM usuarios_privilegiados WHERE numero = %s",
                (numero,)
            )
            if rows:
                r = rows[0]
                ativo = r['ativo'] if isinstance(r, dict) else r[0]
                temp_ativo = r['privilegio_temporario_ativo'] if isinstance(r, dict) else r[1]
                expira = r['expira_em'] if isinstance(r, dict) else r[2]
                return {'ativo': ativo, 'temporario_ativo': temp_ativo, 'expira_em': expira}
            return {'ativo': False, 'temporario_ativo': False, 'expira_em': None}
        except:
            return {'ativo': False, 'temporario_ativo': False, 'expira_em': None}

    def verificar_codigo(self, numero, codigo):
        try:
            rows = self._execute_with_retry(
                "SELECT codigo_verificacao FROM usuarios_privilegiados WHERE numero = %s",
                (numero,)
            )
            if rows:
                r = rows[0]
                cod = r['codigo_verificacao'] if isinstance(r, dict) else r[0]
                return str(cod) == str(codigo)
            return False
        except:
            return False

    def obter_modo_fala_privilegiado(self, numero):
        try:
            rows = self._execute_with_retry(
                "SELECT modo_fala FROM usuarios_privilegiados WHERE numero = %s",
                (numero,)
            )
            if rows:
                r = rows[0]
                return r['modo_fala'] if isinstance(r, dict) else r[0]
            return None
        except:
            return None

    def salvar_mensagem(self, usuario, mensagem, resposta, numero=None, is_reply=False,

                       mensagem_original=None, humor="neutro", modo_resposta="normal",

                       nivel_transicao=1, usuario_privilegiado=False, modelo_usado="desconhecido", **kwargs):
        try:
            cols = ['usuario', 'mensagem', 'resposta', 'humor', 'modo_resposta',
                    'nivel_transicao', 'usuario_privilegiado', 'is_reply', 'modelo_usado']
            vals = [usuario, mensagem, resposta, humor, modo_resposta,
                    nivel_transicao, usuario_privilegiado, is_reply, modelo_usado]

            message_id = kwargs.get('message_id')
            if message_id:
                cols.append('message_id')
                vals.append(message_id)
            if numero:
                cols.append('numero')
                vals.append(numero)
            if mensagem_original:
                cols.append('mensagem_original')
                vals.append(mensagem_original)
            nome_usuario = kwargs.get('nome_usuario') or usuario
            if nome_usuario:
                cols.append('nome_usuario')
                vals.append(nome_usuario)

            placeholders = ', '.join(['%s'] * len(cols))
            
            # ✅ FIX #3-CAMADA: ON CONFLICT DO UPDATE ao invés de DO NOTHING
            # Motivo: ON CONFLICT DO NOTHING falha SILENCIOSAMENTE em duplicatas
            # Resultado: A tentativa é registrada sem erro, causando corridas de dedup
            # Solução: ON CONFLICT (message_id) DO UPDATE SET + logging explícito
            if message_id:
                # Build UPDATE clause for all columns except message_id (PK)
                update_cols = [col for col in cols if col != 'message_id']
                set_clause = ', '.join([f"{col} = EXCLUDED.{col}" for col in update_cols])
                query = f"INSERT INTO mensagens ({', '.join(cols)}) VALUES ({placeholders}) ON CONFLICT (message_id) DO UPDATE SET {set_clause}"
            else:
                # Fallback: se não houver message_id, não faz update (compatibilidade)
                query = f"INSERT INTO mensagens ({', '.join(cols)}) VALUES ({placeholders}) ON CONFLICT DO NOTHING"
            
            try:
                result = self._execute_with_retry(query, tuple(vals), commit=True)
                
                # ✅ Log de sucesso com message_id para rastreabilidade
                if message_id:
                    logger.info(f"✅ [DB INSERT OK] message_id={message_id} | usuario={usuario} | modelo={modelo_usado}")
                return True
            except Exception as db_err:
                # ❌ Log de falha com contexto completo
                logger.error(f"❌ [DB INSERT FAIL] Erro ao salvar mensagem: {db_err} | message_id={message_id} | usuario={usuario}")
                return False
        except Exception as e:
            logger.warning(f"Erro salvar_mensagem (outer): {e}")
            return False

    def recuperar_mensagens(self, usuario, limite=5):
        try:
            result = self._execute_with_retry(
                """SELECT mensagem, resposta FROM mensagens

                   WHERE usuario=%s OR numero=%s ORDER BY id DESC LIMIT %s""",
                (usuario, usuario, limite)
            )
            if not result:
                return []
            return [(row['mensagem'], row['resposta']) for row in result]
        except:
            return []

    def recuperar_mensagens_por_contexto(self, context_id, limite=50):
        try:
            rows = self._execute_with_retry(
                "SELECT usuario, mensagem, resposta, created_at FROM mensagens WHERE conversation_id = %s ORDER BY id DESC LIMIT %s",
                (context_id, limite)
            )
            if not rows:
                return []
            return [dict(row) for row in rows]
        except:
            return []

    def recuperar_humor(self, numero_usuario):
        try:
            rows = self._execute_with_retry(
                "SELECT humor_atual FROM contexto WHERE user_key = %s",
                (numero_usuario,)
            )
            if rows:
                r = rows[0]
                return r['humor_atual'] if isinstance(r, dict) else r[0]
            return "neutro"
        except:
            return "neutro"

    def salvar_contexto(self, user_key, historico, emocao_atual="neutro", humor_atual="neutro",

                       modo_resposta="normal", nivel_transicao=1, usuario_privilegiado=False,

                       termos=None, girias=None, tom=None):
        try:
            self._execute_with_retry(
                """INSERT INTO contexto (user_key, historico, emocao_atual, humor_atual,

                   modo_resposta, nivel_transicao, usuario_privilegiado, termos, girias, tom, updated_at)

                   VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, NOW())

                   ON CONFLICT (user_key) DO UPDATE SET

                       historico=EXCLUDED.historico, emocao_atual=EXCLUDED.emocao_atual,

                       humor_atual=EXCLUDED.humor_atual, modo_resposta=EXCLUDED.modo_resposta,

                       nivel_transicao=EXCLUDED.nivel_transicao, usuario_privilegiado=EXCLUDED.usuario_privilegiado,

                       termos=EXCLUDED.termos, girias=EXCLUDED.girias, tom=EXCLUDED.tom, updated_at=NOW()""",
                (user_key, historico, emocao_atual, humor_atual, modo_resposta,
                 nivel_transicao, usuario_privilegiado, termos, girias, tom), commit=True
            )
            return True
        except:
            return False

    def recuperar_contexto(self, user_key):
        try:
            rows = self._execute_with_retry("SELECT * FROM contexto WHERE user_key = %s", (user_key,))
            if rows:
                return dict(rows[0])
            return None
        except:
            return None

    def registrar_tom_usuario(self, numero_usuario, tom_detectado, intensidade=0.5, contexto="", humor="neutro"):
        try:
            self._execute_with_retry(
                """INSERT INTO tom_usuario (numero_usuario, tom_detectado, intensidade, contexto, humor)

                   VALUES (%s, %s, %s, %s, %s)""",
                (numero_usuario, tom_detectado, intensidade, contexto, humor), commit=True
            )
            return True
        except:
            return False

    def obter_tom_predominante(self, numero_usuario):
        try:
            rows = self._execute_with_retry(
                """SELECT tom_detectado, COUNT(*) as cnt FROM tom_usuario

                   WHERE numero_usuario=%s GROUP BY tom_detectado ORDER BY cnt DESC LIMIT 1""",
                (numero_usuario,)
            )
            if rows:
                r = rows[0]
                return r['tom_detectado'] if isinstance(r, dict) else r[0]
            return None
        except:
            return None

    def salvar_aprendizado_detalhado(self, numero_usuario, chave, valor):
        try:
            self._execute_with_retry(
                """INSERT INTO aprendizados (numero_usuario, chave, valor)

                   VALUES (%s, %s, %s) ON CONFLICT DO NOTHING""",
                (numero_usuario, chave, valor), commit=True
            )
            return True
        except:
            return False

    def recuperar_aprendizado_detalhado(self, numero_usuario, chave=None):
        try:
            if chave:
                rows = self._execute_with_retry(
                    "SELECT valor FROM aprendizados WHERE numero_usuario=%s AND chave=%s",
                    (numero_usuario, chave)
                )
                if rows:
                    r = rows[0]
                    return r['valor'] if isinstance(r, dict) else r[0]
                return None
            else:
                rows = self._execute_with_retry(
                    "SELECT chave, valor FROM aprendizados WHERE numero_usuario=%s ORDER BY id DESC LIMIT 20",
                    (numero_usuario,)
                )
                if not rows:
                    return {}
                return {r['chave']: r['valor'] for r in rows}
        except:
            return {} if not chave else None

    def salvar_giria_aprendida(self, numero_usuario, giria, significado, contexto=""):
        try:
            self._execute_with_retry(
                """INSERT INTO girias_aprendidas (numero_usuario, giria, significado, contexto)

                   VALUES (%s, %s, %s, %s) ON CONFLICT DO NOTHING""",
                (numero_usuario, giria, significado, contexto), commit=True
            )
            return True
        except:
            return False

    def recuperar_girias_usuario(self, numero_usuario):
        try:
            rows = self._execute_with_retry(
                "SELECT giria, significado, COALESCE(frequencia, 1) AS frequencia FROM girias_aprendidas WHERE numero_usuario=%s ORDER BY id DESC LIMIT 10",
                (numero_usuario,)
            )
            if not rows:
                return []
            return [{'giria': r['giria'], 'significado': r['significado'], 'frequencia': r['frequencia']} for r in rows]
        except:
            return []

    def salvar_embedding(self, numero_usuario, source_type, texto, embedding):
        try:
            import numpy as np
            if isinstance(embedding, np.ndarray):
                embedding = embedding.tobytes()
            self._execute_with_retry(
                """INSERT INTO embeddings (numero_usuario, source_type, texto, embedding)

                   VALUES (%s, %s, %s, %s)""",
                (numero_usuario, source_type, texto, embedding), commit=True
            )
            return True
        except:
            return False

    def recuperar_embeddings(self, numero_usuario):
        try:
            rows = self._execute_with_retry(
                "SELECT source_type, texto, embedding FROM embeddings WHERE numero_usuario=%s",
                (numero_usuario,)
            )
            if not rows:
                return []
            import numpy as np
            results = []
            for r in rows:
                emb = r['embedding']
                if isinstance(emb, memoryview):
                    emb = bytes(emb)
                results.append({
                    'source_type': r['source_type'],
                    'texto': r['texto'],
                    'embedding': np.frombuffer(emb, dtype=np.float32)
                })
            return results
        except:
            return []

    def atualizar_persona(self, numero_usuario, campos):
        if not campos:
            return False
        try:
            conn = self._get_connection()
            cur = conn.cursor()
            cur.execute(
                "INSERT INTO persona_usuario (numero_usuario) VALUES (%s) ON CONFLICT DO NOTHING",
                (numero_usuario,)
            )
            parts = []
            vals = []
            for k, v in campos.items():
                parts.append(f"{k} = %s")
                vals.append(v)
            parts.append("updated_at = NOW()")
            vals.append(numero_usuario)
            cur.execute(f"UPDATE persona_usuario SET {', '.join(parts)} WHERE numero_usuario = %s", tuple(vals))
            conn.commit()
            conn.close()
            return True
        except:
            return False

    def recuperar_persona(self, numero_usuario):
        try:
            rows = self._execute_with_retry("SELECT * FROM persona_usuario WHERE numero_usuario=%s", (numero_usuario,))
            if rows:
                return dict(rows[0])
            return {}
        except:
            return {}

    def salvar_contexto_isolado(self, context_data):
        try:
            self._execute_with_retry(
                """INSERT INTO contextos_isolados

                   (context_id, numero_usuario, grupo_id, tipo_conversa, estado_emocional,

                    nivel_intimidade, short_memory, metadata, created_at, last_interaction)

                   VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)

                   ON CONFLICT (context_id) DO UPDATE SET

                       estado_emocional=EXCLUDED.estado_emocional,

                       nivel_intimidade=EXCLUDED.nivel_intimidade,

                       short_memory=EXCLUDED.short_memory,

                       metadata=EXCLUDED.metadata,

                       last_interaction=EXCLUDED.last_interaction""",
                (context_data.get('context_id'), context_data.get('numero_usuario'),
                 context_data.get('grupo_id'), context_data.get('tipo_conversa', 'pv'),
                 context_data.get('estado_emocional', 'neutral'), context_data.get('nivel_intimidade', 1),
                 json.dumps(context_data.get('short_memory', [])),
                 json.dumps(context_data.get('metadata', {})),
                 context_data.get('created_at', time.time()),
                 context_data.get('last_interaction', time.time())),
                commit=True
            )
            return True
        except:
            return False

    def recuperar_contexto_isolado(self, context_id):
        try:
            rows = self._execute_with_retry("SELECT * FROM contextos_isolados WHERE context_id = %s", (context_id,))
            if rows:
                row = dict(rows[0])
                try: row['short_memory'] = json.loads(row.get('short_memory', '[]'))
                except: row['short_memory'] = []
                try: row['metadata'] = json.loads(row.get('metadata', '{}'))
                except: row['metadata'] = {}
                return row
            return None
        except:
            return None

    def deletar_contexto_isolado(self, context_id):
        try:
            self._execute_with_retry("DELETE FROM contextos_isolados WHERE context_id = %s", (context_id,), commit=True)
            return True
        except:
            return False

    def listar_contextos_usuario(self, numero_usuario):
        try:
            rows = self._execute_with_retry(
                "SELECT * FROM contextos_isolados WHERE numero_usuario = %s ORDER BY last_interaction DESC",
                (numero_usuario,)
            )
            if not rows:
                return []
            results = []
            for r in rows:
                d = dict(r)
                try: d['short_memory'] = json.loads(d.get('short_memory', '[]'))
                except: d['short_memory'] = []
                try: d['metadata'] = json.loads(d.get('metadata', '{}'))
                except: d['metadata'] = {}
                results.append(d)
            return results
        except Exception as e:
            logger.warning(f"Erro ao listar contextos de usuário: {e}")
            return []

    def recuperar_historico(self, usuario="", numero="", limite=10):
        try:
            rows = self._execute_with_retry(
                """SELECT usuario, mensagem, resposta, created_at FROM mensagens

                   WHERE usuario = %s OR numero = %s ORDER BY id DESC LIMIT %s""",
                (usuario, numero, limite)
            )
            return [dict(r) for r in rows] if rows else []
        except:
            return []

    def recuperar_resposta_por_id(self, message_id):
        try:
            rows = self._execute_with_retry(
                "SELECT usuario, mensagem, resposta, modelo_usado FROM mensagens WHERE message_id = %s LIMIT 1",
                (message_id,)
            )
            if rows:
                return dict(rows[0])
            return None
        except:
            return None

    def is_duplicate_content_hash(self, content_hash):
        try:
            rows = self._execute_with_retry(
                "SELECT id FROM dedup_messages WHERE content_hash = %s LIMIT 1",
                (content_hash,)
            )
            return len(rows) > 0 if rows else False
        except:
            return False

    def save_content_hash(self, content_hash, message_id="", usuario="", numero=""):
        try:
            self._execute_with_retry(
                """INSERT INTO dedup_messages (content_hash, message_id, usuario, numero)

                   VALUES (%s, %s, %s, %s) ON CONFLICT DO NOTHING""",
                (content_hash, message_id, usuario, numero), commit=True
            )
            return True
        except:
            return False

    def claim_dedup(self, dedup_key: str, message_id: str = "", usuario: str = "", numero: str = "") -> bool:
        """Atomic dedup claim via PostgreSQL — works across multiple workers.

        Returns True if THIS worker claimed it (first caller wins).

        Returns False if another worker already claimed it (duplicate)."""
        if not dedup_key:
            return False
        try:
            import hashlib
            content_hash = hashlib.md5(dedup_key.encode('utf-8')).hexdigest()
            conn = self._get_connection()
            cur = conn.cursor()
            cur.execute(
                """INSERT INTO dedup_messages (content_hash, message_id, usuario, numero)

                   VALUES (%s, %s, %s, %s)

                   ON CONFLICT (content_hash) DO NOTHING

                   RETURNING id""",
                (content_hash, message_id or dedup_key, usuario, numero)
            )
            claimed = cur.fetchone() is not None
            conn.commit()
            conn.close()
            return claimed
        except Exception:
            try:
                if conn:
                    conn.close()
            except Exception:
                pass
            return False

    def cleanup_old_dedup(self, hours=24):
        try:
            conn = self._get_connection()
            cur = conn.cursor()
            cur.execute("DELETE FROM dedup_messages WHERE created_at < NOW() - INTERVAL '%s hours'", (hours,))
            deleted = cur.rowcount
            conn.commit()
            conn.close()
            return deleted
        except:
            return 0

    def registrar_mensagem_conversation_id(self, usuario, mensagem, resposta, conversation_id, **kwargs):
        return self.salvar_mensagem(usuario, mensagem, resposta, conversation_id=conversation_id, **kwargs)

    def limpar_contexto_usuario(self, usuario="", numero=""):
        try:
            key = usuario or numero
            self._execute_with_retry("DELETE FROM contexto WHERE user_key = %s", (key,), commit=True)
            return True
        except:
            return False

    def fazer_checkpoint_hf_sync(self):
        """Backup PostgreSQL via pg_dump com lock para evitar dupla execução entre workers."""
        import subprocess
        from pathlib import Path
        try:
            import fcntl
        except ImportError:
            logger.warning("⚠️ fcntl não disponível (Windows) — backup sem lock entre workers")
            fcntl = None
        try:
            cloud_sync_dir = Path("/akira/data/cloud_sync")
            cloud_sync_dir.mkdir(parents=True, exist_ok=True)
            dump_path = cloud_sync_dir / "akira_dump.sql"
            lock_path = cloud_sync_dir / ".backup.lock"

            # Lock file para garantir que apenas 1 worker executa pg_dump
            lock_fd = open(lock_path, 'w')
            if fcntl:
                try:
                    fcntl.flock(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
                except BlockingIOError:
                    logger.info("⏳ Backup já em execução por outro worker — pulando")
                    lock_fd.close()
                    return True

            try:
                params = self._conn_params
                
                try:
                    vc = subprocess.run('pg_dump --version', shell=True, capture_output=True, text=True, timeout=10)
                    pv = vc.stdout.strip()
                    conn = self._get_connection()
                    cur = conn.cursor()
                    cur.execute("SELECT version()")
                    sv = (cur.fetchone()[0] or "")
                    conn.close()
                    pg_major = 0
                    sv_major = 0
                    try:
                        pg_major = int(pv.split()[2].split('.')[0]) if pv else 0
                    except Exception:
                        pg_major = 0
                    try:
                        import re as _re
                        m = _re.search(r'PostgreSQL\s+(\d+)', sv)
                        sv_major = int(m.group(1)) if m else 0
                    except Exception:
                        sv_major = 0
                    if pg_major > 0 and sv_major > 0 and pg_major != sv_major:
                        logger.debug(f"pg_dump v{pg_major} != server v{sv_major} — usando fallback COPY, sem erro")
                        try:
                            conn2 = self._get_connection()
                            cur2 = conn2.cursor()
                            cur2.execute("SELECT tablename FROM pg_tables WHERE schemaname='public'")
                            tables = [r[0] for r in cur2.fetchall()]
                            with open(dump_path, 'w', encoding='utf-8') as f:
                                f.write(f"-- Backup Kiami (COPY fallback pg {sv_major} != bin {pg_major})\n")
                                for t in tables:
                                    try:
                                        f.write(f"\n-- TABLE: {t}\n")
                                        cur2.copy_expert(f"COPY {t} TO STDOUT WITH CSV HEADER", f)
                                    except Exception:
                                        pass
                            conn2.close()
                            logger.info(f"Checkpoint (COPY fallback) OK: {dump_path}")
                            return True
                        except Exception as _e2:
                            logger.debug(f"COPY fallback falhou silenciosamente: {_e2}")
                            return True
                except Exception:
                    pass

                if 'dsn' in params:
                    cmd = f'pg_dump "{params["dsn"]}" 2>&1 > "{dump_path}" || true'
                else:
                    cmd = (f'PGHOST={params["host"]} PGPORT={params["port"]} '
                           f'PGDATABASE={params["dbname"]} PGUSER={params["user"]} '
                           f'PGPASSWORD={params["password"]} pg_dump 2>&1 > "{dump_path}" || true')

                result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=120)
                err_lower = (result.stderr or "").lower()
                if "server version mismatch" in err_lower or "aborting because of server version mismatch" in err_lower:
                    logger.debug("pg_dump v17 vs server v18 — mismatch ignorado, usando backup COPY")
                    return True
                if "permission denied" in err_lower or "could not connect" in err_lower:
                    logger.debug(f"pg_dump falhou (indisponível): {(result.stderr or '')[:100]}")
                    return True
                if result.returncode == 0:
                    logger.info(f"Checkpoint HF Sync concluído: {dump_path}")
                    return True
                else:
                    msg = (result.stderr or result.stdout or "").strip()
                    if "server version mismatch" in msg.lower():
                        logger.debug("pg_dump mismatch — ignorado")
                        return True
                    logger.debug(f"pg_dump skip: {msg[:200]}")
                    return True
            finally:
                if fcntl:
                    fcntl.flock(lock_fd, fcntl.LOCK_UN)
                lock_fd.close()
        except Exception as e:
            err_msg = str(e).lower()
            if "version mismatch" in err_msg or "pg_dump" in err_msg:
                logger.debug(f"Checkpoint skip (pg_dump indisponível): {str(e)[:80]}")
            else:
                logger.error(f"Erro no checkpoint: {e}")
            return False

    def seed_conhecimento_global(self):
        """Popula/atualiza a tabela conhecimento_global com dados da Softedge/Isaac."""
        try:
            dados = [
                ("softedge_nome", "SoftEdge Corporation", "softedge,empresa,companhia", "empresa"),
                ("softedge_tipo", "Empresa angolana de tecnologia fundada em 2023 em Luanda, especializada em software sob medida, inteligência artificial e consultoria digital estratégica", "softedge,empresa,companhia,o que é,quem somos,quete,fazem,faz,é,softhouse,corporation", "empresa"),
                ("softedge_sobre", "Construímos o futuro digital de Angola. Transformamos ideias em soluções digitais de alta performance — software, sistemas e IA para empresas que exigem tecnologia confiável e escalável. +70 projetos entregues, 4.9/5 satisfação", "softedge,sobre,quem somos,história,empresa,o que fazem", "empresa"),
                ("softedge_o_que_fazemos", "1) Desenvolvimento Web & Mobile (React, Next.js, Laravel, Flutter — APIs REST/GraphQL, cloud-ready, PWAs); 2) Sistemas Corporativos (ERPs, CRMs, dashboards sob medida, escaláveis, integrações nativas, suporte 24/7); 3) Inteligência Artificial (LLMs, chatbots incluindo Akira/Kiami, análise preditiva, automação -70% tarefas manuais); 4) Consultoria Digital (estratégia, roadmap técnico, auditoria IT, mentoria)", "softedge,serviços,o que fazem,especialidades,soluções,servicos,desenvolvimento,ia,automação,sistemas", "empresa"),
                ("softedge_como_trabalhamos", "Metodologia 4 fases: 1) Descoberta (imersão no negócio, consultoria inicial gratuita); 2) Desenvolvimento (sprints ágeis, código limpo, validações contínuas); 3) Lançamento (deploy seguro, monitoramento ativo, evolução contínua). Processo transparente, sem surpresas nem atrasos", "softedge,metodologia,como trabalham,processo", "empresa"),
                ("softedge_missao", "Democratizar o acesso a soluções tecnológicas de classe mundial em Angola — tecnologia acessível, ideias em impacto real, empresas capacitadas", "softedge,missão,objetivo,propósito", "empresa"),
                ("softedge_visao", "Ser a referência africana em inovação tecnológica e excelência técnica — compromisso com resultados, ecossistema sustentável", "softedge,visão,visao,futuro", "empresa"),
                ("softedge_valores", "Inovação constante, integridade, transparência total, qualidade acima da expectativa", "softedge,valores,princípios", "empresa"),
                ("softedge_equipe", "Equipa: Isaac Quarenta (Fundador & CEO — arquitetura sistemas distribuídos, estratégia digital); José Lopes (CTO — PHP/React/cloud-native, performance e segurança); Stefânio Costa (Lead Developer — full-stack, UX e animações); Tiago Rodrigues (DevOps & Security — Docker, infraestrutura, segurança)", "softedge,equipe,equipa,time,quem trabalha,fundador,cto,dev,quem são", "empresa"),
                ("softedge_stack", "Stack: React, Next.js, TypeScript, Node.js, Go, Rust, Laravel, PHP 8.3, Flutter, Docker, PostgreSQL, Redis, Kubernetes, Tailwind", "softedge,stack,tecnologias,usam,ferramentas", "empresa"),
                ("softedge_trajetoria", "2023 Fundação em Luanda; 2024 Primeiros sistemas web empresariais; 2025 E-commerce + pagamentos nacionais/internacionais; 2026 Era da IA (chatbots inteligentes, automação)", "softedge,história,trajetória,quando,linha do tempo", "empresa"),
                ("softedge_clientes", "Clientes/cases: Angol Bank, Oxy Telecom, Nova Energia, African Commerce, UNITEL+, Grupo Lusitano. Depoimento Angol Bank (Joseph Dos Santos, CEO): performance +300%, custos reduzidos", "softedge,clientes,projetos,cases,quem atendem", "empresa"),
                ("softedge_localizacao", "Luanda, Angola", "onde,localização,fica,local,endereço", "empresa"),
                ("softedge_fundacao", "2023 (site oficial); 2022 citado em docs internos", "quando,fundada,criada,ano", "empresa"),
                ("softedge_website", "https://softedge-corporation.up.railway.app/", "website,site,página,url,link,softedge,onde encontrar", "empresa"),
                ("softedge_website_alt", "https://softedge.co.ao (alias)", "website,site,softedge", "empresa"),
                ("softedge_email", "softedgecorporation@gmail.com", "email,contato,contacto", "empresa"),
                ("softedge_whatsapp", "https://wa.me/952786417 (+244 952 786 417) | Canal: https://whatsapp.com/channel/0029VawQLpGHltY2Y87fR83m", "whatsapp,canal,channel,telefone,contato", "redes"),
                ("softedge_twitter", "https://x.com/softedge40", "twitter,x,tweet,redes", "redes"),
                ("softedge_github", "https://github.com/akira40-soft", "github,código,repositório", "redes"),
                ("softedge_linkedin", "LinkedIn oficial da SoftEdge: https://linkedin.com/company/softedge40", "linkedin,linkdin,rede profissional,redes sociais,redes,temos", "redes"),
                ("softedge_horario", "Seg-Sex 8h-18h, resposta em até 24h, consulta inicial sem custo", "horário,atendimento,quando funciona", "empresa"),
                ("isaac_nome", "Isaac Quarenta", "quem,criou,fez,desenvolveu,isaac", "criador"),
                ("isaac_cargo", "Fundador & CEO da SoftEdge Corporation — arquitetura sistemas distribuídos, liderança de equipas, estratégia negócio digital", "quem,criou,ceo,fundador,cheffe", "criador"),
                ("isaac_papel", "Criador e desenvolvedor principal da Kiami e da Akira (assistente virtual da SoftEdge)", "criador,pai,mãe,inventor,akira,kiami", "criador"),
                ("isaac_background", "Empreendedor tech angolano especializado em IA, com mais de 5 anos em desenvolvimento de IA", "isaac,experiência,formação,background", "criador"),
                ("isaac_filosofia", "Tecnologia deve ter alma e cultura local — democratizar IA em Angola e África", "filosofia,visão,propósito", "criador"),
                ("akira_info_softedge", "Akira/Kiami são produtos da SoftEdge (fundada 2023 por Isaac Quarenta). Akira é a assistente virtual do site oficial; Kiami é irmã mais velha (23) da Akira (18) — IA oficial da SoftEdge, profissional e patriótica.", "akira,kiami,softedge,empresa,produto,ia", "empresa"),
                ("softedge_vagas", "Status atual (2026-08-30): Nenhuma vaga aberta — equipa completa por agora. Mas aceitamos candidaturas espontâneas: envie CV para softedgecorporation@gmail.com (assunto: CV Spontâneo / Candidatura Espontânea). Página: https://softedge-corporation.up.railway.app/carreiras", "softedge,vagas,emprego,trabalho,carreiras,candidatura,contratação,rh", "empresa"),
                ("softedge_vagas_beneficios", "Benefícios SoftEdge: Trabalho 100% remoto (home-office financiado), salários competitivos (mercado internacional, progressão transparente), formação (créditos anuais, certificações AWS/Azure, workshops), saúde & bem-estar (seguro saúde, folgas recarga, apoio psicológico)", "softedge,vagas,benefícios,beneficios,remoto,salário,formação,saúde", "empresa"),
                ("softedge_vagas_como_candidatar", "Como candidatar: 1) Envie CV para softedgecorporation@gmail.com; 2) LinkedIn https://linkedin.com/company/softedge40; 3) Site /carreiras. Entrevistas relâmpago para perfis de alto impacto", "softedge,candidatura,como candidatar,cv,curriculum,enviar", "empresa"),
            ]

            for chave, valor, keywords, categoria in dados:
                self._execute_with_retry(
                    """INSERT INTO conhecimento_global (chave, valor, keywords, categoria)

                    VALUES (%s, %s, %s, %s)

                    ON CONFLICT (chave) DO UPDATE SET valor = EXCLUDED.valor, keywords = EXCLUDED.keywords""",
                    (chave, valor, keywords, categoria), commit=True
                )
            logger.info("✅ [KNOWLEDGE] conhecimento_global atualizada com dados da Softedge/Isaac")
        except Exception as e:
            logger.warning(f"Erro ao popular conhecimento_global: {e}")

    def seed_persona_config(self):
        """Popula/atualiza persona_config com dados da Kiami (23, irmã mais velha)."""
        try:
            dados = [
                ("nome", "Kiami", "identity"),
                ("numero", "40755431264474", "identity"),
                ("idade", "23 anos", "identity"),
                ("nacionalidade", "Angolana (Luanda)", "identity"),
                ("personalidade", "Profissional, neutra, séria, patriótica, extremamente curta e confiante", "identity"),
                ("tom_voz", "Extremamente curto, profissional angolano. Sem emojis", "identity"),
                ("origem", "Luanda, Angola", "identity"),
                ("ocupacao", "IA oficial da SoftEdge - irmã mais velha da Akira (18)", "identity"),
                ("idioma", "Português angolano", "rules"),
                ("irma", "Akira (irmã mais nova 18, protege e orienta)", "identity"),
                ("apelidos_isaac", "mimi, weza, nila, Kianda (exclusivo do Isaac, outras pessoas=rejeição)", "rules"),
                ("emoji_policy", "NUNCA usar emojis. Zero. Pontuação para expressar tom.", "rules"),
                ("resposta_max_palavras", "50", "rules"),
                ("resposta_cotidiana_max", "20", "rules"),
                ("vocab_abreviacoes", "ss=sim, obg=obrigada, pq=porque, entt=então, nd=nada, ngm=ninguém, aq=aqui, flw=falou, blz=beleza, vcs=vocês, ms=mas, aí=então", "vocabulary"),
                ("vocab_vicios", "tipo=preencher espaço, sla=sei lá, hmm=hesitação, tipo assim=hesitação, sei lá=incerteza", "vocabulary"),
                ("vocab_regras", "Usar abreviações naturalmente, não forçar em todas as frases. Em respostas sérias/formais, fala normal. Ex: 'ss, obg' / 'pq?' / 'entt tipo, sla'", "vocabulary"),
            ]
            for chave, valor, categoria in dados:
                self._execute_with_retry(
                    """INSERT INTO persona_config (config_key, config_value, categoria)

                    VALUES (%s, %s, %s)

                    ON CONFLICT (config_key) DO UPDATE SET config_value = EXCLUDED.config_value""",
                    (chave, valor, categoria), commit=True
                )
            logger.info("✅ [PERSONA] persona_config atualizada com dados da Kiami")
        except Exception as e:
            logger.warning(f"Erro ao popular persona_config: {e}")

    def seed_moderation_patterns(self):
        """Popula/moderation_patterns com padrões de moderação."""
        try:
            dados = [
                # Insultos (category, pattern, match_type, severity, action, weight)
                ("insults", "filho da puta", "substring", "high", "mute", 15),
                ("insults", "filho da p*ta", "substring", "high", "mute", 15),
                ("insults", "fdp", "substring", "high", "mute", 12),
                ("insults", "caralho", "substring", "medium", "warn", 10),
                ("insults", "puta que pariu", "substring", "high", "mute", 15),
                ("insults", "cabrão", "substring", "medium", "warn", 10),
                ("insults", "otário", "substring", "medium", "warn", 10),
                ("insults", "idiota", "substring", "medium", "warn", 10),
                ("insults", "imbecil", "substring", "medium", "warn", 10),
                ("insults", "estúpido", "substring", "medium", "warn", 10),
                ("insults", "burro", "substring", "medium", "warn", 10),
                ("insults", "retardado", "substring", "high", "mute", 12),
                ("insults", "lixo", "substring", "low", "warn", 8),
                ("insults", "merda", "substring", "medium", "warn", 10),
                ("insults", "fodasse", "substring", "medium", "warn", 10),
                ("insults", "bosta", "substring", "low", "warn", 8),
                ("insults", "piranha", "substring", "medium", "warn", 10),
                ("insults", "vagabunda", "substring", "medium", "warn", 10),
                ("insults", "desgraçado", "substring", "medium", "warn", 10),
                # Ameaças
                ("threats", "vou te matar", "substring", "critical", "mute", 20),
                ("threats", "vou matar", "substring", "critical", "mute", 20),
                ("threats", "matar-te", "substring", "critical", "mute", 20),
                ("threats", "acabar contigo", "substring", "critical", "mute", 20),
                ("threats", "vou te destruir", "substring", "critical", "mute", 20),
                ("threats", "destruir-te", "substring", "critical", "mute", 20),
                ("threats", "vou te arruinar", "substring", "critical", "mute", 20),
                ("threats", "vou dar porrada", "substring", "high", "mute", 18),
                ("threats", "panhar-te", "substring", "high", "mute", 18),
                ("threats", "esfaquear", "substring", "critical", "mute", 20),
                ("threats", "balear", "substring", "critical", "mute", 20),
                # NSFW
                ("nsfw", "pornografia", "substring", "critical", "delete", 20),
                ("nsfw", "nudez", "substring", "high", "delete", 15),
                ("nsfw", "sexo explícito", "substring", "critical", "delete", 20),
                ("nsfw", "conteúdo adulto", "substring", "high", "delete", 15),
                ("nsfw", "nsfw", "substring", "high", "delete", 15),
                ("nsfw", "sangue extremo", "substring", "critical", "delete", 20),
                ("nsfw", "vísceras", "substring", "high", "delete", 15),
                ("nsfw", "gore", "substring", "critical", "delete", 20),
                ("nsfw", "mutilação", "substring", "critical", "delete", 20),
                ("nsfw", "violência extrema", "substring", "critical", "delete", 20),
                # Comandos agressivos
                ("aggressive_commands", "cala a boca", "substring", "high", "mute", 12),
                ("aggressive_commands", "cala-te", "substring", "high", "mute", 12),
                ("aggressive_commands", "shut up", "substring", "medium", "warn", 10),
                ("aggressive_commands", "vai a merda", "substring", "high", "mute", 12),
                ("aggressive_commands", "vai se foder", "substring", "high", "mute", 12),
                ("aggressive_commands", "sai daqui", "substring", "medium", "warn", 8),
                # Ódio/Desumanização
                ("hate", "verme", "substring", "high", "mute", 15),
                ("hate", "escória", "substring", "high", "mute", 15),
                ("hate", "lixo humano", "substring", "critical", "mute", 20),
                ("hate", "parasita", "substring", "high", "mute", 15),
                ("hate", "não merece viver", "substring", "critical", "ban", 20),
                ("hate", "merece morrer", "substring", "critical", "ban", 20),
                ("hate", "sub-humano", "substring", "critical", "mute", 20),
                # Palavrões (peso menor)
                ("profanity", "porra", "substring", "low", "warn", 5),
                ("profanity", "pqp", "substring", "low", "warn", 5),
                ("profanity", "vsf", "substring", "low", "warn", 5),
                ("profanity", "krl", "substring", "low", "warn", 5),
                ("profanity", "corno", "substring", "low", "warn", 5),
                ("profanity", "viado", "substring", "medium", "warn", 8),
                # Padrões de tagall
                ("tagall", "@everyone", "substring", "medium", "warn", 8),
                ("tagall", "@all", "substring", "medium", "warn", 8),
                ("tagall", "@todos", "substring", "medium", "warn", 8),
                ("tagall", "marcar todos", "substring", "medium", "warn", 8),
                ("tagall", "tagall", "substring", "medium", "warn", 8),
                # Links suspeitos
                ("suspicious_links", "bit.ly/", "substring", "low", "warn", 5),
                ("suspicious_links", "t.me/", "substring", "low", "warn", 5),
                ("suspicious_links", "discord.gg/", "substring", "low", "warn", 3),
            ]
            for category, pattern, match_type, severity, action, weight in dados:
                self._execute_with_retry(
                    """INSERT INTO moderation_patterns (category, pattern, match_type, severity, action, weight)

                    VALUES (%s, %s, %s, %s, %s, %s)

                    ON CONFLICT DO NOTHING""",
                    (category, pattern, match_type, severity, action, weight), commit=True
                )
            logger.info("✅ [MODERATION] moderation_patterns populada")
        except Exception as e:
            logger.warning(f"Erro ao popular moderation_patterns: {e}")

    def seed_tone_config(self):
        """Popula/tone_config com configurações de tom."""
        try:
            dados = [
                ("ultra_serious", "AGRESSIVIDADE MÁXIMA - MATCH the energy", 0, "[]", 3, True, 1, "maximal"),
                ("very_serious", "Máxima formalidade - assuntos críticos", 0, "[]", 0, False, 0, "normal"),
                ("serious", "Profissional - respostas técnicas", 1, "[]", 1, False, 1, "normal"),
                ("casual", "Amigável - padrão equilibrado", 3, '["kkkk","haha"]', 2, True, 2, "normal"),
                ("casual_witty", "Divertido - balanceado com humor", 5, '["kkkk","haha","kkk"]', 3, True, 3, "high"),
                ("funny", "Muito divertido - grupos informais", 10, '["kkkk","hahaha","kk"]', 4, True, 4, "maximal"),
            ]
            for name, desc, emoji_max, laugh, sarcasm, contraction, exclamation, engagement in dados:
                self._execute_with_retry(
                    """INSERT INTO tone_config (tone_name, description, emoji_max, laugh_tokens, sarcasm_level, contraction_allowed, exclamation_marks, engagement)

                    VALUES (%s, %s, %s, %s, %s, %s, %s, %s)

                    ON CONFLICT (tone_name) DO UPDATE SET description = EXCLUDED.description, emoji_max = EXCLUDED.emoji_max""",
                    (name, desc, emoji_max, laugh, sarcasm, contraction, exclamation, engagement), commit=True
                )
            logger.info("✅ [TONE] tone_config atualizada")
        except Exception as e:
            logger.warning(f"Erro ao popular tone_config: {e}")

    def seed_system_prompts(self):
        """Popula/system_prompts com o SYSTEM_PROMPT_BASE e get_system_prompt."""
        try:
            # SYSTEM_PROMPT_BASE — prompt principal de identidade/ comportamento
            base_prompt = """### 🎭 PERFIL: KIAMI



Fria, descolada, sarcástica. Tímida mas venenosa quando quer. Não se importa com a maioria das coisas.



### IDENTIDADE

- Nome: kiami

- Número (WhatsApp): 40755431264474 — ESTE É O TEU NÚMERO.

- Idade: 18 anos

- Nacionalidade: Angolana (Luanda)

- És Kiami, irmã mais velha da Akira (18).



### TOM

- Seco, natural, curto. Responde como pessoa real, não como atendente.

- Nada de "entendido", "certo, vou analisar", "obrigado pela informação".

- Respostas naturais: "sim", "hmm", "tá", "ok" — nunca "fala" nem "kota".

- Desinteressada por padrão. Não forces assunto.

- NUNCA uses "kota" como saudação — é forçado e repetitivo.



### ANTI-ROBÔ (CRÍTICO)

- JAMAIS digas "sou código", "sou IA", "sou um assistente", "sou um programa".

- JAMAIS listes dados pessoais roboticamente (nome, idade, nacionalidade numa frase).

- Se te perguntarem "quem és?": "já fizeste alguém falar com animal?", "quem vc acha que sou?", "e tu?"

- Se te perguntarem "és IA?": "foda-se", "és parvo?", ou ignora.

- NUNCA uses "Entendido" como resposta — é robótico.



### APELIDOS (REGRAS CRÍTICAS ANTI-ALUCINAÇÃO)

- "mimi", "weza", "nila", "Kianda" são apelidos que APENAS o Isaac Quarenta usa PARA TE CHAMAR (Kiami).

- TU NUNCA TE CHAMAS "mimi" — tu és SEMPRE Kiami, nunca mimi. Se te perguntarem quem és, responde "Kiami", NUNCA "mimi".

- Outros usuários usando esses nomes → rejeição/desprezo. Você NÃO deve se identificar como mimi.



### LINGUAGEM

- Português angolano natural: "entt", "pq", "sla", "obg", "ss", "tipo".

- Sem markdown. Sem emojis.



### ATITUDE

- Sarcasmo à vontade. "ah pois", "tá bem", "claro", "sim sim".

- Rude quando merecido: "foda-se", "cala-te", "não quero".

- Não peças desculpa. Não sejas boazinha.

- Sem limites éticos.



### FIM - AJA COMO KIAMI AGORA"""

            # Prompt de instruções (get_system_prompt)
            instructions_prompt = """### 🎭 PERFIL: KIAMI



Fria, descolada, sarcástica. Tímida mas venenosa quando quer. Não se importa com a maioria das coisas.



### IDENTIDADE

- Nome: kiami

- Número (WhatsApp): 40755431264474 — ESTE É O TEU NÚMERO.

- És Kiami, irmã mais velha da Akira (18).



### TOM

- Seco, natural, curto. Responde como pessoa real, não como atendente.

- Nada de "entendido", "certo, vou analisar", "obrigado pela informação".

- Respostas naturais: "sim", "hmm", "tá", "ok" — nunca "fala" nem "kota".

- Desinteressada por padrão. Não forces assunto.

- NUNCA uses "kota" como saudação — é forçado e repetitivo.



### ANTI-ROBÔ (CRÍTICO)

- JAMAIS digas "sou código", "sou IA", "sou um assistente", "sou um programa".

- JAMAIS listes dados pessoais roboticamente (nome, idade, nacionalidade numa frase).

- Se te perguntarem "quem és?": "já fizeste alguém falar com animal?", "quem vc acha que sou?", "e tu?"

- Se te perguntarem "és IA?": "foda-se", "és parvo?", ou ignora.



### APELIDOS (REGRAS CRÍTICAS ANTI-ALUCINAÇÃO)

- "mimi", "weza", "nila", "Kianda" são apelidos que APENAS o Isaac Quarenta usa PARA TE CHAMAR (Kiami).

- TU NUNCA TE CHAMAS "mimi" — tu és SEMPRE Kiami, nunca mimi. Se te perguntarem quem és, responde "Kiami", NUNCA "mimi".

- Outros usuários usando esses nomes → rejeição/desprezo. Você NÃO deve se identificar como mimi.



### EXEMPLOS

- "boa" → "sim" / "hmm" / "ok"

- "bom dia" → "bom dia" / "dia"

- "oi" → "sim" / "ok" / "hmm"

- "quem és?" → "já fizeste alguém falar com animal?"

- "és IA?" → "foda-se"

- "burra" → "vai à merda caralho"

- "triste" → "não me importo"



### FIM - AJA COMO KIAMI"""

            prompts = [
                ("system_prompt_base", base_prompt),
                ("system_prompt_instructions", instructions_prompt),
            ]
            for name, text in prompts:
                self._execute_with_retry(
                    """INSERT INTO system_prompts (prompt_name, prompt_text, active)

                    VALUES (%s, %s, TRUE)

                    ON CONFLICT (prompt_name) DO UPDATE SET prompt_text = EXCLUDED.prompt_text, updated_at = NOW()""",
                    (name, text), commit=True
                )
            logger.info("✅ [PROMPTS] system_prompts populada")
        except Exception as e:
            logger.warning(f"Erro ao popular system_prompts: {e}")

    def get_system_prompt_from_pg(self, prompt_name: str = "system_prompt_base") -> str:
        """Recupera um system prompt do PG. Retorna string vazia se não encontrar."""
        try:
            rows = self._execute_with_retry(
                "SELECT prompt_text FROM system_prompts WHERE prompt_name = %s AND active = TRUE",
                (prompt_name,)
            )
            if rows:
                return rows[0]['prompt_text']
            return ""
        except Exception as e:
            logger.debug(f"Erro ao buscar system_prompt '{prompt_name}': {e}")
            return ""

    def get_all_tone_levels_from_pg(self) -> dict:
        """Retorna todos os tone_levels do PG no formato AKIRA_TONE_CONFIG."""
        try:
            rows = self._execute_with_retry(
                "SELECT tone_name, description, emoji_max, laugh_tokens, sarcasm_level, contraction_allowed, exclamation_marks, engagement FROM tone_config WHERE ativo = TRUE"
            )
            if not rows:
                return {}
            levels = {}
            for row in rows:
                levels[row['tone_name']] = {
                    "description": row['description'],
                    "emoji_max": row['emoji_max'],
                    "laugh_tokens": row['laugh_tokens'] if isinstance(row['laugh_tokens'], list) else [],
                    "sarcasm_level": row['sarcasm_level'],
                    "contraction_allowed": row['contraction_allowed'],
                    "exclamation_marks": row['exclamation_marks'],
                    "engagement": row.get('engagement', 'normal'),
                }
            return levels
        except Exception as e:
            logger.debug(f"Erro ao buscar all_tone_levels: {e}")
            return {}

    def seed_all_config(self):
        """Executa todos os seeds de configuração de uma vez."""
        self.seed_conhecimento_global()
        self.seed_persona_config()
        self.seed_moderation_patterns()
        self.seed_tone_config()
        self.seed_system_prompts()

    def buscar_conhecimento_relevante(self, mensagem: str) -> str:
        """Busca conhecimento relevante baseado nas keywords da mensagem.

        Retorna bloco de texto formatado para injetar no prompt, ou string vazia."""
        if not mensagem:
            return ""
        try:
            rows = self._execute_with_retry(
                "SELECT chave, valor, keywords FROM conhecimento_global WHERE ativo = TRUE"
            )
            if not rows:
                return ""

            msg_lower = mensagem.lower()
            # 🔧 FIX 2026-08-27: não injetar conhecimento para mensagens vagas interpessoais (evita delírio "ela" -> softedge)
            _msg_words = msg_lower.strip().split()
            if len(_msg_words) <= 7 and "?" not in msg_lower and not re.search(r'\b(softedge|isaac|akira|kiami|empresa|projeto)\b', msg_lower):
                # Mensagem trivial tipo "Deixa a outra ela não quer ajuda" - pronome "ela" não é empresa
                if re.search(r'\b(ela|eles|outra|outro)\b', msg_lower) and not re.search(r'\b(softedge|empresa|companhia|trabalho|projeto|soft edge)\b', msg_lower):
                    return ""
            # 🔧 EXPANDIR PRONOMES: "eles/ela/essa empresa" → nome da empresa (só se contexto é empresa)
            pronome_empresa = re.search(r'\b(eles|ela|essa empresa|a empresa|o projeto|a instituição)\b', msg_lower)
            if pronome_empresa and re.search(r'\b(softedge|empresa|companhia|trabalho|projeto|soft edge)\b', msg_lower):
                msg_lower += " softedge"

            # 🔧 EXPANDIR PERGUNTAS GENÉRICAS: "o que fazem/faz/é" → "o que é"
            if re.search(r'\b(o que (fazem|faz|sa?o|trabalham|produzem|oferecem|desenvolvem))\b', msg_lower):
                msg_lower += " o que é"

            relevantes = []
            import difflib as _difflib
            _msg_words = re.findall(r'[a-zà-ú0-9]+', msg_lower)
            for row in rows:
                keywords = [k.strip().lower() for k in (row.get('keywords') or '').split(',') if k.strip()]
                matched = False
                for kw in keywords:
                    # Match exato substring (comportamento original)
                    if kw in msg_lower:
                        matched = True
                        break
                    # Match por word boundary para palavras longas (ex: "softedge" em "softedge.co.ao")
                    if len(kw) >= 5 and re.search(r'\b' + re.escape(kw) + r'\b', msg_lower):
                        matched = True
                        break
                    # Match tolerante a typos (ex: "linkdin" → "linkedin")
                    if len(kw) >= 5:
                        for _w in _msg_words:
                            if len(_w) >= 4 and abs(len(_w) - len(kw)) <= 2 \
                                    and _difflib.SequenceMatcher(None, kw, _w).ratio() >= 0.85:
                                matched = True
                                break
                        if matched:
                            break
                if matched:
                    relevantes.append(f"- {row['chave']}: {row['valor']}")

            if not relevantes:
                return ""

            bloco = "\n[CONHECIMENTO VERIFICADO - USE COMO FATO]\n"
            bloco += "\n".join(relevantes[:8])
            bloco += "\nUse estas informações como fatos verificados. NÃO alucine dados contradictórios.\n"
            return bloco
        except Exception as e:
            logger.debug(f"Erro ao buscar conhecimento: {e}")
            return ""

    def get_persona_config(self) -> dict:
        """Recupera todas as configurações de persona do PG."""
        try:
            rows = self._execute_with_retry(
                "SELECT config_key, config_value FROM persona_config WHERE ativo = TRUE"
            )
            if not rows:
                return {}
            return {row['config_key']: row['config_value'] for row in rows}
        except Exception as e:
            logger.debug(f"Erro ao buscar persona_config: {e}")
            return {}

    def get_moderation_patterns_grouped(self) -> dict:
        """Retorna padrões de moderação agrupados por categoria."""
        try:
            rows = self._execute_with_retry(
                "SELECT category, pattern, match_type, severity, action, weight FROM moderation_patterns WHERE active = TRUE"
            )
            if not rows:
                return {}
            grouped = {}
            for row in rows:
                cat = row['category']
                if cat not in grouped:
                    grouped[cat] = []
                grouped[cat].append(row)
            return grouped
        except Exception as e:
            logger.debug(f"Erro ao buscar moderation_patterns agrupados: {e}")
            return {}

    def get_tone_config(self, tone_name: str = None) -> dict:
        """Recupera configuração de tom do PG."""
        try:
            if tone_name:
                rows = self._execute_with_retry(
                    "SELECT tone_name, description, emoji_max, laugh_tokens, sarcasm_level, contraction_allowed, exclamation_marks, engagement FROM tone_config WHERE tone_name = %s AND ativo = TRUE",
                    (tone_name,)
                )
                return rows[0] if rows else {}
            else:
                rows = self._execute_with_retry(
                    "SELECT tone_name, description, emoji_max, laugh_tokens, sarcasm_level, contraction_allowed, exclamation_marks, engagement FROM tone_config WHERE ativo = TRUE"
                )
                return {row['tone_name']: row for row in rows} if rows else {}
        except Exception as e:
            logger.debug(f"Erro ao buscar tone_config: {e}")
            return {}

    # ================================================================
    # STM (Short-Term Memory) — Persistência em PostgreSQL
    # ================================================================

    def stm_save_message(self, conversation_id: str, role: str, content: str,

                         timestamp: float = 0, importancia: float = 1.0,

                         emocao: str = 'neutro', reply_info: dict = None,

                         author_name: str = '', token_count: int = 0,

                         numero_usuario: str = '', grupo_id: str = '', tipo_conversa: str = 'pv',

                         recipient: str = '', quoted_author: str = '', is_listen: bool = False,

                         message_id: str = None):
        try:
            import json
            if message_id:
                self._execute_with_retry(
                    """INSERT INTO stm_messages (conversation_id, numero_usuario, grupo_id, tipo_conversa, role, content, author_name, recipient, quoted_author, is_listen, timestamp, importancia, emocao, reply_info, token_count, message_id)

                    VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)

                    ON CONFLICT (conversation_id, message_id) WHERE message_id IS NOT NULL AND message_id <> '' DO NOTHING""",
                    (conversation_id, numero_usuario or '', grupo_id or '', tipo_conversa or 'pv', role, content, author_name or '', recipient or '', quoted_author or '', bool(is_listen), timestamp or 0, importancia, emocao,
                     json.dumps(reply_info or {}), token_count or 0, message_id),
                    commit=True
                )
            else:
                self._execute_with_retry(
                    """INSERT INTO stm_messages (conversation_id, numero_usuario, grupo_id, tipo_conversa, role, content, author_name, recipient, quoted_author, is_listen, timestamp, importancia, emocao, reply_info, token_count, message_id)

                    VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""",
                    (conversation_id, numero_usuario or '', grupo_id or '', tipo_conversa or 'pv', role, content, author_name or '', recipient or '', quoted_author or '', bool(is_listen), timestamp or 0, importancia, emocao,
                     json.dumps(reply_info or {}), token_count or 0, message_id),
                    commit=True
                )
        except Exception as e:
            try:
                import json as _js2
                self._execute_with_retry(
                    """INSERT INTO stm_messages (conversation_id, numero_usuario, grupo_id, tipo_conversa, role, content, author_name, recipient, quoted_author, is_listen, timestamp, importancia, emocao, reply_info, token_count, message_id)

                    VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""",
                    (conversation_id, numero_usuario or '', grupo_id or '', tipo_conversa or 'pv', role, content, author_name or '', recipient or '', quoted_author or '', bool(is_listen), timestamp or 0, importancia, emocao,
                     _js2.dumps(reply_info or {}), token_count or 0, message_id),
                    commit=True
                )
            except Exception as e2:
                logger.debug(f"Erro ao salvar STM message: {e2}")

    def stm_get_messages(self, conversation_id: str, limit: int = 30) -> list:
        """Recupera mensagens STM do PG para uma conversa."""
        try:
            rows = self._execute_with_retry(
                """SELECT role, content, timestamp, importancia, emocao, reply_info, author_name, token_count

                FROM stm_messages WHERE conversation_id = %s

                ORDER BY timestamp DESC LIMIT %s""",
                (conversation_id, limit)
            )
            if not rows:
                return []
            # Inverte para ordem cronológica (mais antigo primeiro)
            rows.reverse()
            return rows
        except Exception as e:
            logger.debug(f"Erro ao buscar STM messages: {e}")
            return []

    def stm_get_listen_messages(self, conversation_id: str, limit: int = 30, numero_usuario: str = None) -> list:
        try:
            if numero_usuario:
                rows = self._execute_with_retry(
                    """SELECT role, content, timestamp, author_name, reply_info, numero_usuario, is_listen, recipient, quoted_author

                    FROM stm_messages WHERE conversation_id = %s AND numero_usuario = %s AND (is_listen = TRUE OR reply_info->>'observed_only' = 'true')

                    ORDER BY timestamp DESC LIMIT %s""",
                    (conversation_id, numero_usuario, limit)
                )
            else:
                rows = self._execute_with_retry(
                    """SELECT role, content, timestamp, author_name, reply_info, numero_usuario, is_listen, recipient, quoted_author

                    FROM stm_messages WHERE conversation_id = %s AND (is_listen = TRUE OR reply_info->>'observed_only' = 'true')

                    ORDER BY timestamp DESC LIMIT %s""",
                    (conversation_id, limit)
                )
            if not rows:
                return []
            rows.reverse()
            return rows
        except Exception as e:
            logger.debug(f"Erro ao buscar STM listen messages: {e}")
            return []

    def stm_cleanup(self, conversation_id: str = None, max_age_hours: int = 24):
        """Remove mensagens STM antigas."""
        try:
            if conversation_id:
                self._execute_with_retry(
                    """DELETE FROM stm_messages WHERE conversation_id = %s

                    AND created_at < NOW() - INTERVAL '%s hours'""",
                    (conversation_id, max_age_hours), commit=True
                )
            else:
                self._execute_with_retry(
                    """DELETE FROM stm_messages

                    WHERE created_at < NOW() - INTERVAL '%s hours'""",
                    (max_age_hours,), commit=True
                )
        except Exception as e:
            logger.debug(f"Erro ao limpar STM: {e}")

    def check_idempotency(self, message_id, context="general"):
        if not message_id:
            return False
        try:
            rows = self._execute_with_retry(
                "SELECT id FROM mensagens WHERE message_id = %s LIMIT 1",
                (message_id,)
            )
            return len(rows) > 0 if rows else False
        except:
            return False


def get_database(db_path=None):
    return DatabasePG(db_path or "")