Update app.py

app.py

@@ -1,355 +1,414 @@
 # ╔════════════════════════════════════════════════════════════════════════════╗
-# ║ PIPELINE v29: MEMÓRIA VAGA + CONTEXTO GLOBAL                               ║
-# ║ Layout: Chat | Depuração | Contexto | Config                               ║
+# ║ PIPELINE EPISTÊMICO v28: Protocolo Causal de 10 Fases                    ║
+# ║ Resolução do Paradoxo de Ménon aplicado à investigação forense           ║
 # ╚════════════════════════════════════════════════════════════════════════════╝
 
 import os
 import json
 import time
 from datetime import datetime
-
 import gradio as gr
 import google.generativeai as genai
 
 # ==================== 1. CONFIGURAÇÃO ====================
 
 api_key = os.getenv("GOOGLE_API_KEY", "SUA_API_KEY_AQUI")
-if api_key:
+if api_key: 
     genai.configure(api_key=api_key)
 
-model_flash = genai.GenerativeModel("gemini-flash-latest")
-model_pro = genai.GenerativeModel("gemini-pro-latest")
-
-ARQUIVO_CONFIG = "protocolo.json"
-ARQUIVO_CONTEXTO = "contexto.json"
+model_flash = genai.GenerativeModel("gemini-2.0-flash-exp")
+model_pro = genai.GenerativeModel("gemini-1.5-pro-002")
 
+ARQUIVO_CONFIG = "protocolo_epistemico_forense.json"
+MAX_ITERACOES = 3  # Máximo de voltas Fase 7 → Fase 3
 
 # ==================== 2. UTILIDADES ====================
 
 def carregar_protocolo():
+    """Carrega configuração do protocolo"""
     try:
         with open(ARQUIVO_CONFIG, "r", encoding="utf-8") as f:
             return f.read()
     except:
         return "[]"
 
-
 def salvar_protocolo(conteudo):
+    """Salva e valida JSON do protocolo"""
     try:
         json.loads(conteudo)
         with open(ARQUIVO_CONFIG, "w", encoding="utf-8") as f:
             f.write(conteudo)
-        return "✅ Salvo"
-    except:
-        return "❌ Erro JSON"
-
+        return "✅ Protocolo salvo com sucesso"
+    except Exception as e:
+        return f"❌ Erro no JSON: {str(e)}"
 
 def ler_anexo(arquivo):
+    """Lê arquivo anexado"""
     if arquivo is None:
         return ""
     try:
         with open(arquivo.name, "r", encoding="utf-8") as f:
-            return (
-                f"\n\n[ANEXO SISTEMA: {os.path.basename(arquivo.name)}]\n"
-                f"{f.read()}\n[FIM ANEXO]\n"
-            )
-    except:
-        return ""
-
+            conteudo = f.read()
+        return f"\n\n--- ANEXO: {os.path.basename(arquivo.name)} ---\n{conteudo}\n--- FIM ANEXO ---\n"
+    except Exception as e:
+        return f"\n[ERRO ao ler anexo: {e}]\n"
 
-# -------- CONTEXTO GLOBAL (MEMÓRIA VAGA) --------
+# ==================== 3. ENGINE DE EXECUÇÃO ====================
 
-def contexto_vazio():
-    return {
-        "classificacao": "",
-        "fatos": [],
-        "objetivo_usuario": "",
-        "duvida_central_ultimos_input": "",
-        "timestamp": ""
-    }
+def executar_fase(timeline, config, fase_atual, total_fases):
+    """Executa uma fase do protocolo"""
 
+    # Selecionar modelo
+    modelo = model_pro if config.get("modelo") == "pro" else model_flash
 
-def carregar_contexto():
-    try:
-        with open(ARQUIVO_CONTEXTO, "r", encoding="utf-8") as f:
-            return json.load(f)
-    except:
-        return contexto_vazio()
+    # Construir contexto com toda a timeline
+    contexto = json.dumps(timeline, ensure_ascii=False, indent=2)
 
+    # Prompt estruturado
+    prompt = f"""--- TIMELINE COMPLETA ---
+{contexto}
 
-def salvar_contexto(ctx):
-    try:
-        with open(ARQUIVO_CONTEXTO, "w", encoding="utf-8") as f:
-            json.dump(ctx, f, ensure_ascii=False, indent=2)
-        return ctx
-    except:
-        return ctx
+--- FASE ATUAL ---
+AGENTE: {config['nome']}
+FASE: {fase_atual}/{total_fases}
+TIPO_SAIDA: {config['tipo_saida']}
 
+--- MISSÃO ---
+{config['missao']}
 
-def atualizar_contexto(full_input, timeline, contexto_anterior):
-    """
-    Agente MEMÓRIA VAGA:
-    - Só escuta o diálogo e o histórico.
-    - Atualiza e retorna APENAS o JSON de contexto global.
-    - Nunca escreve na timeline, nunca responde ao usuário.
-    """
-    base_ctx = contexto_vazio()
-    ctx_prev = contexto_anterior if contexto_anterior else contexto_vazio()
-
-    modelo = model_pro  # memória usa sempre o modelo mais robusto
-
-    instrucao = (
-        "Você está atuando como um 'ouvinte' que mantém um MEMORIAL do diálogo, "
-        "na posição de Promotor de Justiça em casos de violência doméstica. "
-        "Você NÃO responde ao usuário, NÃO sugere decisões, "
-        "apenas organiza o que é importante em um JSON de CONTEXTO GLOBAL.\n\n"
-        "TAREFA:\n"
-        "- Ler o input atual, o contexto anterior e a timeline.\n"
-        "- Atualizar o CONTEXTO GLOBAL com:\n"
-        "  * classificacao: \"duvida\" ou \"critica\" (ou vazio se não se aplicar).\n"
-        "  * fatos: lista de objetos {\"descricao\": str, \"peso\": float, \"ultima_mencao\": str ISO8601}\n"
-        "    representando elementos factuais relevantes do caso, com peso de 0.0 a 1.0.\n"
-        "    - Fatos que voltam a aparecer podem ter peso aumentado.\n"
-        "    - Fatos que deixam de aparecer podem ter peso suavemente reduzido.\n"
-        "  * objetivo_usuario: 1 frase objetiva sobre o que o usuário quer alcançar agora.\n"
-        "  * duvida_central_ultimos_input: síntese em 1–2 frases da dúvida/foco do último input.\n"
-        "  * timestamp: momento atual em ISO8601.\n\n"
-        "IMPORTANTE:\n"
-        "- Não explique, não comente. Retorne APENAS um JSON válido.\n"
-        "- Mantenha a mesma estrutura de chaves do contexto_anterior, atualizando o que fizer sentido.\n"
-    )
+--- INSTRUÇÕES ---
+1. Analise TODA a timeline acima
+2. Execute sua missão com rigor
+3. {"Retorne APENAS JSON válido" if config['tipo_saida'] == 'json' else "Retorne texto em Markdown"}
+4. Seja epistemicamente honesto sobre incertezas
+"""
 
-    payload = {
-        "input_atual": full_input,
-        "contexto_anterior": ctx_prev,
-        "timeline": timeline,
-    }
-
-    schema_exemplo = base_ctx
-
-    prompt = (
-        instrucao
-        + "\n\n--- DADOS ---\n"
-        + json.dumps(payload, ensure_ascii=False, indent=2)
-        + "\n\n--- SCHEMA EXATO A SEGUIR ---\n"
-        + json.dumps(schema_exemplo, ensure_ascii=False, indent=2)
-        + "\n\n--- SAÍDA ---\n"
-        + "Retorne APENAS um JSON válido seguindo o schema (sem comentários, sem texto extra)."
-    )
+    log = f"\n🔸 Fase {fase_atual}: {config['nome']}"
 
     try:
-        resp = modelo.generate_content(prompt)
-        raw = resp.text.strip()
-        cleaned = raw.replace("``````", "").strip()
-        novo_ctx = json.loads(cleaned)
-
-        # Garantir chaves mínimas
-        for k, v in base_ctx.items():
-            if k not in novo_ctx:
-                novo_ctx[k] = v
-
-        return novo_ctx
-    except Exception:
-        # Fallback: preserva memória antiga e marca timestamp / classificação mínima
-        ctx_fallback = ctx_prev
-        ctx_fallback["timestamp"] = datetime.now().isoformat()
-        if "?" in full_input:
-            ctx_fallback["classificacao"] = "duvida"
-        return ctx_fallback
-
-
-# ==================== 3. ENGINE DE EXECUÇÃO (AGENTES) ====================
-
-def executar_no(timeline, config, contexto):
-    """
-    Executa um nó do protocolo:
-    - Recebe timeline + contexto global (memória vaga).
-    - Gera resposta de agente (texto ou JSON).
-    """
-    modelo = model_pro if config.get("modelo") == "pro" else model_flash
-
-    contexto_timeline = json.dumps(timeline, ensure_ascii=False, indent=2)
-    contexto_global = json.dumps(contexto, ensure_ascii=False, indent=2)
-
-    prompt = (
-        f"--- CONTEXTO GLOBAL (MEMÓRIA DE QUEM OUVE) ---\n{contexto_global}\n"
-        f"--- TIMELINE ---\n{contexto_timeline}\n"
-        f"----------------\n"
-        f"AGENTE: {config['nome']}\n"
-        f"MISSÃO: {config['missao']}"
-    )
+        inicio = time.time()
 
-    log = f"\n🔸 {config['nome']}..."
+        # Executar com retry
+        max_tentativas = 2
+        for tentativa in range(max_tentativas):
+            try:
+                resp = modelo.generate_content(
+                    prompt,
+                    generation_config={
+                        "temperature": 0.3 if config['tipo_saida'] == 'json' else 0.7,
+                        "max_output_tokens": 8000
+                    }
+                )
+                output_raw = resp.text
+                break
+            except Exception as e:
+                if tentativa == max_tentativas - 1:
+                    raise e
+                time.sleep(2)
 
-    try:
-        inicio = time.time()
-        resp = modelo.generate_content(prompt)
-        out = resp.text
         tempo = time.time() - inicio
 
-        if config.get("tipo_saida") == "json":
-            cleaned = out.strip().replace("``````", "")
-            content = json.loads(cleaned)
+        # Processar output
+        if config['tipo_saida'] == 'json':
+            # Limpar markdown
+            output_limpo = output_raw.strip()
+            output_limpo = output_limpo.replace('```json', '').replace('```', '')
+            content = json.loads(output_limpo)
         else:
-            content = out
+            content = output_raw
 
-        log += f" (OK - {tempo:.2f}s)"
+        log += f" ✓ ({tempo:.1f}s)"
 
-        return {"role": "assistant", "agent": config["nome"], "content": content}, log, out
+        return {
+            "role": "assistant",
+            "agent": config['nome'],
+            "fase": config['fase'],
+            "content": content
+        }, log, True
 
     except Exception as e:
-        return {"role": "system", "error": str(e)}, f" (ERRO: {e})", str(e)
+        log += f" ✗ ERRO: {str(e)[:100]}"
+        return {
+            "role": "system",
+            "agent": config['nome'],
+            "fase": config['fase'],
+            "error": str(e)
+        }, log, False
 
-
-# ==================== 4. ORQUESTRADOR ====================
+# ==================== 4. ORQUESTRADOR COM LOOP ITERATIVO ====================
 
 def orquestrador(texto, arquivo, history, json_config):
-    # 1. Input Check
+    """Orquestra execução do protocolo de 10 fases com loop iterativo"""
+
+    # 1. Validar input
     anexo = ler_anexo(arquivo)
     full_input = f"{texto}\n{anexo}".strip()
 
-    contexto = carregar_contexto()
-
     if not full_input:
-        yield history, {}, "Sem input.", contexto
+        yield history, {}, "⚠️ Nenhum input fornecido."
         return
 
-    # 2. Setup histórico
+    # 2. Setup
     history = history + [[texto + (" 📎" if arquivo else ""), None]]
 
     try:
         protocolo = json.loads(json_config)
-    except:
-        history[-1][1] = "❌ Erro no JSON de Configuração."
-        yield history, {}, "Erro JSON", contexto
+    except Exception as e:
+        history[-1][1] = f"❌ **Erro no JSON de Configuração**\n\n```\n{str(e)}\n```"
+        yield history, {}, f"Erro JSON: {e}"
         return
 
-    # Timeline começa só com o usuário
-    timeline = [{"role": "user", "content": full_input}]
+    # 3. Inicializar timeline
+    timeline = [{
+        "role": "user",
+        "content": full_input,
+        "timestamp": datetime.now().isoformat()
+    }]
+
+    logs = f"🚀 INÍCIO: {datetime.now().strftime('%H:%M:%S')}\n"
+    logs += f"📋 Protocolo: {len(protocolo)} fases\n"
+    logs += f"🔄 Max iterações: {MAX_ITERACOES}\n"
+    logs += "=" * 60 + "\n"
+
+    history[-1][1] = "⏳ **Iniciando Protocolo Epistêmico...**\n\nFase 0/10: Estado Inicial"
+    yield history, timeline, logs
+
+    # 4. Executar fases 0-6 (sequenciais)
+    fases_sequenciais = [f for f in protocolo if f['fase'] < 7]
+
+    for cfg in fases_sequenciais:
+        fase_num = cfg['fase']
+        history[-1][1] = f"⚙️ **Fase {fase_num}/10: {cfg['nome']}**\n\nProcessando..."
+        yield history, timeline, logs
+
+        resultado, log_add, sucesso = executar_fase(timeline, cfg, fase_num, 10)
+        timeline.append(resultado)
+        logs += log_add + "\n"
+
+        if not sucesso:
+            history[-1][1] = f"❌ **Erro na Fase {fase_num}**\n\n{resultado.get('error', 'Erro desconhecido')}"
+            yield history, timeline, logs
+            return
+
+        yield history, timeline, logs
+
+    # 5. Loop iterativo: Fases 7 (teste) ↔ Fases 3-6 (refinamento)
+    iteracao = 0
+    fase_7_passou = False
 
-    # 3. MEMÓRIA VAGA: atualiza contexto ANTES de qualquer agente responder
-    contexto = atualizar_contexto(full_input, timeline, contexto)
-    salvar_contexto(contexto)
+    while iteracao < MAX_ITERACOES and not fase_7_passou:
+        iteracao += 1
+        logs += f"\n{'='*60}\n🔄 ITERAÇÃO {iteracao}/{MAX_ITERACOES}\n{'='*60}\n"
 
-    logs = f"🚀 START: {datetime.now().strftime('%H:%M:%S')}\n"
+        # Se não é primeira vez, re-executar fases 3-6
+        if iteracao > 1:
+            history[-1][1] = f"🔄 **Iteração {iteracao}**: Refinando cenários (Fases 3-6)..."
+            yield history, timeline, logs
 
-    history[-1][1] = "⏳ Iniciando análise..."
-    yield history, timeline, logs, contexto
+            fases_refinamento = [f for f in protocolo if 3 <= f['fase'] < 7]
+            for cfg in fases_refinamento:
+                resultado, log_add, sucesso = executar_fase(timeline, cfg, cfg['fase'], 10)
+                timeline.append(resultado)
+                logs += log_add + "\n"
 
-    # 4. Loop de nós do protocolo
-    final_response = ""
+                if not sucesso:
+                    history[-1][1] = f"❌ **Erro no refinamento**"
+                    yield history, timeline, logs
+                    return
 
-    for cfg in protocolo:
-        history[-1][1] = f"⚙️ {cfg['nome']} trabalhando..."
-        yield history, timeline, logs, contexto
+                yield history, timeline, logs
 
-        res, log_add, raw = executar_no(timeline, cfg, contexto)
-        timeline.append(res)
+        # Executar Fase 7: TESTE_CRUCIALIDADE
+        cfg_fase7 = next(f for f in protocolo if f['fase'] == 7)
+        history[-1][1] = f"🧪 **Fase 7/10: Teste de Crucialidade** (Iteração {iteracao})\n\nValidando..."
+        yield history, timeline, logs
+
+        resultado, log_add, sucesso = executar_fase(timeline, cfg_fase7, 7, 10)
+        timeline.append(resultado)
         logs += log_add + "\n"
 
-        # Após cada nó, a memória vaga reouve tudo e atualiza o contexto
-        contexto = atualizar_contexto(full_input, timeline, contexto)
-        salvar_contexto(contexto)
+        if not sucesso:
+            history[-1][1] = f"❌ **Erro na Fase 7**"
+            yield history, timeline, logs
+            return
+
+        # Verificar se passou no teste
+        teste_resultado = resultado['content']
+        fase_7_passou = teste_resultado.get('PASSOU', False)
+        score = teste_resultado.get('SCORE_CRUCIALIDADE', 0)
+
+        if fase_7_passou:
+            logs += f"✅ TESTE PASSOU (score: {score:.3f})\n"
+            history[-1][1] = f"✅ **Validação Aprovada!**\n\nScore: {score:.3f}"
+        else:
+            logs += f"⚠️ TESTE FALHOU (score: {score:.3f})\n"
+            fragilidades = teste_resultado.get('FRAGILIDADES_IDENTIFICADAS', [])
+            history[-1][1] = f"⚠️ **Validação Reprovada** (Score: {score:.3f})\n\nFragilidades:\n" + "\n".join(f"- {f}" for f in fragilidades)
+
+        yield history, timeline, logs
+
+    if not fase_7_passou:
+        logs += f"\n⚠️ Limite de iterações atingido ({MAX_ITERACOES}). Prosseguindo com melhor resultado.\n"
+
+    # 6. Fases finais 8-9 (sempre executam)
+    fases_finais = [f for f in protocolo if f['fase'] >= 8]
+
+    for cfg in fases_finais:
+        fase_num = cfg['fase']
+        history[-1][1] = f"📝 **Fase {fase_num}/10: {cfg['nome']}**\n\nGerando..."
+        yield history, timeline, logs
+
+        resultado, log_add, sucesso = executar_fase(timeline, cfg, fase_num, 10)
+        timeline.append(resultado)
+        logs += log_add + "\n"
 
-        if cfg.get("tipo_saida") == "texto" and res.get("role") == "assistant":
-            final_response = res.get("content", "")
+        if not sucesso:
+            history[-1][1] = f"❌ **Erro na Fase {fase_num}**"
+            yield history, timeline, logs
+            return
+
+        # Se for a fase final (9 - RELATORIO_FINAL), mostrar resultado
+        if cfg['fase'] == 9 and cfg['tipo_saida'] == 'texto':
+            final_response = resultado['content']
             history[-1][1] = final_response
-            yield history, timeline, logs, contexto
 
-    logs += "✅ FIM."
-    yield history, timeline, logs, contexto
+        yield history, timeline, logs
+
+    # 7. Finalizar
+    logs += "\n" + "=" * 60 + "\n"
+    logs += f"✅ CONCLUÍDO: {datetime.now().strftime('%H:%M:%S')}\n"
+    logs += f"📊 Total de fases executadas: {len([t for t in timeline if t.get('fase') is not None])}\n"
+    logs += f"🔄 Iterações necessárias: {iteracao}\n"
+
+    yield history, timeline, logs
 
+# ==================== 5. UI COM GRADIO ====================
 
-# ==================== 5. UI LIMPA (v29) ====================
+def criar_ui():
+    """Cria interface Gradio"""
 
-def ui_clean():
     css = """
     footer {display: none !important;}
     .contain {border: none !important;}
     """
 
-    config_init = carregar_protocolo()
+    config_inicial = carregar_protocolo()
+
+    with gr.Blocks(
+        title="🔬 Investigador Epistêmico",
+        css=css,
+        theme=gr.themes.Soft()
+    ) as app:
+
+        gr.Markdown("""
+        # 🔬 Investigador Epistêmico
+        ### Protocolo Causal de 10 Fases | Resolução do Paradoxo de Ménon
+        """)
 
-    with gr.Blocks(title="AI Forensics", css=css, theme=gr.themes.Soft()) as app:
         with gr.Tabs():
 
-            # === ABA 1: CHAT (LIMPO) ===
-            with gr.Tab("💬 Investigador"):
+            # === ABA 1: INVESTIGAÇÃO ===
+            with gr.Tab("💬 Investigação"):
                 chatbot = gr.Chatbot(
                     label="",
                     show_label=False,
-                    height=600,
+                    height=650,
                     show_copy_button=True,
-                    render_markdown=True,
+                    render_markdown=True
                 )
 
                 with gr.Row():
                     with gr.Column(scale=10):
-                        txt_in = gr.Textbox(
+                        txt_input = gr.Textbox(
                             show_label=False,
-                            placeholder="Descreva o caso ou instrução...",
-                            lines=1,
-                            max_lines=5,
-                            container=False,
+                            placeholder="Descreva o caso, pergunta ou situação a investigar...",
+                            lines=2,
+                            max_lines=8,
+                            container=False
                         )
-                    with gr.Column(scale=1, min_width=50):
-                        file_in = gr.UploadButton(
+
+                    with gr.Column(scale=1, min_width=60):
+                        file_input = gr.UploadButton(
                             "📎",
-                            file_types=[".txt", ".md", ".csv", ".json"],
-                            size="sm",
-                        )
-                    with gr.Column(scale=1, min_width=80):
-                        btn_send = gr.Button(
-                            "Enviar",
-                            variant="primary",
-                            size="sm",
+                            file_types=[".txt", ".md", ".csv", ".json", ".pdf"],
+                            size="sm"
                         )
 
-                # Feedback visual do arquivo
+                    with gr.Column(scale=1, min_width=100):
+                        btn_enviar = gr.Button("🚀 Investigar", variant="primary", size="sm")
+
                 file_status = gr.Markdown("", visible=True)
-                file_in.upload(
-                    lambda x: f"📎 Anexo: {os.path.basename(x.name)}",
-                    file_in,
-                    file_status,
+                file_input.upload(
+                    lambda x: f"📎 **Anexo:** {os.path.basename(x.name)}", 
+                    file_input, 
+                    file_status
                 )
 
             # === ABA 2: DEPURAÇÃO ===
             with gr.Tab("🕵️ Depuração"):
-                with gr.Row():
-                    out_dna = gr.JSON(label="DNA (Timeline)")
-                    out_logs = gr.Textbox(label="Logs do Sistema", lines=20)
+                gr.Markdown("### Timeline Completa (DNA da Investigação)")
+                output_timeline = gr.JSON(label="Timeline")
+
+                gr.Markdown("### Logs do Sistema")
+                output_logs = gr.Textbox(label="Logs", lines=25, max_lines=50)
 
-            # === ABA 3: CONTEXTO GLOBAL ===
-            with gr.Tab("🧠 Contexto"):
-                contexto_json = gr.JSON(label="Contexto Global (contexto.json)")
+            # === ABA 3: CONFIGURAÇÃO ===
+            with gr.Tab("⚙️ Configuração"):
+                gr.Markdown("""
+                ### Protocolo Epistêmico (JSON)
+
+                **Estrutura de cada fase:**
+                - `fase`: Número da fase (0-9)
+                - `nome`: Identificador da fase
+                - `modelo`: "flash" ou "pro"
+                - `tipo_saida`: "json" ou "texto"
+                - `missao`: Instruções detalhadas
+
+                **Fluxo:** 0→1→2→3→4→5→6→7(teste)→[volta 3 se falhar]→8→9
+                """)
 
-            # === ABA 4: CONFIG (TÉCNICO) ===
-            with gr.Tab("⚙️ Config"):
                 with gr.Row():
-                    btn_save = gr.Button("Salvar Config")
-                    lbl_save = gr.Label(show_label=False)
-                code_json = gr.Code(
-                    value=config_init,
+                    btn_salvar = gr.Button("💾 Salvar Protocolo", variant="primary")
+                    label_salvar = gr.Label(show_label=False)
+
+                code_protocolo = gr.Code(
+                    value=config_inicial,
                     language="json",
-                    label="protocolo.json",
-                )
-                btn_save.click(salvar_protocolo, code_json, lbl_save)
-
-            # === TRIGGERS ===
-            triggers = [btn_send.click, txt_in.submit]
-
-            for trig in triggers:
-                trig(
-                    orquestrador,
-                    inputs=[txt_in, file_in, chatbot, code_json],
-                    outputs=[chatbot, out_dna, out_logs, contexto_json],
-                ).then(
-                    lambda: (None, ""),
-                    outputs=[txt_in, file_status],
+                    label="protocolo_epistemico_forense.json",
+                    lines=30
                 )
 
+                btn_salvar.click(salvar_protocolo, code_protocolo, label_salvar)
+
+        # === EVENTOS ===
+        triggers = [btn_enviar.click, txt_input.submit]
+
+        for trigger in triggers:
+            trigger(
+                orquestrador,
+                inputs=[txt_input, file_input, chatbot, code_protocolo],
+                outputs=[chatbot, output_timeline, output_logs]
+            ).then(
+                lambda: (None, ""),
+                outputs=[txt_input, file_status]
+            )
+
     return app
 
+# ==================== 6. MAIN ====================
 
 if __name__ == "__main__":
-    ui_clean().launch()
+    print("=" * 80)
+    print("🔬 INVESTIGADOR EPISTÊMICO - Protocolo Causal v28")
+    print("=" * 80)
+    print(f"📋 Arquivo de configuração: {ARQUIVO_CONFIG}")
+    print(f"🔄 Máximo de iterações: {MAX_ITERACOES}")
+    print("=" * 80)
+
+    app = criar_ui()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )