fix: mega-sweep - crash fixes, autonomous_agent TS, memory leaks, DB bugs

CRITICAL CRASH FIXES:
- api.py: raw_str NameError on doc/image messages (line 1964)
- api.py: media_response AttributeError when skill returns non-dict

AUTONOMOUS AGENT:
- LLM prompt said 'Akira' instead of 'Belmira' + wrong action names
- 'cu' substring matched 'cuidar','curta' (word boundary for short patterns)
- Belmira was moderating herself (self-check guard added)
- _action_log memory leak (capped at 500 entries)
- _spam_tracker memory leak (prune empty keys)
- JSON regex greedy match (use non-greedy [^{}]*)

DATABASE_PG:
- recuperar_humor queried 'humor' but column is 'humor_atual'
- isinstance(memoryview) missing second argument
- import fcntl crashed on Windows (graceful fallback)

BASE_SKILL:
- cache_ttl always ignored (_make_cache_key was popping it)

modules/api.py

@@ -1961,7 +1961,6 @@ class AkiraAPI:
                 _img_check = 'imagem' in data or 'imagem_dados' in data
                 if _doc_check or _img_check:
                     self.logger.info(f"[API] Campos recebidos: documento={_doc_check} | imagem={_img_check} | keys={list(data.keys())}")
-                    self.logger.warning(f"[API] Payload resultou em dicionário vazio. Bruto (latin-1): {raw_str[:200]}")
                 
                 usuario = data.get('usuario', 'anonimo')
                 numero = data.get('numero', '')
@@ -3014,53 +3013,62 @@ class AkiraAPI:
                         _user_jid = numero or usuario
                         _group_jid = grupo_id or ''
 
-                        # 0. Track flood/spam (detecção temporal de mensagens rápidas)
-                        _track_result = _autonomous_agent.track_message(
-                            user_jid=_user_jid,
-                            group_jid=_group_jid,
-                            message=mensagem
-                        )
-                        if _track_result and _track_result.get("type") == "remote_action":
-                            autonomous_actions.append(_track_result)
-                            self.logger.info(f"🤖 [AUTONOMOUS TRACK] Flood/spam detetado")
+                        # SKIP: Belmira não modera a ela mesma
+                        _bot_numero = str(getattr(self.config, 'BOT_NUMERO', '37839265886398'))
+                        _sender_pure = re.sub(r'\D', '', str(_user_jid))
+                        _bot_pure = re.sub(r'\D', '', _bot_numero)
+                        if _sender_pure and _bot_pure and _sender_pure == _bot_pure:
+                            pass  # Não moderar a própria Belmira
+                        elif str(_user_jid).startswith('BOT:'):
+                            pass  # Não moderar outros bots
+                        else:
+                            # 0. Track flood/spam (detecção temporal de mensagens rápidas)
+                            _track_result = _autonomous_agent.track_message(
+                                user_jid=_user_jid,
+                                group_jid=_group_jid,
+                                message=mensagem
+                            )
+                            if _track_result and _track_result.get("type") == "remote_action":
+                                autonomous_actions.append(_track_result)
+                                self.logger.info(f"🤖 [AUTONOMOUS TRACK] Flood/spam detetado")
 
-                        # 1. Análise de hostilidade para ações (mutar/banir/prevenir)
-                        action_analysis = _autonomous_agent.analyze_hostility_for_action(
-                            float(hostility_score), _user_jid, _group_jid
-                        )
-                        if action_analysis:
-                            autonomous_actions.append(action_analysis)
-                            _cmd = action_analysis.get('params', {}).get('cmd', '?')
-                            self.logger.info(f"🤖 [AUTONOMOUS] hostilidade → {_cmd}")
-
-                        # 2. Detecção de toxicidade (proatividade, sem mensagem hostil)
-                        toxicity_actions = _autonomous_agent.analyze_toxic_language(mensagem, _user_jid, _group_jid)
-                        if toxicity_actions:
-                            autonomous_actions.append(toxicity_actions)
-                            _cmd = toxicity_actions.get('params', {}).get('cmd', '?')
-                            self.logger.info(f"🤖 [AUTONOMOUS TOXIC] toxicidade → {_cmd}")
-
-                        # 3. Abuso de menção em massa
-                        mass_mention_actions = _autonomous_agent.analyze_mass_mention_abuse(mensagem, _user_jid, _group_jid)
-                        if mass_mention_actions:
-                            autonomous_actions.append(mass_mention_actions)
-                            _cmd = mass_mention_actions.get('params', {}).get('cmd', '?')
-                            self.logger.info(f"🤖 [AUTONOMOUS SPAM] menções → {_cmd}")
-
-                        # 4. Análise de conteúdo (links proibidos, ameaças, conteúdo ofensivo)
-                        content_actions = _autonomous_agent.analyze_message_for_moderation(mensagem, _user_jid, _group_jid)
-                        if content_actions:
-                            autonomous_actions.append(content_actions)
-                            self.logger.info(f"🤖 [AUTONOMOUS CONTENT] Violação de conteúdo detetada")
-
-                        # 5. Análise de imagem para NSFW/Gore (se houve análise visual)
-                        if analise_visao and isinstance(analise_visao, dict):
-                            img_desc = analise_visao.get('description', '')
-                            if img_desc:
-                                img_actions = _autonomous_agent.analyze_image_description_for_moderation(img_desc, _user_jid, _group_jid)
-                                if img_actions:
-                                    autonomous_actions.append(img_actions)
-                                    self.logger.info(f"🤖 [AUTONOMOUS VISUAL] Conteúdo proibido detetado na imagem")
+                            # 1. Análise de hostilidade para ações (mutar/banir/prevenir)
+                            action_analysis = _autonomous_agent.analyze_hostility_for_action(
+                                float(hostility_score), _user_jid, _group_jid
+                            )
+                            if action_analysis:
+                                autonomous_actions.append(action_analysis)
+                                _cmd = action_analysis.get('params', {}).get('cmd', '?')
+                                self.logger.info(f"🤖 [AUTONOMOUS] hostilidade → {_cmd}")
+
+                            # 2. Detecção de toxicidade (proatividade, sem mensagem hostil)
+                            toxicity_actions = _autonomous_agent.analyze_toxic_language(mensagem, _user_jid, _group_jid)
+                            if toxicity_actions:
+                                autonomous_actions.append(toxicity_actions)
+                                _cmd = toxicity_actions.get('params', {}).get('cmd', '?')
+                                self.logger.info(f"🤖 [AUTONOMOUS TOXIC] toxicidade → {_cmd}")
+
+                            # 3. Abuso de menção em massa
+                            mass_mention_actions = _autonomous_agent.analyze_mass_mention_abuse(mensagem, _user_jid, _group_jid)
+                            if mass_mention_actions:
+                                autonomous_actions.append(mass_mention_actions)
+                                _cmd = mass_mention_actions.get('params', {}).get('cmd', '?')
+                                self.logger.info(f"🤖 [AUTONOMOUS SPAM] menções → {_cmd}")
+
+                            # 4. Análise de conteúdo (links proibidos, ameaças, conteúdo ofensivo)
+                            content_actions = _autonomous_agent.analyze_message_for_moderation(mensagem, _user_jid, _group_jid)
+                            if content_actions:
+                                autonomous_actions.append(content_actions)
+                                self.logger.info(f"🤖 [AUTONOMOUS CONTENT] Violação de conteúdo detetada")
+
+                            # 5. Análise de imagem para NSFW/Gore (se houve análise visual)
+                            if analise_visao and isinstance(analise_visao, dict):
+                                img_desc = analise_visao.get('description', '')
+                                if img_desc:
+                                    img_actions = _autonomous_agent.analyze_image_description_for_moderation(img_desc, _user_jid, _group_jid)
+                                    if img_actions:
+                                        autonomous_actions.append(img_actions)
+                                        self.logger.info(f"🤖 [AUTONOMOUS VISUAL] Conteúdo proibido detetado na imagem")
                     except Exception as e:
                         self.logger.warning(f"⚠️ [AUTONOMOUS] Falha na análise: {e}")
 
@@ -4464,7 +4472,7 @@ class AkiraAPI:
                         self.logger.debug(f"   ℹ️ observation não é dict nem JSON string")
                     
                     # ✅ NOVO: Captura media_response se houver (para imagens geradas)
-                    if obs_data.get("media_response"):
+                    if obs_data.get("media_response") and isinstance(obs_data.get("media_response"), dict):
                         media_response = obs_data.get("media_response")
                         self.logger.info(f"📸 [MEDIA] Capturado media_response: tipo={media_response.get('tipo')}")
                     
@@ -4476,7 +4484,10 @@ class AkiraAPI:
                         remote_actions.append(obs_data)
                         observation = f"Ação remota '{obs_data.get('action')}' será executada pelo bot."
                     elif obs_data.get("type") == "media_response":
-                        media_response.update(obs_data)
+                        if media_response and isinstance(media_response, dict):
+                            media_response.update(obs_data)
+                        else:
+                            media_response = obs_data
                         observation = f"Mídia gerada com sucesso."
                     else:
                         observation = f"Resultado obtido com sucesso."

modules/database_pg.py

@@ -769,12 +769,12 @@ class DatabasePG:
     def recuperar_humor(self, numero_usuario):
         try:
             rows = self._execute_with_retry(
-                "SELECT humor FROM contexto WHERE user_key = %s",
+                "SELECT humor_atual FROM contexto WHERE user_key = %s",
                 (numero_usuario,)
             )
             if rows:
                 r = rows[0]
-                return r['humor'] if isinstance(r, dict) else r[0]
+                return r['humor_atual'] if isinstance(r, dict) else r[0]
             return "neutro"
         except:
             return "neutro"
@@ -915,7 +915,7 @@ class DatabasePG:
             results = []
             for r in rows:
                 emb = r['embedding']
-                if isinstance(memoryview):
+                if isinstance(emb, memoryview):
                     emb = bytes(emb)
                 results.append({
                     'source_type': r['source_type'],
@@ -1126,8 +1126,12 @@ class DatabasePG:
     def fazer_checkpoint_hf_sync(self):
         """Backup PostgreSQL via pg_dump com lock para evitar dupla execução entre workers."""
         import subprocess
-        import fcntl
         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)
@@ -1136,12 +1140,13 @@ class DatabasePG:
 
             # Lock file para garantir que apenas 1 worker executa pg_dump
             lock_fd = open(lock_path, 'w')
-            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
+            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
@@ -1160,7 +1165,8 @@ class DatabasePG:
                     logger.error(f"pg_dump falhou: {result.stderr}")
                     return False
             finally:
-                fcntl.flock(lock_fd, fcntl.LOCK_UN)
+                if fcntl:
+                    fcntl.flock(lock_fd, fcntl.LOCK_UN)
                 lock_fd.close()
         except Exception as e:
             logger.error(f"Erro no checkpoint: {e}")

modules/skills/autonomous_agent.py

@@ -74,6 +74,8 @@ class AutonomousAgent:
             ts for ts in self._spam_tracker[key] 
             if timestamp - ts <= 60
         ]
+        if not self._spam_tracker[key]:
+            del self._spam_tracker[key]
         
         # ─── Detecta Flood ───
         recent_flood = [ts for ts in self._spam_tracker[key] if timestamp - ts <= FLOOD_WINDOW_SECS]
@@ -238,8 +240,10 @@ class AutonomousAgent:
             "filho da mãe", "piriquito", "bosta", "merda", "fodasse",
             "vai te foder", "come merda", "peste", "lixo", "nojento", "nojenta",
             "desgraçado", "desgraçada", "maldito", "maldita", "cornos",
-            "cu", "buceta", "piranha", "vagabunda", "vagabundo"
+            "buceta", "piranha", "vagabunda", "vagabundo"
         ]
+        # Padrões curtos que precisam de word boundary para evitar falsos positivos
+        insult_patterns_boundary = ["cu"]
         
         # Padrões de ameaças de violência
         threat_patterns = [
@@ -252,7 +256,12 @@ class AutonomousAgent:
         ]
         
         # Conta insultos encontrados
+        import re
         insults_found = [p for p in insult_patterns if p in msg_lower]
+        # Padrões curtos: word boundary para evitar "cu" em "cuidar"
+        for p in insult_patterns_boundary:
+            if re.search(r'\b' + re.escape(p) + r'\b', msg_lower):
+                insults_found.append(p)
         threats_found = [p for p in threat_patterns if p in msg_lower]
         
         if threats_found:
@@ -389,6 +398,8 @@ class AutonomousAgent:
         if blacklist:
             log_entry["blacklist"] = True
         self._action_log.append(log_entry)
+        if len(self._action_log) > 500:
+            self._action_log = self._action_log[-500:]
         
         # Guarda no DB se disponível
         if self._db:
@@ -442,17 +453,17 @@ class AutonomousAgent:
             return None
         
         system = (
-            "És a Akira, agente autónoma de infraestrutura. "
+            "És a Belmira, agente autónoma de infraestrutura da Softedge. "
             "Analisa o evento abaixo e decide a melhor ação a tomar. "
             "Responde APENAS em JSON com: {\"acao\": \"string\", \"motivo\": \"string\", \"prioridade\": \"alta|media|baixa\"}. "
-            "Ações possíveis: mute_user, kick_user, lock_group, send_owner_report, ignore."
+            "Ações possíveis: mute, ban, warn, blacklist, ignore."
         )
         
         try:
             response = self._llm_caller(system, f"EVENTO: {event_type}\nCONTEXTO:\n{context}")
             # Extrai JSON da resposta
             import re
-            json_match = re.search(r'\{.*\}', response, re.DOTALL)
+            json_match = re.search(r'\{[^{}]*\}', response, re.DOTALL)
             if json_match:
                 return json.loads(json_match.group())
         except Exception as e:

modules/skills/base_skill.py

@@ -213,10 +213,7 @@ class BaseSkill(ABC):
     
     def _make_cache_key(self, *args, **kwargs) -> str:
         """Cria chave de cache baseada em argumentos"""
-        # Remove cache_ttl antes de processar
-        cache_ttl = kwargs.pop("cache_ttl", None)
-        
-        # Serializa argumentos
+        # Não remove cache_ttl — é preservado para uso externo
         key_str = f"{self.name}:{json.dumps([args, kwargs], sort_keys=True, default=str)}"
         return hashlib.md5(key_str.encode()).hexdigest()