Update app.py

app.py

@@ -1,3 +1,7 @@
+# ╔════════════════════════════════════════════════════════════════════════════╗
+# ║  PIPELINE V44: FRAG + VISÃO PAGINADA + PARALELISMO + CACHE + AUDITORIA     ║
+# ╚════════════════════════════════════════════════════════════════════════════╝
+
 import os
 import json
 import time
@@ -7,42 +11,48 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 
 import gradio as gr
 import google.generativeai as genai
-
-# Dependências para PDF
-try:
-    import PyPDF2
-    PDF_SUPPORT = True
-except ImportError:
-    PDF_SUPPORT = False
-    print("⚠️  PyPDF2 não instalado. Install: pip install PyPDF2")
+import pypdf  # pip install pypdf
 
 # ==================== 1. CONFIGURAÇÃO ====================
 
 api_key = os.getenv("GOOGLE_API_KEY", "SUA_API_KEY_AQUI")
-if api_key and api_key != "SUA_API_KEY_AQUI": 
+if api_key and api_key != "SUA_API_KEY_AQUI":
     genai.configure(api_key=api_key)
 
 model_flash = genai.GenerativeModel("gemini-flash-latest")
-model_pro = genai.GenerativeModel("gemini-pro-latest")
+model_pro   = genai.GenerativeModel("gemini-pro-latest")
 
-ARQUIVO_CONFIG = "protocolo.json"
-PASTA_TRANSCRICOES = "transcricoes"
-PAGES_PER_CHUNK = 10
-MAX_WORKERS = 5  # Limite de chamadas paralelas
+ARQUIVO_CONFIG = "protocolo_fragmentacao_visao-3.json"
+PASTA_CACHE = "cache_processamento"
+MAX_WORKERS = 5  # Paralelismo
 
-os.makedirs(PASTA_TRANSCRICOES, exist_ok=True)
+os.makedirs(PASTA_CACHE, exist_ok=True)
 
 # ==================== 2. UTILIDADES ====================
 
+def log_point(msg, logs):
+    ts = datetime.now().strftime("%H:%M:%S")
+    return logs + f"[{ts}] {msg}\n"
+
 def carregar_protocolo():
     try:
         with open(ARQUIVO_CONFIG, "r", encoding="utf-8") as f:
             return f.read()
     except:
-        return json.dumps([
-            {"nome": "Leitor", "modelo": "flash", "missao": "Resumir o documento"},
-            {"nome": "Investigador", "modelo": "pro", "missao": "Encontrar inconsistências"}
-        ], indent=2)
+        proto = [
+            {
+                "nome": "PAGINADOR_VISUAL",
+                "missao": (
+                    "Você recebe o texto bruto de um conjunto de páginas de um PDF. "
+                    "Separe por página e devolva uma lista JSON com objetos "
+                    "{'pagina','transcricao_fiel','descricao_visual'}."
+                    "Retorne APENAS essa lista JSON, sem texto extra."
+                ),
+                "tipo_saida": "json",
+                "modelo": "flash",
+            }
+        ]
+        return json.dumps(proto, ensure_ascii=False, indent=2)
 
 def salvar_protocolo(conteudo):
     try:
@@ -53,434 +63,348 @@ def salvar_protocolo(conteudo):
     except:
         return "❌ Erro JSON"
 
-def limpar_nome_arquivo(nome):
-    nome_base = os.path.basename(nome)
-    nome_limpo = "".join([c for c in nome_base if c.isalnum() or c in (' ', '.', '_', '-')]).strip()
-    return nome_limpo + ".json"
+def gerar_hash_arquivo(nome_arquivo):
+    return hashlib.md5(nome_arquivo.encode()).hexdigest()
 
-def extrair_texto_pdf(caminho_pdf):
-    try:
-        with open(caminho_pdf, 'rb') as f:
-            reader = PyPDF2.PdfReader(f)
-            paginas = []
-            for i, page in enumerate(reader.pages):
-                texto = page.extract_text()
-                paginas.append({
-                    "numero": i + 1,
-                    "texto": texto,
-                    "metadata": str(page)[:200]
-                })
-            return paginas, None
-    except Exception as e:
-        return None, str(e)
-
-def fragmentar_pdf(paginas, tamanho_chunk=PAGES_PER_CHUNK):
-    chunks = []
-    for i in range(0, len(paginas), tamanho_chunk):
-        chunk = paginas[i:i + tamanho_chunk]
-        num_inicio = chunk[0]["numero"]
-        num_fim = chunk[-1]["numero"]
-        
-        texto_consolidado = "\n---QUEBRA DE PÁGINA---\n".join(
-            [f"[PÁGINA {p['numero']}]\n{p['texto']}" for p in chunk]
-        )
-        
-        chunks.append({
-            "id": f"chunk_{num_inicio}_{num_fim}",
-            "paginas": f"{num_inicio}-{num_fim}",
-            "num_paginas": len(chunk),
-            "texto": texto_consolidado,
-            "metadata": [p["metadata"] for p in chunk]
-        })
-    return chunks
+def salvar_cache(hash_id, dados):
+    caminho = os.path.join(PASTA_CACHE, f"{hash_id}.json")
+    with open(caminho, "w", encoding="utf-8") as f:
+        json.dump(dados, f, ensure_ascii=False, indent=2)
 
-def processar_pdf_completo(arquivo_pdf):
-    if not PDF_SUPPORT:
-        return None, "❌ PyPDF2 não disponível"
-    
-    try:
-        paginas, erro = extrair_texto_pdf(arquivo_pdf.name if hasattr(arquivo_pdf, 'name') else arquivo_pdf)
-        if erro:
-            return None, f"❌ Erro ao ler PDF: {erro}"
-        
-        chunks = fragmentar_pdf(paginas)
-        nome_arquivo = os.path.basename(arquivo_pdf.name if hasattr(arquivo_pdf, 'name') else arquivo_pdf)
-        
-        return {
-            "arquivo": nome_arquivo,
-            "total_paginas": len(paginas),
-            "total_chunks": len(chunks),
-            "chunks": chunks,
-            "tipo": "pdf"
-        }, None
-    except Exception as e:
-        return None, f"❌ Erro no processamento: {str(e)}"
+def carregar_cache(hash_id):
+    caminho = os.path.join(PASTA_CACHE, f"{hash_id}.json")
+    if os.path.exists(caminho):
+        with open(caminho, "r", encoding="utf-8") as f:
+            return json.load(f)
+    return None
 
-def ler_arquivo_texto(arquivo):
-    if arquivo is None: return None
-    try:
-        with open(arquivo.name, "r", encoding="utf-8") as f:
-            conteudo = f.read()
-        return {
-            "arquivo": os.path.basename(arquivo.name),
-            "conteudo": conteudo,
-            "tipo": "texto"
-        }
-    except: return None
+# --------- DIVISÃO PDF ---------
 
-# ==================== 3. PIPELINE DE IA ====================
+def ler_anexo_e_fragmentar(arquivo, paginas_por_fragmento=5, logs=""):
+    logs = log_point("ler_anexo_e_fragmentar() chamado", logs)
 
-def transcrever_chunk(chunk_data, config_agentes):
-    # Função auxiliar para ser executada na thread
-    modelo = model_flash
-    try:
-        if config_agentes and isinstance(config_agentes, list):
-            if config_agentes[0].get("modelo") == "pro":
-                modelo = model_pro
-    except:
-        pass
+    if arquivo is None:
+        return [], "", logs
+
+    filename = getattr(arquivo, "name", arquivo)
     
-    prompt = f"""
-ANÁLISE DE DOCUMENTO (OCR/LEITURA):
-Transcreva e estruture o conteúdo das páginas {chunk_data['paginas']}.
-Texto extraído:
-{chunk_data['texto']}
-
-Retorne JSON: {{ "transcricao": "...", "objetos": ["..."], "resumo": "..." }}
-"""
+    if not os.path.exists(filename):
+        return [], f"[ERRO: Arquivo não encontrado]", logs
+
+    anexo_info = f"[PDF: {os.path.basename(filename)}]"
+
+    if not filename.lower().endswith(".pdf"):
+        logs = log_point("Arquivo texto simples detectado", logs)
+        try:
+            with open(filename, "r", encoding="utf-8") as f:
+                texto = f.read()
+            # Retorna como um único fragmento de texto
+            return [texto], f"[TXT: {os.path.basename(filename)}]", logs
+        except:
+            return [], "[ERRO LEITURA TXT]", logs
+
     try:
-        # Retry simples em caso de erro 429 (rate limit)
-        for tentativa in range(3):
-            try:
-                resposta = modelo.generate_content(prompt)
-                texto_resp = resposta.text.replace("```json", "").replace("```", "")
-                return json.loads(texto_resp.strip()), None
-            except Exception as inner_e:
-                if "429" in str(inner_e):
-                    time.sleep(2 * (tentativa + 1))
-                    continue
-                raise inner_e
+        reader = pypdf.PdfReader(filename)
+        total_pages = len(reader.pages)
+        logs = log_point(f"PDF carregado: {total_pages} páginas", logs)
+
+        fragments = []
+        for i in range(0, total_pages, paginas_por_fragmento):
+            start = i + 1
+            end = min(i + paginas_por_fragmento, total_pages)
+
+            bloco_texto = ""
+            for p in range(i, end):
+                try:
+                    t = reader.pages[p].extract_text() or ""
+                except Exception as e:
+                    t = f"\n[ERRO_EXTRACT_PAG_{p+1}: {e}]\n"
+                bloco_texto += f"\n=== PAGINA {p+1}/{total_pages} ===\n{t}\n"
+
+            fragment = (
+                f"=== FRAG {i//paginas_por_fragmento + 1} "
+                f"(PÁGS {start}-{end}/{total_pages}) ===\n"
+                f"{bloco_texto.strip()}"
+            )
+            fragments.append(fragment)
+
+        logs = log_point(f"Total de fragmentos criados: {len(fragments)}", logs)
+        return fragments, anexo_info, logs
     except Exception as e:
-        return None, str(e)
+        logs = log_point(f"ERRO PDF: {e}", logs)
+        return [], f"[ERRO PDF: {str(e)}]", logs
 
-# ==================== 4. GERENCIADOR DE ARQUIVOS ====================
+# ==================== 3. ENGINE DE EXECUÇÃO ====================
 
-class GerenciadorArquivos:
-    def __init__(self):
-        self.arquivos = {} 
+def _extrair_json_possivel(out_raw: str) -> str:
+    cleaned = out_raw.strip()
+    idx_abre_col = cleaned.find("[")
+    idx_abre_obj = cleaned.find("{")
 
-    def adicionar(self, arquivo, arquivo_id):
-        self.arquivos[arquivo_id] = {
-            "arquivo": arquivo,
-            "nome": os.path.basename(arquivo.name),
-            "status": "adicionado",
-            "processado": None,
-            "transcricao": None
-        }
+    candidatos = [i for i in [idx_abre_col, idx_abre_obj] if i != -1]
+    if candidatos:
+        start = min(candidatos)
+        cleaned = cleaned[start:]
 
-    def gerar_prompt_com_transcricoes(self, texto_usuario):
-        prompt = texto_usuario + "\n\n--- CONTEXTO DOS ARQUIVOS ---\n"
-        count = 0
-        for _, item in self.arquivos.items():
-            if item["status"] == "processado" and item["transcricao"]:
-                count += 1
-                trans = item["transcricao"]
-                nome = item["nome"]
-                prompt += f"\n[ARQUIVO: {nome}]\n"
-                
-                if isinstance(trans, dict) and "chunks_processados" in trans:
-                    # Como garantimos a ordem na lista chunks_processados, iteramos normalmente
-                    for chunk in trans["chunks_processados"]:
-                        if chunk.get("status") == "OK":
-                            resumo = chunk.get('resumo', '')
-                            resumo = str(resumo) if resumo else ""
-                            prompt += f"Páginas {chunk['paginas']}: {resumo}\n"
-                            
-                            texto_full = chunk.get('transcricao', '')
-                            if texto_full:
-                                texto_seguro = str(texto_full)
-                                prompt += f"Trecho: {texto_seguro[:400]}...\n"
-                            else:
-                                prompt += "Trecho: (vazio)\n"
-
-                elif isinstance(trans, dict) and "conteudo" in trans:
-                    conteudo = str(trans['conteudo'])
-                    prompt += f"Conteúdo: {conteudo[:1000]}...\n"
-        
-        if count == 0:
-            prompt += "(Nenhum arquivo processado ainda)"
-        return prompt
+    cleaned = cleaned.replace("```json", "").replace("```", "")
+    return cleaned
 
-# Instância Global
-gerenciador = GerenciadorArquivos()
+def executar_no(timeline, config, fragmento_input=None):
+    """
+    Função Worker que será chamada tanto sequencialmente quanto em paralelo.
+    """
+    modelo = model_pro if config.get("modelo") == "pro" else model_flash
 
-# ==================== 5. FUNÇÕES DE ORQUESTRAÇÃO ====================
+    if fragmento_input is not None:
+        input_para_prompt = fragmento_input
+    else:
+        input_para_prompt = json.dumps(timeline, ensure_ascii=False, indent=2)
 
-def automacao_upload_processamento(files, history, config_json):
-    if not files:
-        return history
+    prompt = (
+        "--- INPUT PARA O AGENTE ---\n"
+        f"{input_para_prompt}\n"
+        "----------------\n"
+        f"AGENTE: {config['nome']}\n"
+        f"MISSÃO: {config['missao']}"
+    )
 
     try:
-        config_agentes = json.loads(config_json)
-    except:
-        config_agentes = []
+        # Retry simples para API
+        for tentativa in range(3):
+            try:
+                resp = modelo.generate_content(prompt)
+                out = resp.text or ""
+                break
+            except Exception as e:
+                if "429" in str(e):
+                    time.sleep(2 * (tentativa + 1))
+                    continue
+                raise e
+        
+        content = out
+        if config["tipo_saida"] == "json":
+            cleaned = _extrair_json_possivel(out)
+            try:
+                content = json.loads(cleaned)
+            except:
+                content = [] # Fallback em caso de erro de parse
 
-    if history is None:
-        history = []
+        return {"role": "assistant", "agent": config["nome"], "content": content}, None
+    except Exception as e:
+        return {"role": "system", "error": str(e)}, str(e)
 
-    history.append([None, f"📂 **SISTEMA:** Recebi {len(files)} arquivo(s). Verificando cache e processando..."])
-    yield history
-    
-    ids_para_processar = []
+# ==================== 4. ORQUESTRADOR ====================
+
+def orquestrador(texto, arquivo, history, json_config, confext_state):
+    logs = f"🚀 START: {datetime.now().strftime('%H:%M:%S')}\n"
+    logs = log_point("Orquestrador V44 iniciado", logs)
+
+    # 1. Preparação
+    if history is None: history = []
     
-    for f in files:
-        arquivo_id = f"arq_{int(time.time()*1000)}_{f.name}"
-        gerenciador.adicionar(f, arquivo_id)
-        ids_para_processar.append(arquivo_id)
+    nome_arquivo = os.path.basename(getattr(arquivo, "name", "sem_arquivo")) if arquivo else "sem_arquivo"
+    hash_op = gerar_hash_arquivo(nome_arquivo + json_config) # Hash baseado no arquivo + protocolo
+
+    # 2. Verifica Cache
+    cache_existente = carregar_cache(hash_op) if arquivo else None
     
-    for arq_id in ids_para_processar:
-        item = gerenciador.arquivos[arq_id]
-        nome = item["nome"]
+    if cache_existente:
+        logs = log_point(f"♻️ Cache encontrado para {nome_arquivo}", logs)
+        confext_upload = cache_existente["confext_upload"]
+        timeline = cache_existente.get("timeline", [])
+        history.append([texto, "✅ Arquivo carregado do cache! Análise pronta."])
+        yield history, timeline, logs, confext_upload
         
-        # --- VERIFICAÇÃO DE CACHE ---
-        nome_cache = limpar_nome_arquivo(nome)
-        caminho_cache = os.path.join(PASTA_TRANSCRICOES, nome_cache)
-        
-        if os.path.exists(caminho_cache):
-            try:
-                with open(caminho_cache, "r", encoding="utf-8") as cache_file:
-                    dados_cache = json.load(cache_file)
-                item["transcricao"] = dados_cache
-                item["status"] = "processado"
-                if nome.lower().endswith('.pdf') and "chunks_processados" in dados_cache:
-                     item["processado"] = {"tipo": "pdf", "chunks": []}
-                history.append([None, f"♻️ **Cache Encontrado:** `{nome}` já foi processado. Carregando..."])
-                yield history
-                continue
-            except Exception as e:
-                history.append([None, f"⚠️ Erro cache `{nome}`: {e}. Reprocessando..."])
-        # ---------------------------
+        # Se houver texto novo do usuário, seguimos para análise final, senão paramos
+        if not texto:
+            return
+    else:
+        # 3. Processamento Normal
+        fragmentos, anexo_info, logs = ler_anexo_e_fragmentar(
+            arquivo, paginas_por_fragmento=5, logs=logs
+        )
 
-        history.append([None, f"⚙️ **Processando:** `{nome}`..."])
-        yield history
+        history.append([texto + (" 📎" if arquivo else ""), None])
+        yield history, {}, logs, confext_state
 
-        if nome.lower().endswith('.pdf'):
-            if not PDF_SUPPORT:
-                history.append([None, f"❌ Erro em `{nome}`: Biblioteca PDF ausente."])
-                yield history
-                continue
+        try:
+            protocolo = json.loads(json_config)
+        except Exception as e:
+            history[-1][1] = "❌ Erro no JSON de Configuração."
+            yield history, {}, logs, confext_state
+            return
 
-            pdf_proc, erro = processar_pdf_completo(item["arquivo"])
-            if erro:
-                history.append([None, f"❌ Erro em `{nome}`: {erro}"])
-                yield history
-                continue
-            
-            item["processado"] = pdf_proc
-            chunks = pdf_proc["chunks"]
-            total_chunks = len(chunks)
-            
-            # Inicializa lista com o tamanho exato para garantir a ordem
-            chunks_ordenados = [None] * total_chunks
-            
-            history.append([None, f"📄 `{nome}` fragmentado em {total_chunks} partes. Iniciando IA (Paralelo: {MAX_WORKERS} threads)..."])
-            yield history
+        timeline = [{"role": "user", "content": texto}]
+        confext_upload = {
+            "arquivo": nome_arquivo,
+            "meta": anexo_info,
+            "paginas": []
+        }
+
+        # 4. Execução Paginador (Paralela)
+        if protocolo and fragmentos:
+            cfg_visao = protocolo[0] # Assume que o primeiro é o leitor
+            logs = log_point(f"Iniciando Leitura Paralela ({MAX_WORKERS} workers) com {cfg_visao['nome']}", logs)
+            history[-1][1] = f"⏳ Fragmentando e lendo {len(fragmentos)} partes em paralelo..."
+            yield history, timeline, logs, confext_upload
+
+            resultados_ordenados = [None] * len(fragmentos)
 
-            # --- PROCESSAMENTO PARALELO ---
             with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
-                # Dicionário para mapear Future -> Índice Original
-                futures_map = {}
-                
-                # Submeter todas as tarefas
-                for i, chunk in enumerate(chunks):
-                    future = executor.submit(transcrever_chunk, chunk, config_agentes)
-                    futures_map[future] = i
+                futures_map = {executor.submit(executar_no, [], cfg_visao, frag): i for i, frag in enumerate(fragmentos)}
                 
-                # Coletar resultados conforme ficam prontos
                 concluidos = 0
                 for future in as_completed(futures_map):
-                    index_original = futures_map[future]
-                    res, err = future.result()
+                    idx = futures_map[future]
+                    res, erro = future.result()
                     
-                    if err:
-                        chunks_ordenados[index_original] = {"status": "ERRO", "paginas": chunks[index_original]["paginas"]}
+                    if erro:
+                        logs = log_point(f"Erro no frag {idx}: {erro}", logs)
                     else:
-                        chunks_ordenados[index_original] = {
-                            "status": "OK",
-                            "paginas": chunks[index_original]["paginas"],
-                            "transcricao": res.get("transcricao"),
-                            "resumo": res.get("resumo")
-                        }
+                        resultados_ordenados[idx] = res["content"]
                     
                     concluidos += 1
-                    # Atualiza a UI a cada 2 chunks ou no final para não flodar
-                    if concluidos % 2 == 0 or concluidos == total_chunks:
-                        msg_base = f"📄 `{nome}`: Processando partes... ({concluidos}/{total_chunks})"
-                        history[-1][1] = msg_base
-                        yield history
-            # ------------------------------
-
-            dados_finais = {
-                "arquivo": nome,
-                "data_processamento": str(datetime.now()),
-                "chunks_processados": chunks_ordenados # Agora contém a lista na ordem correta
-            }
+                    history[-1][1] = f"⏳ Leitura: {concluidos}/{len(fragmentos)} partes processadas..."
+                    yield history, timeline, logs, confext_upload
+
+            # Consolidar resultados ordenados
+            for pags in resultados_ordenados:
+                if pags:
+                    if isinstance(pags, list):
+                        confext_upload["paginas"].extend(pags)
+                    elif isinstance(pags, dict):
+                        confext_upload["paginas"].append(pags)
+
+            logs = log_point(f"Leitura concluída. Total páginas extraídas: {len(confext_upload['paginas'])}", logs)
             
-            item["transcricao"] = dados_finais
-            item["status"] = "processado"
-            
-            try:
-                with open(caminho_cache, "w", encoding="utf-8") as f_out:
-                    json.dump(dados_finais, f_out, indent=2, ensure_ascii=False)
-                history.append([None, f"💾 `{nome}` processado e salvo no cache."])
-            except Exception as e:
-                 history.append([None, f"⚠️ Erro ao salvar cache: {e}"])
+            # Salvar Cache após a leitura pesada
+            if arquivo:
+                salvar_cache(hash_op, {"confext_upload": confext_upload, "timeline": timeline})
+                logs = log_point("Estado salvo em Cache", logs)
+
+        # Injeta contexto no timeline
+        timeline.append({
+            "role": "system",
+            "agent": "CONFEXT_UPLOAD",
+            "content": confext_upload
+        })
+
+        # 5. Execução dos Agentes de Análise (Sequencial)
+        restante = protocolo[1:] if protocolo else []
+        
+        for cfg in restante:
+            history[-1][1] = f"⚙️ {cfg['nome']} analisando..."
+            logs = log_point(f"Iniciando agente: {cfg['nome']}", logs)
+            yield history, timeline, logs, confext_upload
+
+            # Passa timeline atualizada
+            res, erro = executar_no(timeline, cfg, fragmento_input=None)
             
-            yield history
-
-        else:
-            # Processamento de Texto Simples (não precisa de paralelismo pois é 1 chunk)
-            res = ler_arquivo_texto(item["arquivo"])
-            if res:
-                item["processado"] = res
-                dados_finais = {"conteudo": res["conteudo"], "data_processamento": str(datetime.now())}
-                item["transcricao"] = dados_finais
-                item["status"] = "processado"
-                
-                with open(caminho_cache, "w", encoding="utf-8") as f_out:
-                    json.dump(dados_finais, f_out, indent=2, ensure_ascii=False)
-                
-                history.append([None, f"✅ `{nome}` (Texto) lido e salvo."])
+            if erro:
+                logs = log_point(f"Erro agente {cfg['nome']}: {erro}", logs)
             else:
-                history.append([None, f"❌ Falha ao ler `{nome}`."])
-            yield history
+                timeline.append(res)
+                if cfg.get("tipo_saida") == "texto":
+                    history[-1][1] = res["content"]
             
-    history.append([None, "🏁 **Processamento de lote finalizado.** Os arquivos estão prontos para análise."])
-    yield history
-
+            yield history, timeline, logs, confext_upload
 
-def chat_orquestrador(message, history, config_json):
-    try:
-        prompt_contexto = gerenciador.gerar_prompt_com_transcricoes(message)
-    except Exception as e:
-        history.append([message, f"❌ Erro ao gerar contexto: {str(e)}"])
-        yield history
-        return
-    
-    try:
-        protocolo = json.loads(config_json)
-    except:
-        history.append([message, "❌ Erro no JSON de Configuração."])
-        yield history
-        return
-
-    history.append([message, None])
-    yield history
-
-    timeline_execucao = [{"role": "user", "content": prompt_contexto}]
+    if not texto and arquivo:
+        history[-1][1] = "✅ Documento processado e indexado. Pode fazer perguntas."
     
-    for cfg in protocolo:
-        nome_agente = cfg.get("nome", "Agente")
-        modelo_agente = model_pro if cfg.get("modelo") == "pro" else model_flash
-        
-        history[-1][1] = f"⏳ **{nome_agente}** está analisando..."
-        yield history
-        
-        prompt_agente = f"""
---- HISTÓRICO ---
-{json.dumps(timeline_execucao, ensure_ascii=False)}
------------------
-Você é: {nome_agente}
-Sua Missão: {cfg['missao']}
-Responda de forma concisa e direta.
-"""
-        try:
-            inicio = time.time()
-            resp = modelo_agente.generate_content(prompt_agente)
-            texto_resp = resp.text
-            duracao = time.time() - inicio
-            
-            timeline_execucao.append({"role": "model", "content": f"[{nome_agente}]: {texto_resp}"})
-            
-            msg_atual = history[-1][1]
-            if "⏳" in msg_atual: msg_atual = ""
-            
-            novo_trecho = f"**[{nome_agente}]** ({duracao:.1f}s):\n{texto_resp}\n\n"
-            history[-1][1] = msg_atual + novo_trecho
-            yield history
-            
-        except Exception as e:
-            msg_atual = history[-1][1]
-            history[-1][1] = msg_atual + f"\n❌ Erro em {nome_agente}: {str(e)}\n"
-            yield history
+    logs = log_point("Processo Finalizado", logs)
+    yield history, timeline, logs, confext_upload
 
-# ==================== 6. UI (Gradio) ====================
+# ==================== 5. UI ====================
 
-def ui_v28_corrected():
+def ui_clean():
     css = """
     footer {display: none !important;}
     .contain {border: none !important;}
     """
-    
-    config_inicial = carregar_protocolo()
 
-    with gr.Blocks(title="AI Forensics Auto", css=css, theme=gr.themes.Soft()) as app:
-        
-        state_config = gr.State(config_inicial)
+    config_init = carregar_protocolo()
+
+    with gr.Blocks(title="AI Forensics Auto V44", css=css, theme=gr.themes.Soft()) as app:
+        confext_state = gr.State(value=None)
 
         with gr.Tabs():
-            with gr.Tab("💬 Investigação"):
-                
+            with gr.Tab("💬 Investigador"):
                 chatbot = gr.Chatbot(
-                    height=550, 
-                    show_label=False, 
+                    label="",
+                    show_label=False,
+                    height=600,
                     show_copy_button=True,
-                    render_markdown=True
+                    render_markdown=True,
                 )
-                
+
                 with gr.Row():
-                    txt_input = gr.Textbox(
-                        scale=8, 
-                        show_label=False, 
-                        placeholder="Digite sua instrução ou pergunta sobre o caso...", 
-                        lines=1
-                    )
-                    btn_enviar = gr.Button("Enviar 📨", variant="primary", scale=1)
-
-                with gr.Accordion("📂 Adicionar Arquivos para Análise", open=False):
-                    gr.Markdown("Selecione arquivos (PDF, TXT). A transcrição iniciará **automaticamente** e os logs aparecerão no chat acima.")
-                    file_uploader = gr.File(
-                        file_count="multiple",
-                        file_types=[".pdf", ".txt", ".json", ".md"],
-                        label="Arraste arquivos aqui ou clique para selecionar"
-                    )
-
-            with gr.Tab("⚙️ Contexto & Config"):
-                gr.Markdown("### Protocolo dos Agentes")
+                    with gr.Column(scale=10):
+                        txt_in = gr.Textbox(
+                            show_label=False,
+                            placeholder="Descreva o caso ou faça perguntas...",
+                            lines=1,
+                            max_lines=5,
+                            container=False,
+                        )
+                    with gr.Column(scale=1, min_width=50):
+                        file_in = gr.UploadButton(
+                            "📎",
+                            file_types=[".txt", ".md", ".json", ".pdf"],
+                            size="sm",
+                        )
+                    with gr.Column(scale=1, min_width=80):
+                        btn_send = gr.Button("Enviar", variant="primary", size="sm")
+
+                file_status = gr.Markdown("", visible=True)
+
+                def _on_upload(x):
+                    nome = os.path.basename(getattr(x, "name", x))
+                    return f"📎 Anexo pronto para análise: {nome}"
+
+                file_in.upload(_on_upload, inputs=file_in, outputs=file_status)
+
+            # --- AQUI ESTÁ A ABA SOLICITADA ---
+            with gr.Tab("🕵️ Auditoria & Debug"):
+                gr.Markdown("### 🧠 Processo Interno de Pensamento")
                 with gr.Row():
-                    btn_save_cfg = gr.Button("💾 Salvar Alterações")
-                    lbl_cfg_status = gr.Label(show_label=False)
-                
-                code_config = gr.Code(value=config_inicial, language="json", label="protocolo.json")
+                    out_dna = gr.JSON(label="Timeline da IA (Contexto)")
+                    out_logs = gr.Textbox(label="Logs do Sistema", lines=20)
                 
-                btn_save_cfg.click(salvar_protocolo, inputs=[code_config], outputs=[lbl_cfg_status])
-                btn_save_cfg.click(lambda x: x, inputs=[code_config], outputs=[state_config])
-
-        btn_enviar.click(
-            chat_orquestrador,
-            inputs=[txt_input, chatbot, state_config],
-            outputs=[chatbot]
-        ).then(
-            lambda: "", outputs=[txt_input]
-        )
+                gr.Markdown("### 📂 Dados Estruturados (Confext)")
+                confext_view = gr.JSON(label="Conteúdo Extraído")
 
-        file_uploader.upload(
-            automacao_upload_processamento,
-            inputs=[file_uploader, chatbot, state_config],
-            outputs=[chatbot]
-        )
+            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, language="json", label=ARQUIVO_CONFIG)
+                btn_save.click(salvar_protocolo, code_json, lbl_save)
+
+        def _orq_wrapper(texto, arquivo, history, json_cfg, confext_old):
+            for h, dna, logs, confext_new in orquestrador(
+                texto, arquivo, history, json_cfg, confext_old
+            ):
+                yield h, dna, logs, confext_new
+
+        triggers = [btn_send.click, txt_in.submit]
+
+        for trig in triggers:
+            trig(
+                _orq_wrapper,
+                inputs=[txt_in, file_in, chatbot, code_json, confext_state],
+                outputs=[chatbot, out_dna, out_logs, confext_state], # Atualiza aba Debug
+            ).then(
+                lambda c: (None, None, "", c)[1:],
+                inputs=confext_state,
+                outputs=[txt_in, file_in, file_status, confext_state],
+            ).then(
+                lambda c: c,
+                inputs=confext_state,
+                outputs=confext_view, # Atualiza visualizador JSON
+            )
 
     return app
 
 if __name__ == "__main__":
-    ui_v28_corrected().launch()
+    ui_clean().launch()