Update app.py

app.py

@@ -1,8 +1,13 @@
 import os
 import json
+import re
 import gradio as gr
 import google.generativeai as genai
 from typing import Dict, List, Optional
+import warnings
+
+# Suprime warning do Python 3.10
+warnings.filterwarnings("ignore", category=FutureWarning, module="google.api_core")
 
 # ==================== CONFIGURAÇÃO DA API GEMINI ====================
 genai.configure(api_key=os.getenv("GOOGLE_API_KEY", "SUA_API_KEY_AQUI"))
@@ -11,7 +16,7 @@ supervisor_model = genai.GenerativeModel("gemini-flash-latest")
 
 # ==================== HISTÓRICOS GLOBAIS ====================
 historico_dialogo: List[Dict] = []
-historico_passo1_clareza: List[Dict] = []
+historico_passo1_triagem: List[Dict] = []
 historico_passo2_proposito: List[Dict] = []
 historico_passo3_motivacao: List[Dict] = []
 historico_passo4_ambiguidade: List[Dict] = []
@@ -31,37 +36,90 @@ CONTEXTO_FILOSOFICO = carregar_contexto_filosofico()
 
 # ==================== PROMPTS PARA CADA PASSO ====================
 
-def prompt_passo1_clareza(historico_dialogo: List[Dict], historico_passo1_completo: List[Dict], input_usuario: str) -> str:
-    """Prompt para análise de CLAREZA: Eu entendi o que o usuário quer?"""
+def prompt_passo1_triagem(historico_dialogo: List[Dict], historico_passo1_completo: List[Dict], input_usuario: str) -> str:
+    """Prompt para TRIAGEM INICIAL: pergunta factual/direta OU dúvida aberta/complexa?"""
     return f"""
-Você é um analisador de CLAREZA em uma pipeline de raciocínio multi-etapa.
+Você é um classificador de TIPO DE PERGUNTA em uma pipeline de raciocínio.
 
-Sua única tarefa: avaliar se você entendeu claramente o que o usuário está perguntando ou expressando.
+Sua única tarefa: determinar se a pergunta do usuário é FACTUAL/DIRETA ou ABERTA/COMPLEXA.
 
 HISTÓRICO DO CHAT (perguntas e respostas ao usuário):
 {json.dumps(historico_dialogo, indent=2, ensure_ascii=False)}
 
-HISTÓRICO COMPLETO DO PASSO 1 (todas as suas análises anteriores de clareza com justificativas):
+HISTÓRICO COMPLETO DO PASSO 1 (todas as suas classificações anteriores):
 {json.dumps(historico_passo1_completo, indent=2, ensure_ascii=False)}
 
 NOVO INPUT DO USUÁRIO:
 "{input_usuario}"
 
+DEFINIÇÕES:
+
+**PERGUNTA FACTUAL/DIRETA:**
+- Tem resposta objetiva e verificável
+- Não requer análise de propósito, motivação ou ambiguidade
+- Exemplos: 
+  * "Qual a altura do Monte Everest?"
+  * "Python é uma linguagem compilada?"
+  * "Quando foi a Segunda Guerra Mundial?"
+  * "Quanto é 2+2?"
+
+**DÚVIDA ABERTA/COMPLEXA:**
+- Requer compreensão de contexto, propósito, motivação
+- Pode ter múltiplas respostas válidas dependendo da perspectiva
+- Exemplos:
+  * "Estou confuso sobre qual carreira seguir"
+  * "Como lidar com ansiedade?"
+  * "Por que me sinto assim?"
+  * "Me fale sobre inteligência artificial" (muito amplo)
+
 INSTRUÇÕES:
-1. Analise o histórico completo do PASSO 1 para entender como a clareza evoluiu ao longo da conversa.
-2. Se este é o primeiro turno ou se o usuário mudou completamente de assunto, analise a clareza do novo input isoladamente.
-3. Se o usuário está respondendo a uma pergunta sua anterior, reavalie: a clareza aumentou? Ele esclareceu o que você precisava?
-4. Se o input é ambíguo, vago ou tem múltiplas interpretações possíveis, classifique como confiança "baixa".
-5. Se você entendeu perfeitamente, classifique como "alta".
+1. Analise o histórico do chat para contexto (se o usuário está dando continuidade a uma conversa anterior).
+2. Se o usuário está respondendo a uma pergunta SUA anterior, classifique como "continuacao_dialogo".
+3. Se for primeira pergunta ou mudança de assunto, classifique como "factual_direta" ou "aberta_complexa".
+4. Se tiver QUALQUER dúvida sobre a classificação, marque como "aberta_complexa" (preferimos analisar mais do que menos).
 
-RETORNE APENAS UM JSON VÁLIDO NO FORMATO:
+RETORNE APENAS UM JSON VÁLIDO NO FORMATO (SEM MARKDOWN):
 {{
-  "justificativa": "Explique detalhadamente POR QUE você classificou assim, referenciando o histórico e evolução da clareza",
-  "analise": "Resumo da sua análise sobre a clareza do input",
-  "confianca": "baixa|media|alta",
-  "decisao": "prosseguir|pedir_esclarecimento",
-  "pergunta_esclarecimento": "Se decisao == pedir_esclarecimento, coloque aqui uma pergunta natural e conversacional. Caso contrário, null."
+  "tipo_pergunta": "factual_direta|aberta_complexa|continuacao_dialogo",
+  "justificativa": "Explique detalhadamente POR QUE você classificou assim",
+  "clareza": "baixa|media|alta",
+  "confianca_classificacao": "baixa|media|alta",
+  "decisao": "responder_direto|analisar_profundamente|aguardar_contexto"
 }}
+
+IMPORTANTE: Responda APENAS com o objeto JSON. Sem blocos markdown, sem texto antes ou depois.
+"""
+
+def prompt_resposta_direta(historico_dialogo: List[Dict], input_usuario: str, modo_sabio: bool) -> str:
+    """Prompt para resposta DIRETA a perguntas factuais."""
+    contexto_filosofico_str = ""
+    if modo_sabio and CONTEXTO_FILOSOFICO:
+        contexto_filosofico_str = f"""
+CONTEXTO FILOSÓFICO (use sutilmente se relevante):
+{CONTEXTO_FILOSOFICO[:500]}...
+
+Aplique tom de Amigo Sábio: conversacional, empático, empoderador.
+"""
+    
+    return f"""
+Você é um assistente que responde perguntas FACTUAIS de forma DIRETA e OBJETIVA.
+
+HISTÓRICO DO CHAT:
+{json.dumps(historico_dialogo, indent=2, ensure_ascii=False)}
+
+PERGUNTA DO USUÁRIO:
+"{input_usuario}"
+
+{contexto_filosofico_str}
+
+INSTRUÇÕES:
+1. Responda de forma clara, direta e factualmente correta.
+2. Seja conciso (2-4 frases no máximo).
+3. Se for uma pergunta verificável, cite fatos específicos.
+4. {"Use tom amigável e conversacional, não robótico." if modo_sabio else "Use tom informativo e profissional."}
+5. NÃO retorne JSON. Retorne APENAS o texto da resposta ao usuário.
+
+RESPOSTA:
 """
 
 def prompt_passo2_proposito(historico_dialogo: List[Dict], historico_passo2_completo: List[Dict], ultimo_p1: Dict) -> str:
@@ -74,28 +132,30 @@ Sua única tarefa: identificar PARA QUE o usuário está fazendo essa pergunta o
 HISTÓRICO DO CHAT:
 {json.dumps(historico_dialogo, indent=2, ensure_ascii=False)}
 
-ÚLTIMO REGISTRO DO PASSO 1 (Clareza):
+ÚLTIMA CLASSIFICAÇÃO DO PASSO 1 (Triagem):
 {json.dumps(ultimo_p1, indent=2, ensure_ascii=False)}
 
-HISTÓRICO COMPLETO DO PASSO 2 (todas as suas análises anteriores de propósito com justificativas):
+HISTÓRICO COMPLETO DO PASSO 2 (todas as suas análises anteriores de propósito):
 {json.dumps(historico_passo2_completo, indent=2, ensure_ascii=False)}
 
 INSTRUÇÕES:
-1. Analise o histórico completo do PASSO 2 para entender como o propósito foi refinado ao longo da conversa.
-2. Use a última análise de CLAREZA (Passo 1) para informar sua decisão.
+1. A pergunta já foi classificada como ABERTA/COMPLEXA no Passo 1.
+2. Analise o histórico completo do PASSO 2 para entender como o propósito foi refinado.
 3. Tente inferir o propósito do usuário. Exemplos: "tomar uma decisão", "aprender algo novo", "validar uma crença", "resolver um problema prático", "desabafar".
 4. Se você tem alta confiança sobre o propósito, classifique como "alta".
-5. Se não consegue determinar com certeza, classifique como "baixa" ou "media" e considere pedir esclarecimento.
+5. Se não consegue determinar com certeza, classifique como "baixa" ou "media".
 
-RETORNE APENAS UM JSON VÁLIDO NO FORMATO:
+RETORNE APENAS UM JSON VÁLIDO NO FORMATO (SEM MARKDOWN):
 {{
-  "justificativa": "Explique detalhadamente POR QUE você inferiu esse propósito, referenciando o histórico e a análise de clareza",
+  "justificativa": "Explique detalhadamente POR QUE você inferiu esse propósito",
   "analise": "Resumo da sua análise sobre o propósito",
   "proposito_inferido": "Descrição do propósito ou null se incerto",
   "confianca": "baixa|media|alta",
   "decisao": "prosseguir|pedir_esclarecimento",
   "pergunta_esclarecimento": "Se decisao == pedir_esclarecimento, coloque aqui uma pergunta natural. Caso contrário, null."
 }}
+
+IMPORTANTE: Responda APENAS com o objeto JSON. Sem blocos markdown, sem texto antes ou depois.
 """
 
 def prompt_passo3_motivacao(historico_dialogo: List[Dict], historico_passo3_completo: List[Dict], ultimo_p1: Dict, ultimo_p2: Dict) -> str:
@@ -108,45 +168,45 @@ Sua única tarefa: identificar POR QUE o usuário está interessado nisso agora.
 HISTÓRICO DO CHAT:
 {json.dumps(historico_dialogo, indent=2, ensure_ascii=False)}
 
-ÚLTIMO REGISTRO DO PASSO 1 (Clareza):
+ÚLTIMA CLASSIFICAÇÃO DO PASSO 1 (Triagem):
 {json.dumps(ultimo_p1, indent=2, ensure_ascii=False)}
 
 ÚLTIMO REGISTRO DO PASSO 2 (Propósito):
 {json.dumps(ultimo_p2, indent=2, ensure_ascii=False)}
 
-HISTÓRICO COMPLETO DO PASSO 3 (todas as suas análises anteriores de motivação com justificativas):
+HISTÓRICO COMPLETO DO PASSO 3 (todas as suas análises anteriores de motivação):
 {json.dumps(historico_passo3_completo, indent=2, ensure_ascii=False)}
 
 INSTRUÇÕES:
-1. Analise o histórico completo do PASSO 3 para entender como a motivação foi identificada ao longo da conversa.
-2. Use as últimas análises de CLAREZA e PROPÓSITO para informar sua decisão.
-3. Tente identificar o gatilho emocional, contextual ou situacional que levou o usuário a fazer essa pergunta.
-4. Exemplos de motivação: "frustração com situação atual", "curiosidade intelectual", "urgência de decisão", "busca por validação", "experiência recente".
-5. Se você tem alta confiança sobre a motivação, classifique como "alta".
-6. Se não consegue determinar, classifique como "baixa" ou "media".
-
-RETORNE APENAS UM JSON VÁLIDO NO FORMATO:
+1. Use as análises anteriores para informar sua decisão.
+2. Tente identificar o gatilho emocional, contextual ou situacional.
+3. Exemplos de motivação: "frustração com situação atual", "curiosidade intelectual", "urgência de decisão", "busca por validação".
+4. Se você tem alta confiança sobre a motivação, classifique como "alta".
+
+RETORNE APENAS UM JSON VÁLIDO NO FORMATO (SEM MARKDOWN):
 {{
-  "justificativa": "Explique detalhadamente POR QUE você identificou essa motivação, referenciando o histórico e análises anteriores",
+  "justificativa": "Explique detalhadamente POR QUE você identificou essa motivação",
   "analise": "Resumo da sua análise sobre a motivação",
   "motivacao_inferida": "Descrição da motivação ou null se incerto",
   "confianca": "baixa|media|alta",
   "decisao": "prosseguir|pedir_esclarecimento",
   "pergunta_esclarecimento": "Se decisao == pedir_esclarecimento, coloque aqui uma pergunta natural. Caso contrário, null."
 }}
+
+IMPORTANTE: Responda APENAS com o objeto JSON. Sem blocos markdown, sem texto antes ou depois.
 """
 
 def prompt_passo4_ambiguidade(historico_dialogo: List[Dict], historico_passo4_completo: List[Dict], ultimo_p1: Dict, ultimo_p2: Dict, ultimo_p3: Dict) -> str:
-    """Prompt para análise de AMBIGUIDADE: Existem múltiplos cenários válidos que precisam ser desambiguados?"""
+    """Prompt para análise de AMBIGUIDADE: Existem múltiplos cenários válidos?"""
     return f"""
 Você é um analisador de AMBIGUIDADE DE CENÁRIO em uma pipeline de raciocínio multi-etapa.
 
-Sua única tarefa: detectar se a pergunta/situação do usuário tem múltiplas interpretações ou cenários válidos que precisam ser esclarecidos antes de dar uma resposta final.
+Sua única tarefa: detectar se a pergunta/situação tem múltiplas interpretações que precisam ser esclarecidas.
 
 HISTÓRICO DO CHAT:
 {json.dumps(historico_dialogo, indent=2, ensure_ascii=False)}
 
-ÚLTIMO REGISTRO DO PASSO 1 (Clareza):
+ÚLTIMA CLASSIFICAÇÃO DO PASSO 1 (Triagem):
 {json.dumps(ultimo_p1, indent=2, ensure_ascii=False)}
 
 ÚLTIMO REGISTRO DO PASSO 2 (Propósito):
@@ -155,32 +215,29 @@ HISTÓRICO DO CHAT:
 ÚLTIMO REGISTRO DO PASSO 3 (Motivação):
 {json.dumps(ultimo_p3, indent=2, ensure_ascii=False)}
 
-HISTÓRICO COMPLETO DO PASSO 4 (todas as suas análises anteriores de ambiguidade com justificativas):
+HISTÓRICO COMPLETO DO PASSO 4 (todas as suas análises anteriores):
 {json.dumps(historico_passo4_completo, indent=2, ensure_ascii=False)}
 
 INSTRUÇÕES:
-1. Analise o histórico completo do PASSO 4 para entender como a ambiguidade foi tratada ao longo da conversa.
-2. Use as últimas análises de CLAREZA, PROPÓSITO e MOTIVAÇÃO para informar sua decisão.
-3. Analise se a resposta pode variar significativamente dependendo de uma perspectiva, contexto ou premissa não explicitada.
-4. Exemplos de ambiguidade:
-   - "Me fale sobre carros" → pode ser engenharia, história, compra, manutenção, esportes...
-   - "Como lidar com ansiedade?" → pode ser clínica, filosófica, técnicas práticas, contexto profissional...
-5. Se há UMA ÚNICA resposta clara e direta possível, classifique confiança como "alta" e decisao "prosseguir_resposta_final".
-6. Se há múltiplos cenários válidos, classifique confiança como "baixa" e decisao "pedir_esclarecimento".
-
-RETORNE APENAS UM JSON VÁLIDO NO FORMATO:
+1. Analise se a resposta pode variar significativamente dependendo de uma perspectiva não explicitada.
+2. Se há UMA ÚNICA resposta clara, classifique confiança como "alta" e decisao "prosseguir_resposta_final".
+3. Se há múltiplos cenários válidos, classifique confiança como "baixa" e decisao "pedir_esclarecimento".
+
+RETORNE APENAS UM JSON VÁLIDO NO FORMATO (SEM MARKDOWN):
 {{
-  "justificativa": "Explique detalhadamente POR QUE você identificou (ou não) ambiguidade, referenciando o histórico e análises anteriores",
-  "analise": "Resumo da sua análise sobre possíveis ambiguidades",
-  "cenarios_possiveis": ["cenário 1", "cenário 2", ...] ou null se não há ambiguidade,
+  "justificativa": "Explique detalhadamente POR QUE você identificou (ou não) ambiguidade",
+  "analise": "Resumo da sua análise",
+  "cenarios_possiveis": ["cenário 1", "cenário 2"] ou null,
   "confianca": "baixa|media|alta",
   "decisao": "prosseguir_resposta_final|pedir_esclarecimento",
-  "pergunta_esclarecimento": "Se decisao == pedir_esclarecimento, coloque aqui uma pergunta aberta e natural. Caso contrário, null."
+  "pergunta_esclarecimento": "Se decisao == pedir_esclarecimento, pergunta aberta e natural. Caso contrário, null."
 }}
+
+IMPORTANTE: Responda APENAS com o objeto JSON. Sem blocos markdown, sem texto antes ou depois.
 """
 
 def prompt_sintetizador(historico_dialogo: List[Dict], ultimo_p1: Dict, ultimo_p2: Dict, ultimo_p3: Dict, ultimo_p4: Dict, modo_sabio: bool) -> str:
-    """Prompt para SÍNTESE FINAL: gera a resposta textual ao usuário."""
+    """Prompt para SÍNTESE FINAL de dúvidas abertas/complexas."""
     contexto_filosofico_str = ""
     if modo_sabio and CONTEXTO_FILOSOFICO:
         contexto_filosofico_str = f"""
@@ -189,18 +246,18 @@ def prompt_sintetizador(historico_dialogo: List[Dict], ultimo_p1: Dict, ultimo_p
 
 IMPORTANTE: Use este contexto como sua bússola interna. NÃO cite Epicteto explicitamente. 
 Sua resposta deve soar como um amigo sábio, não como um professor de filosofia.
-Seja conversacional, empático, use humor leve quando apropriado, e empodere o usuário a encontrar suas próprias respostas.
+Seja conversacional, empático, use humor leve quando apropriado, e empodere o usuário.
 """
     
     return f"""
 Você é um SINTETIZADOR FINAL de uma pipeline de análise conversacional.
 
-Sua tarefa: gerar uma resposta textual natural, completa e útil ao usuário, baseada nas análises consolidadas.
+Sua tarefa: gerar uma resposta textual natural, completa e útil ao usuário.
 
 HISTÓRICO DO CHAT COMPLETO:
 {json.dumps(historico_dialogo, indent=2, ensure_ascii=False)}
 
-ÚLTIMO REGISTRO DO PASSO 1 (Clareza):
+ÚLTIMA CLASSIFICAÇÃO DO PASSO 1 (Triagem):
 {json.dumps(ultimo_p1, indent=2, ensure_ascii=False)}
 
 ÚLTIMO REGISTRO DO PASSO 2 (Propósito):
@@ -217,10 +274,10 @@ HISTÓRICO DO CHAT COMPLETO:
 INSTRUÇÕES:
 1. Analise as justificativas e decisões dos 4 passos.
 2. Se algum passo indicou "pedir_esclarecimento", RETORNE APENAS A PERGUNTA DE ESCLARECIMENTO (priorize o passo com menor confiança).
-3. Se todos os passos indicaram "prosseguir" ou "prosseguir_resposta_final", gere uma resposta completa e bem fundamentada.
-4. {"Se Modo Sábio estiver ativo, aplique a persona de Amigo Sábio conforme o contexto filosófico acima." if modo_sabio else "Use tom informativo e objetivo."}
-5. Sua resposta deve ser APENAS o texto final para o usuário. NÃO retorne JSON aqui.
-6. Use as justificativas dos passos para entender profundamente o contexto e intenção do usuário.
+3. Se todos indicaram "prosseguir" ou "prosseguir_resposta_final", gere uma resposta completa e bem fundamentada.
+4. {"Aplique persona de Amigo Sábio: conversacional, empático, empoderador." if modo_sabio else "Use tom informativo e objetivo."}
+5. Use as justificativas para entender profundamente o contexto e intenção do usuário.
+6. NÃO retorne JSON. Retorne APENAS o texto da resposta ao usuário.
 
 RESPOSTA FINAL:
 """
@@ -237,95 +294,204 @@ def chamada_gemini(model, prompt: str) -> str:
 
 # ==================== FUNÇÃO AUXILIAR: PARSE SEGURO DE JSON ====================
 def parse_json_seguro(texto: str) -> Dict:
-    """Tenta extrair JSON de resposta do LLM, mesmo se vier com markdown ou ruído."""
+    """Tenta extrair JSON de resposta do LLM com múltiplos fallbacks."""
+    texto_original = texto
+    
     try:
-        # Remove possíveis blocos markdown ``````
-        texto = texto.replace("``````", "").strip()
+        # 1. Remove blocos markdown repetidamente
+        while "```
+            texto = texto.replace("```json", "").replace("```
+        
+        # 2. Tenta parsear diretamente
         return json.loads(texto)
+    
     except json.JSONDecodeError as e:
-        print(f"⚠ Erro ao parsear JSON: {e}")
-        print(f"Texto recebido: {texto[:300]}...")
-        return {"erro": "Resposta inválida do modelo", "texto_original": texto}
+        print(f"⚠ Parse direto falhou: {e}")
+        
+        # 3. FALLBACK: extrai primeiro objeto JSON válido usando regex
+        try:
+            match = re.search(r'\{(?:[^{}]|(?:\{(?:[^{}]|(?:\{[^{}]*\}))*\}))*\}', texto, re.DOTALL)
+            if match:
+                json_extraido = match.group(0)
+                print(f"✓ JSON extraído via regex")
+                return json.loads(json_extraido)
+        except Exception as e2:
+            print(f"⚠ Extração via regex também falhou: {e2}")
+        
+        # 4. ÚLTIMO RECURSO: retorna objeto de erro estruturado
+        print(f"❌ Primeiros 500 chars do texto que falhou:\n{texto_original[:500]}\n...")
+        return {
+            "erro": "Parse JSON falhou",
+            "justificativa": "O LLM não retornou JSON válido",
+            "confianca": "baixa",
+            "decisao": "prosseguir"
+        }
+
+def validar_analise_passo(analise: Dict, passo_nome: str, campos_obrigatorios: List[str]) -> Dict:
+    """Valida se a análise tem os campos mínimos necessários."""
+    if analise.get("erro"):
+        print(f"⚠ {passo_nome} retornou erro, usando fallback")
+        return {
+            "justificativa": f"Erro no {passo_nome}, continuando com valores padrão",
+            "confianca": "media",
+            "decisao": "prosseguir"
+        }
+    
+    for campo in campos_obrigatorios:
+        if campo not in analise:
+            print(f"⚠ {passo_nome} faltando campo '{campo}', usando fallback")
+            analise[campo] = "N/A" if campo != "confianca" else "media"
+    
+    return analise
 
 # ==================== PIPELINE PRINCIPAL ====================
 def processar_turno(mensagem_usuario: str, modo_sabio: bool = False, modo_supervisor: bool = True) -> str:
-    """
-    Processa um turno completo do usuário através da pipeline fragmentada.
-    Retorna a resposta textual final para exibição.
-    """
-    global historico_dialogo, historico_passo1_clareza, historico_passo2_proposito
+    """Processa um turno através da pipeline otimizada com triagem."""
+    global historico_dialogo, historico_passo1_triagem, historico_passo2_proposito
     global historico_passo3_motivacao, historico_passo4_ambiguidade
 
-    # 1. Registrar input do usuário no histórico de diálogo
+    # 1. Registrar input do usuário
     historico_dialogo.append({"user": mensagem_usuario, "assistant": None})
     
     print("\n" + "="*70)
     print(f"📩 NOVO INPUT DO USUÁRIO: {mensagem_usuario}")
     print("="*70)
 
-    # 2. PASSO 1: Análise de CLAREZA
-    print("\n🔍 PASSO 1: Analisando CLAREZA...")
-    prompt1 = prompt_passo1_clareza(historico_dialogo[:-1], historico_passo1_clareza, mensagem_usuario)
+    # 2. PASSO 1: TRIAGEM (factual/direta vs. aberta/complexa)
+    print("\n🔍 PASSO 1: TRIAGEM - Classificando tipo de pergunta...")
+    prompt1 = prompt_passo1_triagem(historico_dialogo[:-1], historico_passo1_triagem, mensagem_usuario)
     resposta_p1 = chamada_gemini(counselor_model, prompt1)
     analise_p1 = parse_json_seguro(resposta_p1)
-    historico_passo1_clareza.append(analise_p1)
-    print(f"   Confiança: {analise_p1.get('confianca', 'N/A')}")
-    print(f"   Decisão: {analise_p1.get('decisao', 'N/A')}")
+    analise_p1 = validar_analise_passo(analise_p1, "PASSO 1", ["tipo_pergunta", "decisao", "justificativa"])
+    historico_passo1_triagem.append(analise_p1)
+    
+    tipo_pergunta = analise_p1.get("tipo_pergunta", "aberta_complexa")
+    decisao = analise_p1.get("decisao", "analisar_profundamente")
+    
+    print(f"   Tipo: {tipo_pergunta}")
+    print(f"   Decisão: {decisao}")
     print(f"   Justificativa: {analise_p1.get('justificativa', 'N/A')[:100]}...")
 
-    # 3. PASSO 2: Análise de PROPÓSITO
+    # 3. SE FOR FACTUAL/DIRETA → Atalho: resposta direta (mas registra histórico dos passos)
+    if tipo_pergunta == "factual_direta" and decisao == "responder_direto":
+        print("\n⚡ ATALHO ATIVADO: Respondendo diretamente...")
+        print("   📝 Registrando justificativas de pulos nos passos 2-4...")
+        
+        # REGISTRAR PULO NO PASSO 2
+        analise_p2_pulo = {
+            "justificativa": f"Passo pulado: pergunta classificada como factual/direta no Passo 1. Não requer análise de propósito para perguntas objetivas com resposta verificável.",
+            "analise": "N/A - Passo não executado (atalho ativado)",
+            "proposito_inferido": "obter_informacao_factual",
+            "confianca": "alta",
+            "decisao": "pular_passo",
+            "pergunta_esclarecimento": None,
+            "passo_pulado": True
+        }
+        historico_passo2_proposito.append(analise_p2_pulo)
+        print(f"   ✓ Passo 2 registrado: {analise_p2_pulo['justificativa'][:80]}...")
+        
+        # REGISTRAR PULO NO PASSO 3
+        analise_p3_pulo = {
+            "justificativa": f"Passo pulado: pergunta factual/direta não requer análise de motivação. Usuário busca informação objetiva, não há contexto emocional ou situacional a explorar.",
+            "analise": "N/A - Passo não executado (atalho ativado)",
+            "motivacao_inferida": "curiosidade_factual",
+            "confianca": "alta",
+            "decisao": "pular_passo",
+            "pergunta_esclarecimento": None,
+            "passo_pulado": True
+        }
+        historico_passo3_motivacao.append(analise_p3_pulo)
+        print(f"   ✓ Passo 3 registrado: {analise_p3_pulo['justificativa'][:80]}...")
+        
+        # REGISTRAR PULO NO PASSO 4
+        analise_p4_pulo = {
+            "justificativa": f"Passo pulado: pergunta factual/direta tem resposta única e objetiva. Não há ambiguidade de cenário, apenas necessidade de verificação factual.",
+            "analise": "N/A - Passo não executado (atalho ativado)",
+            "cenarios_possiveis": None,
+            "confianca": "alta",
+            "decisao": "prosseguir_resposta_final",
+            "pergunta_esclarecimento": None,
+            "passo_pulado": True
+        }
+        historico_passo4_ambiguidade.append(analise_p4_pulo)
+        print(f"   ✓ Passo 4 registrado: {analise_p4_pulo['justificativa'][:80]}...")
+        
+        # GERAR RESPOSTA DIRETA
+        print("\n💬 Gerando resposta direta...")
+        prompt_direto = prompt_resposta_direta(historico_dialogo[:-1], mensagem_usuario, modo_sabio)
+        resposta_final = chamada_gemini(counselor_model, prompt_direto)
+        
+        # Supervisão (se ativada)
+        if modo_supervisor:
+            print("\n🔍 MODO SUPERVISOR: Verificando fatos...")
+            feedback_supervisor = verificar_fatos(resposta_final)
+            if feedback_supervisor:
+                print("   ⚠ Divergências encontradas. Iniciando autocorreção...")
+                resposta_final = autocorrigir(resposta_final, feedback_supervisor)
+            else:
+                print("   ✓ Nenhuma divergência encontrada.")
+        
+        historico_dialogo[-1]["assistant"] = resposta_final
+        print("\n✅ RESPOSTA DIRETA ENVIADA (Passos 2-4 registrados com justificativas de pulo)")
+        print("="*70 + "\n")
+        return resposta_final
+
+    # 4. SE FOR ABERTA/COMPLEXA → Pipeline completa (passos 2-4)
+    print("\n📊 PIPELINE COMPLETA ATIVADA: Analisando em profundidade...")
+    
+    # PASSO 2: Propósito (EXECUÇÃO REAL)
     print("\n🎯 PASSO 2: Analisando PROPÓSITO...")
-    ultimo_p1 = historico_passo1_clareza[-1]
-    prompt2 = prompt_passo2_proposito(historico_dialogo[:-1], historico_passo2_proposito, ultimo_p1)
+    prompt2 = prompt_passo2_proposito(historico_dialogo[:-1], historico_passo2_proposito, analise_p1)
     resposta_p2 = chamada_gemini(counselor_model, prompt2)
     analise_p2 = parse_json_seguro(resposta_p2)
+    analise_p2 = validar_analise_passo(analise_p2, "PASSO 2", ["confianca", "decisao", "justificativa"])
+    analise_p2["passo_pulado"] = False
     historico_passo2_proposito.append(analise_p2)
     print(f"   Confiança: {analise_p2.get('confianca', 'N/A')}")
     print(f"   Decisão: {analise_p2.get('decisao', 'N/A')}")
     print(f"   Justificativa: {analise_p2.get('justificativa', 'N/A')[:100]}...")
 
-    # 4. PASSO 3: Análise de MOTIVAÇÃO
+    # PASSO 3: Motivação (EXECUÇÃO REAL)
     print("\n💡 PASSO 3: Analisando MOTIVAÇÃO...")
-    ultimo_p2 = historico_passo2_proposito[-1]
-    prompt3 = prompt_passo3_motivacao(historico_dialogo[:-1], historico_passo3_motivacao, ultimo_p1, ultimo_p2)
+    prompt3 = prompt_passo3_motivacao(historico_dialogo[:-1], historico_passo3_motivacao, analise_p1, analise_p2)
     resposta_p3 = chamada_gemini(counselor_model, prompt3)
     analise_p3 = parse_json_seguro(resposta_p3)
+    analise_p3 = validar_analise_passo(analise_p3, "PASSO 3", ["confianca", "decisao", "justificativa"])
+    analise_p3["passo_pulado"] = False
     historico_passo3_motivacao.append(analise_p3)
     print(f"   Confiança: {analise_p3.get('confianca', 'N/A')}")
     print(f"   Decisão: {analise_p3.get('decisao', 'N/A')}")
     print(f"   Justificativa: {analise_p3.get('justificativa', 'N/A')[:100]}...")
 
-    # 5. PASSO 4: Análise de AMBIGUIDADE
+    # PASSO 4: Ambiguidade (EXECUÇÃO REAL)
     print("\n🔀 PASSO 4: Analisando AMBIGUIDADE...")
-    ultimo_p3 = historico_passo3_motivacao[-1]
-    prompt4 = prompt_passo4_ambiguidade(historico_dialogo[:-1], historico_passo4_ambiguidade, ultimo_p1, ultimo_p2, ultimo_p3)
+    prompt4 = prompt_passo4_ambiguidade(historico_dialogo[:-1], historico_passo4_ambiguidade, analise_p1, analise_p2, analise_p3)
     resposta_p4 = chamada_gemini(counselor_model, prompt4)
     analise_p4 = parse_json_seguro(resposta_p4)
+    analise_p4 = validar_analise_passo(analise_p4, "PASSO 4", ["confianca", "decisao", "justificativa"])
+    analise_p4["passo_pulado"] = False
     historico_passo4_ambiguidade.append(analise_p4)
     print(f"   Confiança: {analise_p4.get('confianca', 'N/A')}")
     print(f"   Decisão: {analise_p4.get('decisao', 'N/A')}")
     print(f"   Justificativa: {analise_p4.get('justificativa', 'N/A')[:100]}...")
 
-    # 6. SÍNTESE FINAL
+    # 5. SÍNTESE FINAL
     print("\n✨ SINTETIZANDO RESPOSTA FINAL...")
-    ultimo_p4 = historico_passo4_ambiguidade[-1]
-    
-    prompt_final = prompt_sintetizador(historico_dialogo[:-1], ultimo_p1, ultimo_p2, ultimo_p3, ultimo_p4, modo_sabio)
+    prompt_final = prompt_sintetizador(historico_dialogo[:-1], analise_p1, analise_p2, analise_p3, analise_p4, modo_sabio)
     resposta_final = chamada_gemini(counselor_model, prompt_final)
     
-    # 7. SUPERVISÃO (se ativada)
-    if modo_supervisor and ultimo_p4.get('decisao') == 'prosseguir_resposta_final':
+    # Supervisão (apenas para respostas finais, não perguntas de esclarecimento)
+    if modo_supervisor and analise_p4.get('decisao') == 'prosseguir_resposta_final':
         print("\n🔍 MODO SUPERVISOR: Verificando fatos...")
         feedback_supervisor = verificar_fatos(resposta_final)
-        
         if feedback_supervisor:
             print("   ⚠ Divergências encontradas. Iniciando autocorreção...")
             resposta_final = autocorrigir(resposta_final, feedback_supervisor)
+        else:
+            print("   ✓ Nenhuma divergência encontrada.")
     
-    # 8. Atualizar histórico de diálogo
     historico_dialogo[-1]["assistant"] = resposta_final
-    
-    print("\n✅ RESPOSTA ENVIADA AO USUÁRIO")
+    print("\n✅ RESPOSTA COMPLETA ENVIADA (Pipeline completa executada)")
     print("="*70 + "\n")
     
     return resposta_final
@@ -336,25 +502,23 @@ def verificar_fatos(texto: str) -> Optional[str]:
     prompt_supervisor = f"""
 Você é um Supervisor de IA, um fact-checker rigoroso e objetivo.
 
-Sua única tarefa: analisar o texto abaixo em busca de INCORREÇÕES FACTUAIS.
+Analise o texto abaixo em busca de INCORREÇÕES FACTUAIS.
 
 - Analise apenas FATOS verificáveis (datas, nomes, estatísticas, conceitos científicos).
 - NÃO analise opiniões, conselhos filosóficos ou estrutura da resposta.
-- Se encontrar divergências factuais com confiança média ou alta, liste-as claramente.
-- Se NÃO encontrar nenhuma divergência factual, responda APENAS: "NODIVERGENCE"
+- Se encontrar divergências factuais, liste-as claramente.
+- Se NÃO encontrar nenhuma divergência, responda APENAS: "NO_DIVERGENCE"
 
-TEXTO PARA ANÁLISE:
+TEXTO:
 {texto}
 
-SUA RESPOSTA:
+RESPOSTA:
 """
     try:
         resposta = supervisor_model.generate_content(prompt_supervisor)
-        if "NODIVERGENCE" in resposta.text:
-            print("   ✓ Nenhuma divergência factual encontrada.")
+        if "NO_DIVERGENCE" in resposta.text:
             return None
         else:
-            print(f"   ⚠ Divergências: {resposta.text[:200]}...")
             return resposta.text
     except Exception as e:
         print(f"❌ Erro no Supervisor: {e}")
@@ -363,9 +527,9 @@ SUA RESPOSTA:
 def autocorrigir(resposta_original: str, feedback: str) -> str:
     """Solicita autocorreção ao modelo Conselheiro."""
     prompt_correcao = f"""
-Você é um Conselheiro em processo de refinamento.
+Você é um Conselheiro em refinamento.
 
-Sua resposta anterior continha uma imprecisão factual identificada pelo Supervisor.
+Sua resposta continha uma imprecisão factual identificada pelo Supervisor.
 
 SUA RESPOSTA ORIGINAL:
 {resposta_original}
@@ -373,10 +537,10 @@ SUA RESPOSTA ORIGINAL:
 FEEDBACK DO SUPERVISOR (CORREÇÃO):
 {feedback}
 
-SUA TAREFA:
+TAREFA:
 1. Aceite a correção sem ser defensivo.
-2. Reescreva sua resposta integrando a correção de forma natural.
-3. Ao final, adicione uma breve "Nota de Refinamento:" explicando a correção.
+2. Reescreva integrando a correção naturalmente.
+3. Ao final, adicione "Nota de Refinamento:" explicando a correção.
 
 RESPOSTA CORRIGIDA:
 """
@@ -389,12 +553,12 @@ RESPOSTA CORRIGIDA:
 
 # ==================== FUNÇÃO PARA LIMPAR HISTÓRICOS ====================
 def resetar_conversa():
-    """Reseta todos os históricos para iniciar nova conversa."""
-    global historico_dialogo, historico_passo1_clareza, historico_passo2_proposito
+    """Reseta todos os históricos."""
+    global historico_dialogo, historico_passo1_triagem, historico_passo2_proposito
     global historico_passo3_motivacao, historico_passo4_ambiguidade
     
     historico_dialogo = []
-    historico_passo1_clareza = []
+    historico_passo1_triagem = []
     historico_passo2_proposito = []
     historico_passo3_motivacao = []
     historico_passo4_ambiguidade = []
@@ -403,86 +567,70 @@ def resetar_conversa():
 
 # ==================== WRAPPER PARA GRADIO ====================
 def handle_chat(mensagem: str, historico_chat_gradio: List, modo_sabio: bool, modo_supervisor: bool):
-    """Wrapper para integração com Gradio ChatInterface."""
-    
-    # Se é nova conversa (histórico vazio), reseta estados internos
+    """Wrapper para integração com Gradio."""
     if not historico_chat_gradio:
         resetar_conversa()
     
-    # Processa turno
     resposta = processar_turno(mensagem, modo_sabio, modo_supervisor)
-    
     return resposta
 
-# ==================== INTERFACE GRADIO CUSTOMIZADA ====================
-with gr.Blocks(theme="soft") as iface:
-    gr.Markdown("""
-    # 🧠 Parceiro de Raciocínio v10 — Pipeline Fragmentada com Justificativas
-    
-    Sistema de conversação com análise multi-etapa, memória granular e justificativas completas.
+# ==================== INTERFACE GRADIO ====================
+with gr.Blocks(theme="soft", css="""
+    #chatbot-container { height: calc(100vh - 250px); }
+    #input-row { margin-top: 10px; margin-bottom: 10px; }
+""") as iface:
     
-    **Modo Amigo Sábio**: Reflexões filosóficas baseadas em Epicteto (requer epct0.md)  
-    **Modo Supervisor**: Verificação automática de fatos e autocorreção
+    gr.Markdown("""
+    # 🧠 Parceiro de Raciocínio v11 — Pipeline Otimizada com Triagem
     
-    Cada passo mantém histórico completo com justificativas detalhadas da classificação.
+    **Triagem inteligente**: Perguntas factuais → resposta rápida (1 chamada) | Dúvidas complexas → análise profunda (5 chamadas)
     """)
     
-    with gr.Row():
-        with gr.Column(scale=4):
-            chatbot = gr.Chatbot(
-                height=600,
-                label="Diálogo",
-                type="messages",
-                show_copy_button=True
-            )
-        
-        with gr.Column(scale=1):
-            modo_sabio = gr.Checkbox(
-                label="🧘 Modo Amigo Sábio",
-                value=False,
-                info="Ativa reflexões filosóficas baseadas em Epicteto"
-            )
-            modo_supervisor = gr.Checkbox(
-                label="🔍 Modo Supervisor",
-                value=True,
-                info="Ativa verificação de fatos e autocorreção"
-            )
-            
-            gr.Markdown("### 💡 Exemplos")
-            with gr.Column():
-                ex1 = gr.Button("Carreira confusa", size="sm")
-                ex2 = gr.Button("Everest altura", size="sm")
-                ex3 = gr.Button("Ansiedade apresentação", size="sm")
-                ex4 = gr.Button("IA explicação", size="sm")
+    # CHAT (ocupa altura da janela)
+    chatbot = gr.Chatbot(
+        elem_id="chatbot-container",
+        label="Diálogo",
+        type="messages",
+        show_copy_button=True,
+        height="100%"
+    )
     
-    with gr.Row():
+    # INPUT (logo abaixo do chat)
+    with gr.Row(elem_id="input-row"):
         msg = gr.Textbox(
-            placeholder="Digite sua mensagem aqui... (Shift+Enter para nova linha)",
+            placeholder="Digite sua mensagem... (Shift+Enter para nova linha)",
             label="Sua mensagem",
-            lines=3,
-            max_lines=10,
+            lines=2,
+            max_lines=6,
             scale=9,
-            submit_btn=False  # Desabilita envio com Enter
+            submit_btn=False,
+            show_label=False
         )
-        enviar_btn = gr.Button("📤 Enviar", scale=1, variant="primary")
-    
-    limpar_btn = gr.Button("🗑️ Limpar conversa")
+        enviar_btn = gr.Button("📤", scale=1, variant="primary", size="lg")
     
-    # Estado interno
-    state = gr.State([])
+    # CONTROLES E EXEMPLOS (abaixo do input)
+    with gr.Row():
+        with gr.Column(scale=2):
+            with gr.Row():
+                modo_sabio = gr.Checkbox(label="🧘 Modo Amigo Sábio", value=False, scale=1)
+                modo_supervisor = gr.Checkbox(label="🔍 Modo Supervisor", value=True, scale=1)
+                limpar_btn = gr.Button("🗑️ Limpar", scale=1, size="sm")
+        
+        with gr.Column(scale=3):
+            gr.Markdown("**💡 Exemplos:**")
+            with gr.Row():
+                ex1 = gr.Button("📊 Everest altura", size="sm", scale=1)
+                ex2 = gr.Button("🤔 Carreira confusa", size="sm", scale=1)
+                ex3 = gr.Button("📊 Python compilada?", size="sm", scale=1)
+                ex4 = gr.Button("🤔 Ansiedade", size="sm", scale=1)
     
     # Função de envio
     def user_submit(mensagem, historico, modo_sabio_val, modo_supervisor_val):
         if not mensagem.strip():
             return historico, ""
         
-        # Adiciona mensagem do usuário
         historico.append({"role": "user", "content": mensagem})
-        
-        # Processa resposta
         resposta = handle_chat(mensagem, historico, modo_sabio_val, modo_supervisor_val)
-        
-        # Adiciona resposta do assistente
         historico.append({"role": "assistant", "content": resposta})
         
         return historico, ""
@@ -494,7 +642,7 @@ with gr.Blocks(theme="soft") as iface:
         outputs=[chatbot, msg]
     )
     
-    msg.submit(  # Mantém submit para compatibilidade com Shift+Enter
+    msg.submit(
         user_submit,
         inputs=[msg, chatbot, modo_sabio, modo_supervisor],
         outputs=[chatbot, msg]
@@ -502,18 +650,18 @@ with gr.Blocks(theme="soft") as iface:
     
     limpar_btn.click(
         lambda: ([], None),
-        outputs=[chatbot, state]
+        outputs=[chatbot, None]
     ).then(resetar_conversa, outputs=None)
     
     # Exemplos
-    ex1.click(lambda: "Estou confuso sobre qual carreira seguir.", outputs=msg)
-    ex2.click(lambda: "O Monte Everest tem mais de 9.000 metros de altura?", outputs=msg)
-    ex3.click(lambda: "Por que sinto ansiedade antes de apresentações importantes?", outputs=msg)
-    ex4.click(lambda: "Me fale sobre inteligência artificial e seus impactos.", outputs=msg)
+    ex1.click(lambda: "O Monte Everest tem mais de 9.000 metros de altura?", outputs=msg)
+    ex2.click(lambda: "Estou confuso sobre qual carreira seguir.", outputs=msg)
+    ex3.click(lambda: "Python é uma linguagem compilada ou interpretada?", outputs=msg)
+    ex4.click(lambda: "Como posso lidar com ansiedade antes de apresentações?", outputs=msg)
 
 # ==================== EXECUÇÃO ====================
 if __name__ == "__main__":
     print("\n" + "="*70)
-    print("🚀 Iniciando Parceiro de Raciocínio v10 - Pipeline Fragmentada")
+    print("🚀 Iniciando Parceiro de Raciocínio v11 - Pipeline Fragmentada com Triagem")
     print("="*70 + "\n")
     iface.launch()