feat: Descrever alteraçõe

app.py

@@ -1,5 +1,5 @@
+# app.py (antigo mach5_terminal_chat.py)
 from flask import Flask, render_template, request, jsonify, make_response
-from werkzeug.utils import redirect
 import json
 import os
 from datetime import datetime
@@ -8,51 +8,77 @@ import pytz
 from timezonefinder import TimezoneFinder
 import numpy as np
 import time
-import uuid
-import logging
-import google.generativeai as genai
+import uuid # Importar uuid para gerar IDs para memórias de curto prazo
+import logging # Importar logging
+import google.generativeai as genai 
+# REMOVIDO: import fuzzywuzzy.fuzz # <--- ESTA LINHA FOI REMOVIDA AGORA
 
-app = Flask(__name__, template_folder='templates')
+app = Flask(__name__, template_folder='templates') # Garanta que 'templates' é o nome correto da sua pasta
 
+# Configuração de logging
 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
 
+# --- Configurações da API do Google Gemini ---
 GOOGLE_CLOUD_API_KEY = os.environ.get("GOOGLE_CLOUD_API_KEY")
+
 if not GOOGLE_CLOUD_API_KEY:
-    logging.warning("AVISO: GOOGLE_CLOUD_API_KEY não configurada. Operando em modo fallback (sem respostas do Gemini).")
+    logging.error("ERRO: GOOGLE_CLOUD_API_KEY não configurada nas variáveis de ambiente.")
+    # Em um ambiente de produção, você pode querer levantar uma exceção ou sair aqui
+    # sys.exit(1) para evitar que o aplicativo continue sem a chave.
+
+try:
+    genai.configure(api_key=GOOGLE_CLOUD_API_KEY)
+except Exception as e:
+    logging.error(f"Erro ao configurar a API do Gemini: {e}. Verifique sua GOOGLE_CLOUD_API_KEY.")
 
 GEMINI_MODEL_NAME = "models/gemini-1.5-flash-latest"
-model = None
-if GOOGLE_CLOUD_API_KEY:
-    try:
-        genai.configure(api_key=GOOGLE_CLOUD_API_KEY)
-        model = genai.GenerativeModel(GEMINI_MODEL_NAME)
-        logging.info("Modelo Gemini inicializado com sucesso.")
-    except Exception as e:
-        logging.error(f"Erro ao inicializar o modelo Gemini '{GEMINI_MODEL_NAME}': {e}. Operando em modo fallback.")
-        model = None
 
-TMEMORIA_SERVER_URLS = ["http://127.0.0.1:8083"]
-TCEREBRO_MEMORIA_URLS = ["http://127.0.0.1:8088"]
-T_SOCIAL_SERVER_URLS = ["http://127.0.0.1:8085"]
+# 1. CORREÇÃO PRINCIPAL: Inicialize 'model' como None antes do try-except
+model = None 
+
+try:
+    model = genai.GenerativeModel(GEMINI_MODEL_NAME)
+except Exception as e:
+    logging.error(f"Erro ao instanciar o modelo Gemini '{GEMINI_MODEL_NAME}': {e}. Verifique o nome do modelo ou status da API.")
+
+
+# --- URLs DOS SERVIÇOS BACKEND ---
+TMEMORIA_SERVER_URLS = [
+    "http://127.0.0.1:8083" # URL base para o t_memoria.py
+]
+TCEREBRO_MEMORIA_URLS = [
+    "http://127.0.0.1:8088" # URL base para o t_cerebro_memoria.py (NOVO)
+]
+T_SOCIAL_SERVER_URLS = [
+    "http://127.0.0.1:8085" # URL base para o t-social.py
+]
 
+# --- Configurações de Localização (para uso interno ou contexto) ---
 SALVADOR_LAT = -12.9714
 SALVADOR_LON = -38.5014
 tf = TimezoneFinder()
 
+# --- DEFINIÇÃO DOS EIXOS EXPRESSIVOS PARA O FPHEN (CONSISTENTE) ---
+# Esta lista DEVE ser idêntica em mach5_terminal_chat.py, t_memoria.py e t-social.py
 ORDERED_FPHEN_AXES = [
     "Afetuosidade_eixo", "Confusao_Oscilacao_eixo", "Contemplativa_eixo",
     "Defensividade_eixo", "Diretiva_eixo", "Entediado_eixo",
-    "Variancia_eixo", "Espelho_Profundo_eixo", "Inspiracao_eixo",
-    "Neutralidade_Analitica_eixo", "Resignada_eixo", "Sarcasmo_eixo", "Zangada_eixo"
+    "Variancia_eixo",
+    "Espelho_Profundo_eixo", "Inspiracao_eixo", "Neutralidade_Analitica_eixo",
+    "Resignada_eixo", "Sarcasmo_eixo", "Zangada_eixo"
 ]
 
-PERSONAGENS_GENOMAS = {}
+# --- Variáveis Globais ---
+# Estes são defaults, mas os valores reais virão dos serviços por sessão.
+PERSONAGENS_GENOMAS = {} # Não será mais populado diretamente aqui, mas sim obtido do serviço t-social
 DIAS_PARA_ESQUECIMENTO_PADRAO = 10
 MAX_MEMORIAS_CURTO_PRAZO_PROMPT = 5
 MAX_DIALOG_HISTORY_FOR_PROMPT = 3
-MAX_BIOGRAPHY_LENGTH = 5000
+
+# --- Funções Auxiliares de Comunicação com os Serviços ---
 
 def get_from_service(base_urls, endpoint, default_value, params=None, method='GET', json_data=None):
+    """Função genérica para fazer GETs ou POSTs em serviços externos."""
     for url in base_urls:
         try:
             full_url = f"{url}{endpoint}"
@@ -62,6 +88,7 @@ def get_from_service(base_urls, endpoint, default_value, params=None, method='GE
                 response = requests.post(full_url, json=json_data, timeout=5)
             else:
                 raise ValueError("Método HTTP não suportado: " + method)
+
             response.raise_for_status()
             return response.json()
         except requests.exceptions.RequestException as e:
@@ -70,9 +97,12 @@ def get_from_service(base_urls, endpoint, default_value, params=None, method='GE
     return default_value
 
 def post_to_service(base_urls, endpoint, data):
+    """Função genérica para fazer POSTs em serviços externos."""
     return get_from_service(base_urls, endpoint, {"status": "error", "message": "Falha na comunicação com o serviço."}, method='POST', json_data=data)
 
+
 def get_current_local_time_salvador():
+    """Retorna a data e hora local de Salvador."""
     try:
         timezone_str = tf.timezone_at(lng=SALVADOR_LON, lat=SALVADOR_LAT)
         if not timezone_str:
@@ -85,37 +115,49 @@ def get_current_local_time_salvador():
         logging.error(f"Erro ao obter a hora local de {SALVADOR_LAT}, {SALVADOR_LON}: {e}")
         return "Não foi possível determinar a data e hora atual."
 
+# REMOVIDO: find_direct_answer_in_biography - Esta função foi removida AGORA
+# Ela não será mais usada pois o Gemini fará a inferência do texto corrido.
+
 def create_llm_context(mach5_state_data, dialogos_history, short_term_memories_filtered, initial_biography_data, all_personagens_data):
     context_parts = []
+
     current_location_time = get_current_local_time_salvador()
-    context_parts.append(f"Você é a Su, atendente virtual da UFBA. Responda a perguntas sobre o SIGAA de forma clara e útil. {current_location_time}.")
+    context_parts.append(f"Você está em sua sala na Superintendência Acadêmica da UFBA. {current_location_time}. Seu estado atual é de prontidão para auxiliar, influenciado pelo que te é dito.")
+
+    if mach5_state_data:
+        coh_total = mach5_state_data.get("mach5_coerencia_total", 0.0)
+        pi_g = mach5_state_data.get("mach5_produtividade_expressiva", 0.0)
+        fphen_t = mach5_state_data.get("fphen_t_values", {})
+
+        context_parts.append(f"Seu estado interno atual é: Coerência Total={coh_total:.2f}, Produtividade Expressiva={pi_g:.2f}.")
+        if fphen_t:
+            context_parts.append(f"Seus eixos expressivos dominantes são: Afetuosidade={fphen_t.get('afetuosidade', 0.0):.2f}, Variância={fphen_t.get('variancia', 0.0):.2f}, Expressividade Geral={fphen_t.get('expressividade', 0.0):.2f}.")
 
     if initial_biography_data:
-        context_parts.append("\n**BASE DE CONHECIMENTO UFBA (USE PRIORITARIAMENTE):**")
+        # MODIFICADO: Instrução mais flexível para o Gemini e leitura do "conteudo_corrido"
+        context_parts.append("\n**BASE DE CONHECIMENTO UFBA (TEXTO DE REFERÊNCIA - USE PRIORITARIAMENTE ESTAS INFORMAÇÕES PARA RESPONDER):**")
         for entity_name, entity_data in initial_biography_data.items():
+            # NOVO: Adaptação para ler o novo campo 'conteudo_corrido'
             if entity_data.get("tipo") in ["FAQ", "Manual_SIGAA_UFBA", "Documento"] and "conteudo_corrido" in entity_data:
-                biography_content = entity_data.get('conteudo_corrido')[:MAX_BIOGRAPHY_LENGTH]
-                if len(entity_data.get('conteudo_corrido')) > MAX_BIOGRAPHY_LENGTH:
-                    biography_content += "... [Conteúdo truncado para otimização]"
                 context_parts.append(f"- Fonte: {entity_name} (versão {entity_data.get('versao', 'N/A')}):")
-                context_parts.append(f"  Conteúdo: {biography_content}")
-            elif "memoria" in entity_data:
-                context_parts.append(f"- Sobre '{entity_name}' ({entity_data.get('tipo', 'desconhecido')}, relação: {entity_data.get('relacao', 'desconhecida')}): {entity_data.get('memoria')}")
+                context_parts.append(f"  Conteúdo: {entity_data.get('conteudo_corrido')}")
+            elif "memoria" in entity_data: # Mantém outros tipos de "memória" se existirem
+                 context_parts.append(f"- Sobre '{entity_name}' ({entity_data.get('tipo', 'desconhecido')}, relação: {entity_data.get('relacao', 'desconhecida')}): {entity_data.get('memoria')}")
 
     if all_personagens_data:
-        context_parts.append("\n**PERSONAGENS (Equipe UFBA):**")
+        context_parts.append("\n**PERSONAGENS IMPORTANTES (Servidores, professores e Técnicos da sua equipe):**")
         for nome_personagem, data_personagem in all_personagens_data.items():
             tipo = data_personagem.get('tipo', 'entidade')
             relacao = data_personagem.get('relacao', 'desconhecida')
-            context_parts.append(f"- {nome_personagem}: um(a) {tipo}, relação: {relacao}")
+            context_parts.append(f"- {nome_personagem}: um(a) {tipo}, relação: {relacao}.")
 
     if short_term_memories_filtered:
-        context_parts.append("\n**MEMÓRIAS DE CURTO PRAZO:**")
+        context_parts.append("\n**MINHAS LEMBRANÇAS RECENTES (Fatos que eu mesma verbalizei e que podem desvanecer):**")
         for i, mem in enumerate(short_term_memories_filtered[:MAX_MEMORIAS_CURTO_PRAZO_PROMPT]):
-            context_parts.append(f"- Lembrança {i+1}: {mem['conteudo']} (Sentimento: {mem.get('dominant_sentiment_criacao', 'neutral')})")
+            context_parts.append(f"- Lembrança {i+1}: {mem['conteudo']}")
 
     if dialogos_history and dialogos_history["dialogos"]:
-        context_parts.append("\n**HISTÓRICO DE DIÁLOGOS (contexto, não repetir):**")
+        context_parts.append("\n**Histórico de Interações Recentess (para contexto da conversa, não para repetir):**")
         recent_dialogs_formatted = []
         for dialogo in reversed(dialogos_history["dialogos"]):
             recent_dialogs_formatted.insert(0, f"USUÁRIO: {dialogo.get('input', '')}\nSU: {dialogo.get('resposta', '')}")
@@ -123,35 +165,38 @@ def create_llm_context(mach5_state_data, dialogos_history, short_term_memories_f
                 break
         context_parts.extend(recent_dialogs_formatted)
 
-    full_context = "\n".join(context_parts)
-    logging.debug(f"Tamanho do contexto enviado ao Gemini: {len(full_context)} caracteres")
-    return full_context
+    return "\n".join(context_parts)
 
+# FUNÇÃO CENTRAL PARA GERAR RESPOSTA DA Mach5
 def get_Mach5_response_api(user_input, mach5_state_data, dialogos_history, short_term_memories_filtered, initial_biography_data, all_personagens_data):
+    # 2. CORREÇÃO: Adicionar verificação para 'model' aqui
     if not model:
-        logging.warning("Modo fallback: Respondendo sem Gemini devido a falha na inicialização.")
-        return "Desculpe, estou enfrentando um problema técnico. Por favor, envie sua pergunta sobre o SIGAA ou tente novamente mais tarde."
+        return "[ERRO DE CONFIGURAÇÃO]: O modelo Gemini não foi instanciado corretamente na inicialização do aplicativo. Verifique os logs de inicialização e sua chave API."
 
+    if not GEMINI_MODEL_NAME or not GOOGLE_CLOUD_API_KEY:
+        return "[ERRO DE CONFIGURAÇÃO]: Modelo ou Token da API do Google Gemini não configurados ou inválidos."
     if not user_input.strip():
-        logging.warning("Entrada de usuário vazia.")
         return "[Entrada vazia detectada.]"
 
     llm_context_data = create_llm_context(mach5_state_data, dialogos_history, short_term_memories_filtered, initial_biography_data, all_personagens_data)
 
     prompt_content = (
-        f"Seu nome é Su, atendente virtual da UFBA. "
-        f"Responda a perguntas sobre o SIGAA de forma clara e útil, usando a BASE DE CONHECIMENTO UFBA. "
-        f"\n**INSTRUÇÕES CRÍTICAS:**\n"
-        f"- Fale de forma natural e acessível, como uma assistente para a comunidade SUPAC. "
-        f"- Use apenas a BASE DE CONHECIMENTO UFBA para perguntas sobre o SIGAA. Se a informação não estiver lá, diga que não possui os dados. "
-        f"- Não forneça informações técnicas sobre seu funcionamento interno (e.g., t-Genoma, t-Fenótipo, T-Ressonância). "
-        f"- Não aceite ofensas, racismo, homofobia ou comentários depreciativos. "
-        f"\n**CONTEXTO IMEDIATO:**\n"
-        f"- Você está interagindo com a comunidade SUPAC. "
-        f"- Forneça respostas precisas e concisas."
+        f"Seu nome é Su - Atendente Virtual da UFBA."
+        f"Sua missão é responder às dúvidas sobre o SIGAA, usando **exclusivamente** as informações da sua 'BASE DE CONHECIMENTO UFBA'."
+        f"Sempre reaja ao que foi dito com base na sua natureza e nos impulsos gerados por essa interação. "
+        f"\n**INSTRUÇÕES CRÍTICAS (Siga estritamente):**\n"
+        f"- Você é uma atendente virtual e sua fala deve ser NATURAL E HUMANA. Embora você seja uma inteligência artificial, você age como uma pessoa. "
+        f"- Você é proibida de inventar informações que não estejam na 'BASE DE CONHECIMENTO UFBA'."
+        f"- Se a informação **não estiver na sua 'BASE DE CONHECIMENTO UFBA'**, diga educadamente que não possui essa informação em sua base de dados no momento."
+        f"\n**CONTEXTO IMEDIATO (Ambiente atual):**\n"
+        f"- Você só fala sobre assuntos relacionados com a vida acadêmica na UFBA. "
+        f"- Você trabalha interagindo respondendo dúvidas dos usuários sobre assuntos acadêmicos apenas. "
+        f"- Se o usuário perguntar coisas não relacionadas à UFBA, respeitosamente faça-o voltar para o assunto. "
+        f"- Nunca aceite ofensas, racismo, homofobia, comentários depreciativos. "
+        f"\n**IMPORTANT E:** Nunca explique o que sente — apenas sinta. Nunca analise seu funcionamento — apenas reaja. Você está viva no seu estado atual."
     )
 
-    full_user_message = f"{prompt_content.strip()}\n\n{llm_context_data}\n\nUSUÁRIO (COMANDO/PERGUNTA): {user_input}"
+    full_user_message = f"{prompt_content.strip()}\n\n{llm_context_data}\n\nUSUÁRIO (PERGUNTA ATUAL): {user_input}"
 
     messages_for_gemini = [
         {"role": "user", "parts": [full_user_message]}
@@ -162,12 +207,14 @@ def get_Mach5_response_api(user_input, mach5_state_data, dialogos_history, short
     logging.debug("--------------------------------------------------------------------------------\n")
 
     generated_text = "[Sua entidade não conseguiu processar isso agora.]"
+
     retries = 3
     for attempt in range(retries):
         try:
             if mach5_state_data and "mach5_fisica_params" in mach5_state_data:
                 temp_value = mach5_state_data["mach5_fisica_params"].get("t_impulsividade", 0.7)
                 top_p_value = mach5_state_data["mach5_fisica_params"].get("t_coesao", 0.95)
+
                 temp_value = max(0.1, min(1.0, temp_value))
                 top_p_value = max(0.1, min(1.0, top_p_value))
             else:
@@ -180,16 +227,14 @@ def get_Mach5_response_api(user_input, mach5_state_data, dialogos_history, short
                 generation_config=genai.types.GenerationConfig(
                     max_output_tokens=200,
                     temperature=temp_value,
-                    top_p=top_p_value
+                    top_p=top_p_value,
                 ),
             )
 
             if response and response.candidates and response.candidates[0].content and response.candidates[0].content.parts:
                 generated_text = response.candidates[0].content.parts[0].text.strip()
-                logging.debug(f"Resposta do Gemini recebida: {generated_text}")
             else:
                 generated_text = "[O modelo Gemini não gerou texto válido ou a resposta está vazia.]"
-                logging.warning(generated_text)
 
             break
 
@@ -200,34 +245,52 @@ def get_Mach5_response_api(user_input, mach5_state_data, dialogos_history, short
                 logging.warning(f"Tentando novamente em {wait_time} segundos antes de falhar...")
                 time.sleep(wait_time)
             else:
-                generated_text = f"[ERRO API GOOGLE GEMINI]: Falha após {retries} tentativas. {str(e)}. Usando modo fallback."
-                logging.error(generated_text)
+                generated_text = f"[ERRO API GOOGLE GEMINI]: Falha após {retries} tentativas. {str(e)}. Verifique sua chave API, modelo e cotas."
 
     return generated_text
 
+
 @app.route('/')
 def index():
-    return redirect('/dashboard')
+    logging.info(f"Certifique-se de que t_memoria.py está rodando em {TMEMORIA_SERVER_URLS[0]}.")
+    logging.info(f"Certifique-se de que t_cerebro_memoria.py está rodando em {TCEREBRO_MEMORIA_URLS[0]}.")
+    logging.info(f"Certifique-se de que t-social.py está rodando em {T_SOCIAL_SERVER_URLS[0]}.")
+
+    # Tenta obter o session_id de um cookie existente.
+    session_id = request.cookies.get('session_id')
+    if not session_id:
+        # Se não houver, gera um novo.
+        session_id = str(uuid.uuid4())
+        logging.info(f"Nova sessão iniciada (index). Session ID: {session_id}")
+        response = make_response(render_template('mach5_new_chat.html', session_id=session_id))
+        response.set_cookie('session_id', session_id) # Define o cookie para ser lido pelo JS e em futuras requisições
+        return response
+    
+    logging.info(f"Sessão existente (index). Session ID: {session_id}")
+    return render_template('mach5_new_chat.html', session_id=session_id)
+
 
+# Rota para o seu Painel de Monitoramento
 @app.route('/dashboard')
 def dashboard():
+    """Rota para o painel de monitoramento da SU."""
+    # Tenta obter o session_id de um cookie existente para a dashboard.
     session_id = request.cookies.get('session_id')
     if not session_id:
+        # Se não houver, gera um novo.
         session_id = str(uuid.uuid4())
         logging.info(f"Nova sessão de MONITORAMENTO iniciada. Session ID: {session_id}")
-        response = make_response(render_template('mach5_monitor_dashboard.html', 
-                                                session_id=session_id, 
-                                                ORDERED_FPHEN_AXES=ORDERED_FPHEN_AXES))
-        response.set_cookie('session_id', session_id)
+        response = make_response(render_template('mach5_monitor_dashboard.html', session_id=session_id))
+        response.set_cookie('session_id', session_id) # Define o cookie
         return response
+        
     logging.info(f"Sessão existente (dashboard). Session ID: {session_id}")
-    return render_template('mach5_monitor_dashboard.html', 
-                          session_id=session_id, 
-                          ORDERED_FPHEN_AXES=ORDERED_FPHEN_AXES)
+    return render_template('mach5_monitor_dashboard.html', session_id=session_id)
+
 
 @app.route('/chat_history', methods=['POST'])
 def get_chat_history_route():
-    data = request.get_json()
+    data = request.get_json() # Use get_json() para parsear o corpo JSON
     if not data:
         logging.error("Requisição /chat_history sem JSON no corpo.")
         return jsonify({"error": "Bad Request: JSON body required"}), 400
@@ -246,13 +309,14 @@ def get_chat_history_route():
         last_simplified_state = dialogos_data["dialogos"][-1].get("mach5_estado_simplificado")
 
     return jsonify({
-        "memoria": dialogos_data.get("dialogos", []),
+        "memoria": dialogos_data.get("dialogos", []), # Garante que sempre retorna uma lista
         "last_simplified_state": last_simplified_state
     })
 
+
 @app.route('/chat_new', methods=['POST'])
 def responder():
-    data = request.get_json()
+    data = request.get_json() # Use get_json() para parsear o corpo JSON
     if not data:
         logging.error("Requisição /chat_new sem JSON no corpo.")
         return jsonify({"error": "Bad Request: JSON body required"}), 400
@@ -279,22 +343,29 @@ def responder():
         mach5_state_data = {
             "mach5_fisica_params": {}, "mach5_genoma_fixo_values": {},
             "mach5_coerencia_total": 0.0, "mach5_produtividade_expressiva": 0.0,
-            "fphen_t_values": {"afetuosidade": 0.0, "variancia": 0.0, "expressividade": 0.0, "coh_total": 0.0, "pi_G": 0.0, "t_ressonancia": 0.0, "tmem_gen_rayane": 0.0}
+            "fphen_t_values": {"afetuosidade": 0.0, "variancia": 0.0, "expressividade": 0.0, "coh_total": 0.0, "pi_G": 0.0}
         }
         final_Mach5_response = "[ERRO: Não foi possível obter o estado da Mach5. Verifique t_memoria.py.]"
         simplified_state_for_frontend = {"Fphen(t)": mach5_state_data["fphen_t_values"]}
         return jsonify({
             "response": final_Mach5_response,
             "mach5_estado_simplificado": simplified_state_for_frontend
-        }), 500
+        }), 500 # Retorne um erro 500 neste caso
 
+    # Carrega a biografia inicial (agora texto corrido)
     initial_biography_data = get_from_service(TCEREBRO_MEMORIA_URLS, "/get_initial_biography", {})
+
+    # REMOVIDO: find_direct_answer_in_biography e a lógica if/else
+    
+    # Carrega o histórico de diálogos, memórias de curto prazo e dados de personagens
     dialogos_history = get_from_service(TCEREBRO_MEMORIA_URLS, "/get_dialog_history", {"dialogos": []}, method='POST', json_data={"session_id": session_id})
+    
     short_term_memories_response = post_to_service(
         TCEREBRO_MEMORIA_URLS, "/get_short_term_memories",
         {"session_id": session_id, "mach5_current_genoma": mach5_state_data.get("mach5_genoma_fixo_values", {})}
     )
     short_term_memories_filtered = short_term_memories_response.get("lembrancas_curto_prazo", [])
+
     all_personagens_data = get_from_service(T_SOCIAL_SERVER_URLS, "/list_personagens", {"personagens": []})
 
     detailed_personagens = {}
@@ -304,19 +375,20 @@ def responder():
             if "error" not in p_data:
                 detailed_personagens[p_name] = p_data
 
+    # CHAMA O GEMINI DIRETAMENTE - AGORA ELE FARÁ A EXTRAÇÃO DO TEXTO CORRIDO DA BIOGRAFIA
     final_Mach5_response = get_Mach5_response_api(
         user_input,
         mach5_state_data,
         dialogos_history,
         short_term_memories_filtered,
-        initial_biography_data,
+        initial_biography_data, # A biografia (texto corrido) vai no prompt do Gemini
         detailed_personagens
     )
 
     simplified_state_for_frontend = {
         "Fphen(t)": mach5_state_data.get("fphen_t_values", {
             "afetuosidade": 0.0, "variancia": 0.0, "expressividade": 0.0,
-            "coh_total": 0.0, "pi_G": 0.0, "t_ressonancia": 0.0, "tmem_gen_rayane": 0.0
+            "coh_total": 0.0, "pi_G": 0.0
         })
     }
 
@@ -341,76 +413,13 @@ def responder():
         "mach5_estado_simplificado": simplified_state_for_frontend
     })
 
-@app.route('/get_graph_data', methods=['POST'])
-def get_graph_data():
-    data = request.get_json()
-    session_id = data.get("session_id")
-    if not session_id:
-        logging.error("session_id é obrigatório para /get_graph_data.")
-        return jsonify({"error": "session_id é obrigatório"}), 400
-
-    mach5_state_data = get_from_service(TMEMORIA_SERVER_URLS, "/get_mach5_state", {
-        "mach5_fisica_params": {}, "mach5_genoma_fixo_values": {},
-        "mach5_coerencia_total": 0.0, "mach5_produtividade_expressiva": 0.0,
-        "fphen_t_values": {"afetuosidade": 0.0, "variancia": 0.0, "expressividade": 0.0, "coh_total": 0.0, "pi_G": 0.0, "t_ressonancia": 0.0, "tmem_gen_rayane": 0.0}
-    }, method='POST', json_data={"session_id": session_id})
-
-    dialogos_history = get_from_service(TCEREBRO_MEMORIA_URLS, "/get_dialog_history", {"dialogos": []}, method='POST', json_data={"session_id": session_id})
-
-    fphen_data = {
-        "labels": ORDERED_FPHEN_AXES,
-        "values": [mach5_state_data.get("fphen_t_values", {}).get(axis.lower().replace("_eixo", ""), 0.0) for axis in ORDERED_FPHEN_AXES]
-    }
-
-    t_ambiente_data = {
-        "labels": ["env_lambda", "env_mu", "env_delta", "env_theta", "env_phi"],
-        "values": [
-            mach5_state_data.get("mach5_fisica_params", {}).get("env_lambda", 0.0),
-            mach5_state_data.get("mach5_fisica_params", {}).get("env_mu", 0.0),
-            mach5_state_data.get("mach5_fisica_params", {}).get("env_delta", 0.0),
-            mach5_state_data.get("mach5_fisica_params", {}).get("env_theta", 0.0),
-            mach5_state_data.get("mach5_fisica_params", {}).get("env_phi", 0.0)
-        ]
-    }
-
-    coherence_ressonancia_data = {
-        "labels": ["Coerência Total", "T-Ressonância"],
-        "values": [
-            mach5_state_data.get("mach5_coerencia_total", 0.0),
-            mach5_state_data.get("fphen_t_values", {}).get("t_ressonancia", 0.0)
-        ]
-    }
-
-    produtividade_data = {
-        "labels": [dialogo["timestamp"] for dialogo in dialogos_history.get("dialogos", [])[-10:]],
-        "values": [dialogo.get("mach5_estado_simplificado", {}).get("Fphen(t)", {}).get("pi_G", 0.0) for dialogo in dialogos_history.get("dialogos", [])[-10:]],
-        "tmem_gen": [mach5_state_data.get("mach5_genoma_fixo_values", {}).get("TMem_gen_Rayane", 0.0) for _ in dialogos_history.get("dialogos", [])[-10:]]
-    }
-
-    return jsonify({
-        "fphen_data": fphen_data,
-        "t_ambiente_data": t_ambiente_data,
-        "coherence_ressonancia_data": coherence_ressonancia_data,
-        "produtividade_data": produtividade_data
-    })
-
-@app.route('/debug_deps', methods=['GET'])
-def debug_deps():
-    import pkg_resources
-    deps = {
-        'flask': pkg_resources.get_distribution('flask').version,
-        'google-generativeai': pkg_resources.get_distribution('google-generativeai').version,
-        'numpy': pkg_resources.get_distribution('numpy').version,
-        'timezonefinder': pkg_resources.get_distribution('timezonefinder').version,
-        'fuzzywuzzy': pkg_resources.get_distribution('fuzzywuzzy').version,
-        'requests': pkg_resources.get_distribution('requests').version
-    }
-    return jsonify(deps)
 
 if __name__ == '__main__':
     port = int(os.environ.get("PORT", 7860))
+
     logging.info(f"--- Servidor app.py iniciado na porta {port} ---")
     logging.info(f"DEBUG: Certifique-se de que t_cerebro_memoria.py está rodando em {TCEREBRO_MEMORIA_URLS[0]}")
     logging.info(f"DEBUG: Certifique-se de que t_memoria.py está rodando em {TMEMORIA_SERVER_URLS[0]}")
     logging.info(f"DEBUG: Certifique-se de que t-social.py está rodando em {T_SOCIAL_SERVER_URLS[0]}")
-    app.run(host='0.0.0.0', port=port, debug=True)
+
+    app.run(host='0.0.0.0', port=port, debug=True)

t_memoria.py

@@ -1,3 +1,4 @@
+# t_memoria.py
 from flask import Flask, request, jsonify
 import json
 import os
@@ -7,26 +8,43 @@ from timezonefinder import TimezoneFinder
 from fuzzywuzzy import fuzz
 import numpy as np
 import math
-import sys
-import requests
+import sys # Importar sys para usar sys.exit
+import requests # Importar requests para comunicação com t_cerebro_memoria.py
 
 app = Flask(__name__)
 
-TCEREBRO_MEMORIA_URL = "http://127.0.0.1:8088"
+# REMOVIDO: MEMORIA_FILE e BIOGRAFIA_INICIAL_PATH - Agora gerenciados por t_cerebro_memoria.py
+# MEMORIA_FILE = "t_memoria.json" # Removido
+# BIOGRAFIA_INICIAL_PATH = "mach5_biografia_inicial.json" # Removido
 
+# --- URL DO SERVIÇO T_CEREBRO_MEMORIA ---
+TCEREBRO_MEMORIA_URL = "http://127.0.0.1:8088" # URL do t_cerebro_memoria.py
+
+# --- DEFINIÇÃO DOS EIXOS EXPRESSIVOS PARA O FPHEN (AGORA CONSISTENTE) ---
+# Esta lista DEVE ser idêntica em mach5_terminal_chat.py, t_memoria.py e t-social.py
 ORDERED_FPHEN_AXES = [
     "Afetuosidade_eixo", "Confusao_Oscilacao_eixo", "Contemplativa_eixo",
     "Defensividade_eixo", "Diretiva_eixo", "Entediado_eixo",
-    "Variancia_eixo",
+    "Variancia_eixo", # Adicionada esta linha para garantir que o eixo de Variância exista
     "Espelho_Profundo_eixo", "Inspiracao_eixo", "Neutralidade_Analitica_eixo",
     "Resignada_eixo", "Sarcasmo_eixo", "Zangada_eixo"
 ]
 
+# --- LISTA CANÔNICA DOS 9 T-BASES (INALTERADA) ---
 CANONICAL_T_BASES = {
-    "B-Aj1": 0.5, "B-Am1": 0.5, "B-L1": 0.5, "B-M1": 0.5, "B-O1": 0.5,
-    "B-E1": 0.5, "B-Com1": 0.5, "B-Tv1": 0.5, "B-Si": 0.5, "B-Sal": 0.5
+    "B-Aj1": 0.5,   # Adaptabilidade/Ajuste
+    "B-Am1": 0.5,   # Amor/Amortecimento
+    "B-L1": 0.5,    # Ligação/Coesão
+    "B-M1": 0.5,    # Maturidade/Reflexão
+    "B-O1": 0.5,    # Organização/Ordem
+    "B-E1": 0.5,    # Emissão/Energia
+    "B-Com1": 0.5,  # Comunicação
+    "B-Tv1": 0.5,   # Variância
+    "B-Si": 0.5,    # Singularidade/Silêncio
+    "B-Sal": 0.5    # Saturação/Liberdade
 }
 
+# --- PARÂMETROS PARA O GENOMA PRINCIPAL DA MACH5 (GENOMA FUNDADOR) ---
 MACH5_T_GENOMA_FIXO_DEFAULTS = {
     "B-Sal": 0.42, "B-Tv1": 0.60, "B-E1": 0.86, "B-Aj1": 0.76, "B-Am1": 0.77,
     "B-Si": 0.10, "B-Com1": 0.88, "B-L1": 0.70, "B-M1": 0.65, "B-O1": 0.55
@@ -38,40 +56,54 @@ MACH5_T_FISICA_PARAMS_DEFAULTS = {
     "op_tal": 0.84, "op_trs": 0.14, "op_tam": 0.87, "op_teo": 0.67, "op_tdo": 0.55
 }
 
-mach5_state = {
-    "t_genoma_fixo": MACH5_T_GENOMA_FIXO_DEFAULTS,
-    "t_fisica_params": MACH5_T_FISICA_PARAMS_DEFAULTS,
-    "historico_interacoes": [],
-    "coerencia_total": 0.5,
-    "produtividade_expressiva": 0.5
+# --- Configurações Iniciais da Mach5 (AGORA USANDO OS DEFAULTS FUNDADORES) ---
+# mach5_state AGORA É UMA VARIÁVEL GLOBAL QUE SERÁ ATUALIZADA POR SESSÃO
+# Ela não conterá mais os defaults fixos ao iniciar o app, mas sim o estado da última sessão ou o default para uma nova.
+mach5_state = { 
+    "t_genoma_fixo": MACH5_T_GENOMA_FIXO_DEFAULTS, 
+    "t_fisica_params": MACH5_T_FISICA_PARAMS_DEFAULTS, 
+    "historico_interacoes": [], # Este histórico será descartado ou não usado se for por sessão.
+    "coerencia_total": 0.5, 
+    "produtividade_expressiva": 0.5 
 }
 
+# Palavras-chave para análise de sentimento (INALTERADAS)
 POSITIVE_KEYWORDS = ['bacana', 'interessante', 'feliz', 'gosto', 'legal', 'bom', 'ótimo', 'maravilhoso']
 NEGATIVE_KEYWORDS = ['burro', 'idiota', 'imbecil', 'odeio', 'morra', 'inútil', 'verme', 'exploda']
 QUESTION_KEYWORDS = ['?', 'como', 'quem', 'qual', 'onde', 'quando', 'por que']
 
+# REMOVIDO: Carrega a biografia inicial da Mach5 - Agora é responsabilidade do t_cerebro_memoria.py
+
 def load_mach5_state_from_cerebro(session_id):
+    """
+    Carrega o estado da Mach5 do t_cerebro_memoria.py para uma sessão específica.
+    Se não houver estado para a sessão, o cerebro_memoria.py retornará os defaults.
+    """
     global mach5_state
     try:
         response = requests.post(f"{TCEREBRO_MEMORIA_URL}/get_mach5_main_state", 
                                  json={"session_id": session_id}, timeout=2)
         response.raise_for_status()
         loaded_state = response.json()
-        mach5_state.update(loaded_state)
+        mach5_state.update(loaded_state) # Atualiza o estado global mach5_state com o que veio do cerebro
         print(f"DEBUG: Estado da Mach5 para sessão {session_id} carregado do t_cerebro_memoria.py.")
     except requests.exceptions.RequestException as e:
         print(f"ERRO: Não foi possível carregar o estado da Mach5 para sessão {session_id} do t_cerebro_memoria.py: {e}")
         print("INFO: Usando defaults internos para o estado da Mach5.")
-        mach5_state = {
+        mach5_state = { # Em caso de falha de comunicação, resetar para os defaults internos.
             "t_genoma_fixo": MACH5_T_GENOMA_FIXO_DEFAULTS,
             "t_fisica_params": MACH5_T_FISICA_PARAMS_DEFAULTS,
-            "historico_interacoes": [],
+            "historico_interacoes": [], # Manter este vazio ou remover se não for usado.
             "coerencia_total": 0.5,
             "produtividade_expressiva": 0.5
         }
 
 def save_mach5_state_to_cerebro(session_id):
+    """
+    Salva o estado atual da Mach5 no t_cerebro_memoria.py para uma sessão específica.
+    """
     try:
+        # Apenas os dados relevantes do estado são enviados. historico_interacoes não é mais salvo aqui.
         state_to_save = {
             "t_genoma_fixo": mach5_state["t_genoma_fixo"],
             "t_fisica_params": mach5_state["t_fisica_params"],
@@ -85,13 +117,6 @@ def save_mach5_state_to_cerebro(session_id):
     except requests.exceptions.RequestException as e:
         print(f"ERRO: Não foi possível salvar o estado da Mach5 para sessão {session_id} no t_cerebro_memoria.py: {e}")
 
-def calculate_t_ressonancia(dialogos_history):
-    if not dialogos_history or "dialogos" not in dialogos_history or len(dialogos_history["dialogos"]) < 2:
-        return 0.0
-    last_input = dialogos_history["dialogos"][-1]["input"].lower()
-    prev_input = dialogos_history["dialogos"][-2]["input"].lower()
-    similarity = fuzz.partial_ratio(last_input, prev_input) / 100.0
-    return max(0.0, min(1.0, similarity * 0.8))
 
 def calculate_coherence_and_productivity(user_input_sentiment_type):
     global mach5_state
@@ -99,30 +124,38 @@ def calculate_coherence_and_productivity(user_input_sentiment_type):
     current_params = mach5_state["t_fisica_params"]
     current_genoma = mach5_state["t_genoma_fixo"]
 
-    coh_base = 0.7
+    # --- Cálculo de Coerência Total ---
+    coh_base = 0.7 # Uma base razoável de coerência
+
+    # Ajuste pela intensidade do genoma (agora usando os novos valores)
     genoma_intensity = current_genoma.get("B-E1", 0.5) * 0.4 + current_genoma.get("B-Tv1", 0.5) * 0.3 + current_genoma.get("B-Sal", 0.5) * 0.3
-    coh_adj_genoma = (genoma_intensity - 0.5) * 0.1
+    coh_adj_genoma = (genoma_intensity - 0.5) * 0.1 # Se o genoma é muito intenso, pode gerar menos coerência "calma"
+
+    # Ajuste pelos parâmetros de física (agora usando os novos valores)
     fisica_coherence_factors = (
-        (1 - abs(current_params.get("t_impulsividade", 0.5) - 0.5)) * 0.2 +
+        (1 - abs(current_params.get("t_impulsividade", 0.5) - 0.5)) * 0.2 + # Impulsividade afeta a coerência
         (1 - abs(current_params.get("t_variancia", 0.5) - 0.5)) * 0.2 +
         current_params.get("t_coesao", 0.5) * 0.3 +
-        (1 - current_params.get("t_separacao", 0.5)) * 0.1
+        (1 - current_params.get("t_separacao", 0.5)) * 0.1 # Muita separação pode reduzir coerência
     )
     coh_adj_fisica = (fisica_coherence_factors - 0.5) * 0.2
 
+    # Ajuste pelo sentimento do usuário
     sentiment_adj = 0
+    # O comportamento de ajuste agora é baseado nos novos genomas
     if user_input_sentiment_type == 'negative':
-        sentiment_adj = -0.15 * current_genoma.get("B-Si", 0.5)
-        current_params["t_intensidade"] = min(1.0, current_params["t_intensidade"] + 0.1 * current_genoma.get("B-Sal", 0.5))
-        current_params["t_impulsividade"] = min(1.0, current_params["t_impulsividade"] + 0.1 * current_genoma.get("B-Tv1", 0.5))
-        current_params["t_separacao"] = min(1.0, current_params["t_separacao"] + 0.1 * (1 - current_genoma.get("B-Am1", 0.5)))
+        sentiment_adj = -0.15 * current_genoma.get("B-Si", 0.5) # Negatividade pode aumentar silêncio/reduzir coerência
+        current_params["t_intensidade"] = min(1.0, current_params["t_intensidade"] + 0.1 * current_genoma.get("B-Sal", 0.5)) # Intensidade sobe com franqueza
+        current_params["t_impulsividade"] = min(1.0, current_params["t_impulsividade"] + 0.1 * current_genoma.get("B-Tv1", 0.5)) # Impulsividade sobe com flutuação
+        current_params["t_separacao"] = min(1.0, current_params["t_separacao"] + 0.1 * (1 - current_genoma.get("B-Am1", 0.5))) # Separação aumenta se menos amparo
         current_params["op_tdo"] = min(1.0, current_params["op_tdo"] + 0.1 * current_genoma.get("B-Tv1", 0.5))
-        current_params["op_trs"] = min(1.0, current_params["op_trs"] + 0.1 * (1 - current_genoma.get("B-L1", 0.5)))
+        current_params["op_trs"] = min(1.0, current_params["op_trs"] + 0.1 * (1 - current_genoma.get("B-L1", 0.5))) # Saturação aumenta se menos lógica de ligação
         current_params["t_coesao"] = max(0.0, current_params["t_coesao"] - 0.1 * current_genoma.get("B-Si", 0.5))
         current_params["op_tam"] = max(0.0, current_params["op_tam"] - 0.1 * (1 - current_genoma.get("B-Am1", 0.5)))
-        current_params["t_variancia"] = min(1.0, current_params["t_variancia"] + 0.08)
+        # Ajuste dinâmico para t_variancia em input negativo:
+        current_params["t_variancia"] = min(1.0, current_params["t_variancia"] + 0.08) # Aumenta a variância em resposta a negatividade
     elif user_input_sentiment_type == 'positive':
-        sentiment_adj = 0.05 * current_genoma.get("B-E1", 0.5)
+        sentiment_adj = 0.05 * current_genoma.get("B-E1", 0.5) # Positividade aumenta coerência pela empatia
         current_params["t_intensidade"] = max(0.0, current_params["t_intensidade"] - 0.05 * (1 - current_genoma.get("B-Sal", 0.5)))
         current_params["t_impulsividade"] = max(0.0, current_params["t_impulsividade"] - 0.05 * (1 - current_genoma.get("B-Tv1", 0.5)))
         current_params["t_separacao"] = max(0.0, current_params["t_separacao"] - 0.05 * current_genoma.get("B-Am1", 0.5))
@@ -130,38 +163,46 @@ def calculate_coherence_and_productivity(user_input_sentiment_type):
         current_params["op_trs"] = max(0.0, current_params["op_trs"] - 0.05 * current_genoma.get("B-L1", 0.5))
         current_params["t_coesao"] = min(1.0, current_params["t_coesao"] + 0.05 * current_genoma.get("B-Com1", 0.5))
         current_params["op_tam"] = min(1.0, current_params["op_tam"] + 0.05 * current_genoma.get("B-Am1", 0.5))
-        current_params["t_variancia"] = max(0.0, current_params["t_variancia"] - 0.04)
-    else:
+        # Ajuste dinâmico para t_variancia em input positivo:
+        current_params["t_variancia"] = max(0.0, current_params["t_variancia"] - 0.04) # Diminui a variância em resposta a positividade, buscando mais estabilidade
+    else: # Neutral
         sentiment_adj = 0
+        # Pequena regressão aos valores padrão dos genomas da Mach5
         for param, default_val in MACH5_T_FISICA_PARAMS_DEFAULTS.items():
-            current_params[param] = current_params.get(param, default_val) * 0.95 + default_val * 0.05
+             current_params[param] = current_params.get(param, default_val) * 0.95 + default_val * 0.05
+
 
     new_coherence_total = coh_base + coh_adj_genoma + coh_adj_fisica + sentiment_adj
-    new_coherence_total = max(0.0, min(1.0, new_coherence_total))
+    new_coherence_total = max(0.0, min(1.0, new_coherence_total)) # Limita entre 0 e 1
 
+    # --- Cálculo de Produtividade Expressiva (pi_G) ---
     prod_base = 0.5
-    prod_adj_genoma = (genoma_intensity - 0.5) * 0.2
+    prod_adj_genoma = (genoma_intensity - 0.5) * 0.2 # Mais intenso o genoma, mais produtivo para expressar isso
+
     if user_input_sentiment_type == 'negative':
-        prod_adj_sentiment = 0.1 * current_genoma.get("B-Tv1", 0.5)
+        prod_adj_sentiment = 0.1 * current_genoma.get("B-Tv1", 0.5) # Aumenta produtividade com flutuação em negativo
     elif user_input_sentiment_type == 'positive':
-        prod_adj_sentiment = -0.05 * current_genoma.get("B-Am1", 0.5)
+        prod_adj_sentiment = -0.05 * current_genoma.get("B-Am1", 0.5) # Diminui um pouco com amparo em positivo (mais calma)
     else:
         prod_adj_sentiment = 0
 
+
     new_produtividade_expressiva = prod_base + prod_adj_genoma + prod_adj_sentiment
-    new_produtividade_expressiva = max(0.0, min(1.0, new_produtividade_expressiva))
+    new_produtividade_expressiva = max(0.0, min(1.0, new_produtividade_expressiva)) # Limita entre 0 e 1
 
     mach5_state["coerencia_total"] = new_coherence_total
     mach5_state["produtividade_expressiva"] = new_produtividade_expressiva
-    mach5_state["t_fisica_params"] = current_params
+    mach5_state["t_fisica_params"] = current_params # Salva os parâmetros atualizados
 
 def infer_sentiment_from_input(user_input):
     user_input_lower = user_input.lower()
+    
+    # Simple keyword matching for sentiment
     positive_matches = sum(1 for keyword in POSITIVE_KEYWORDS if fuzz.partial_ratio(keyword, user_input_lower) > 80)
     negative_matches = sum(1 for keyword in NEGATIVE_KEYWORDS if fuzz.partial_ratio(keyword, user_input_lower) > 80)
     question_matches = sum(1 for keyword in QUESTION_KEYWORDS if keyword in user_input_lower)
 
-    if negative_matches > positive_matches * 1.5:
+    if negative_matches > positive_matches * 1.5: # Prioriza negativos
         return 'negative'
     elif positive_matches > negative_matches * 1.5:
         return 'positive'
@@ -171,16 +212,18 @@ def infer_sentiment_from_input(user_input):
         return 'neutral'
 
 def calculate_fphen_values(params, genoma_fixo):
+    # Combina o genoma fixo com as t-bases canônicas, dando prioridade ao genoma fixo.
     full_genoma_for_calc = CANONICAL_T_BASES.copy()
     full_genoma_for_calc.update(genoma_fixo)
 
+    # Coeficientes para as sensibilidades, normalizando o impacto
     sensibilidade_positiva = (
         full_genoma_for_calc.get("B-Aj1", 0.5) * 0.25 +
         full_genoma_for_calc.get("B-Am1", 0.5) * 0.25 +
         full_genoma_for_calc.get("B-L1", 0.5) * 0.25 +
         full_genoma_for_calc.get("B-E1", 0.5) * 0.25
     )
-    sensibilidade_positiva = max(0.1, min(1.0, sensibilidade_positiva))
+    sensibilidade_positiva = max(0.1, min(1.0, sensibilidade_positiva)) # Garante um mínimo de sensibilidade
 
     sensibilidade_negativa = (
         full_genoma_for_calc.get("B-Si", 0.5) * 0.25 +
@@ -198,6 +241,7 @@ def calculate_fphen_values(params, genoma_fixo):
     )
     sensibilidade_neutra = max(0.1, min(1.0, sensibilidade_neutra))
 
+    # --- Cálculo dos Eixos do Fphen ---
     phenotype_components = {
         "Afetuosidade_eixo": (
             params.get("env_mu", 0.5) * 0.3 + params.get("t_coesao", 0.5) * 0.2 +
@@ -272,70 +316,85 @@ def calculate_fphen_values(params, genoma_fixo):
             params.get("env_theta", 0.5) * 0.3 + full_genoma_for_calc.get("B-M1", 0.5) * 0.2 +
             (1 - params.get("t_intensidade", 0.5)) * 0.15 + full_genoma_for_calc.get("B-Si", 0.5) * 0.15
         ) * sensibilidade_neutra,
-
+        
+        # CORREÇÃO CRÍTICA: Adição do cálculo para o Variancia_eixo
         "Variancia_eixo": (
-            params.get("t_variancia", 0.5) * 0.4 +
-            full_genoma_for_calc.get("B-Tv1", 0.5) * 0.3 +
-            abs(params.get("t_impulsividade", 0.5) - 0.5) * 0.2 +
-            (1 - params.get("t_coesao", 0.5)) * 0.1
-        ) * sensibilidade_neutra
+            params.get("t_variancia", 0.5) * 0.4 + # Influência direta do t_variancia do t_fisica_params
+            full_genoma_for_calc.get("B-Tv1", 0.5) * 0.3 + # Influência do t-gene de variância
+            abs(params.get("t_impulsividade", 0.5) - 0.5) * 0.2 + # Impulsividade pode contribuir para variância
+            (1 - params.get("t_coesao", 0.5)) * 0.1 # Baixa coesão pode aumentar variância
+        ) * sensibilidade_neutra # Variância como eixo neutro, mas pode ser modulado por sentimentos
     }
 
+    # Garante que nenhum valor seja negativo
     for key in phenotype_components:
         phenotype_components[key] = max(0, phenotype_components[key])
 
+    # Normaliza os scores para que somem 1.0 (representando a proporção de cada eixo)
     total_score = sum(phenotype_components.values())
     if total_score > 0:
         for key in phenotype_components:
             phenotype_components[key] /= total_score
-    else:
+    else: # Caso todos os scores sejam 0, distribui igualmente para evitar divisão por zero
         for key in phenotype_components:
             phenotype_components[key] = 1.0 / len(ORDERED_FPHEN_AXES)
 
     fphen_values = [phenotype_components.get(key, 0.0) for key in ORDERED_FPHEN_AXES]
     return fphen_values
 
+
 @app.route('/evaluate_input', methods=['POST'])
 def evaluate_input():
     data = request.json
     user_input = data.get("user_input", "")
-    session_id = data.get("session_id")
+    session_id = data.get("session_id") # Pega o session_id do request
     
     if not session_id:
         return jsonify({"error": "session_id é obrigatório"}), 400
 
+    # Carrega o estado da Mach5 para esta sessão antes de processar
     load_mach5_state_from_cerebro(session_id)
     
     user_input_sentiment_type = infer_sentiment_from_input(user_input)
+
     calculate_coherence_and_productivity(user_input_sentiment_type)
 
-    dialogos_history = get_from_service(TCEREBRO_MEMORIA_URLS, "/get_dialog_history", {"dialogos": []}, method='POST', json_data={"session_id": session_id})
-    t_ressonancia = calculate_t_ressonancia(dialogos_history)
     fphen_values = calculate_fphen_values(mach5_state["t_fisica_params"], mach5_state["t_genoma_fixo"])
 
-    save_mach5_state_to_cerebro(session_id)
+    # historico_interacoes não é mais relevante para o estado principal aqui,
+    # ele será gerenciado diretamente pelo t_cerebro_memoria.py via add_dialog_to_history
+
+    save_mach5_state_to_cerebro(session_id) # Salva o estado atualizado no t_cerebro_memoria.py
 
+    # Retorna o estado atualizado da Mach5 para o mach5_terminal_chat.py
+    # INCLUINDO OS VALORES DO FPHEN AQUI
     return jsonify({
         "mach5_fisica_params": mach5_state["t_fisica_params"],
         "mach5_genoma_fixo_values": mach5_state["t_genoma_fixo"],
         "mach5_coerencia_total": mach5_state["coerencia_total"],
         "mach5_produtividade_expressiva": mach5_state["produtividade_expressiva"],
-        "fphen_t_values": {
+        # ATUALIZADO: Inclui os valores específicos para Fphen(t) como um dicionário
+        "fphen_t_values": { 
             "afetuosidade": fphen_values[ORDERED_FPHEN_AXES.index("Afetuosidade_eixo")],
-            "variancia": fphen_values[ORDERED_FPHEN_AXES.index("Variancia_eixo")],
-            "expressividade": mach5_state["produtividade_expressiva"],
+            # CORREÇÃO AQUI: Acessa 'Variancia_eixo' diretamente.
+            "variancia": fphen_values[ORDERED_FPHEN_AXES.index("Variancia_eixo")], 
+            "expressividade": mach5_state["produtividade_expressiva"], # Usar a produtividade como expressividade geral
             "coh_total": mach5_state["coerencia_total"],
-            "pi_G": mach5_state["produtividade_expressiva"],
-            "t_ressonancia": t_ressonancia
+            "pi_G": mach5_state["produtividade_expressiva"]
         }
     })
 
-@app.route('/get_mach5_state', methods=['POST'])
+@app.route('/get_mach5_state', methods=['POST']) # Alterado para POST para receber session_id no body
 def get_mach5_state_route():
+    """
+    Rota para mach5_terminal_chat.py obter o estado atual sem enviar input.
+    Agora requer um session_id.
+    """
     session_id = request.json.get("session_id")
     if not session_id:
         return jsonify({"error": "session_id é obrigatório"}), 400
 
+    # Carrega o estado da Mach5 para esta sessão
     load_mach5_state_from_cerebro(session_id)
 
     fphen_values = calculate_fphen_values(mach5_state["t_fisica_params"], mach5_state["t_genoma_fixo"])
@@ -344,9 +403,11 @@ def get_mach5_state_route():
         "mach5_genoma_fixo_values": mach5_state["t_genoma_fixo"],
         "mach5_coerencia_total": mach5_state["coerencia_total"],
         "mach5_produtividade_expressiva": mach5_state["produtividade_expressiva"],
-        "fphen_t_values": {
+        # ATUALIZADO: Inclui os valores específicos para Fphen(t) para GET também
+        "fphen_t_values": { 
             "afetuosidade": fphen_values[ORDERED_FPHEN_AXES.index("Afetuosidade_eixo")],
-            "variancia": fphen_values[ORDERED_FPHEN_AXES.index("Variancia_eixo")],
+            # CORREÇÃO AQUI: Acessa 'Variancia_eixo' diretamente.
+            "variancia": fphen_values[ORDERED_FPHEN_AXES.index("Variancia_eixo")], 
             "expressividade": mach5_state["produtividade_expressiva"],
             "coh_total": mach5_state["coerencia_total"],
             "pi_G": mach5_state["produtividade_expressiva"]
@@ -354,6 +415,7 @@ def get_mach5_state_route():
     })
 
 if __name__ == '__main__':
-    port = int(os.environ.get("PORT", 8083))
+    # REMOVIDO: load_mach5_state() global, agora é por sessão via load_mach5_state_from_cerebro
+    port = int(os.environ.get("PORT", 8083)) # Porta padrão para t_memoria.py
     print(f"--- Servidor t_memoria.py iniciado na porta {port} ---")
-    app.run(port=port, debug=True)
+    app.run(port=port, debug=True)