Update app.py

app.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 import gradio as gr
 import requests
 import os
@@ -94,7 +95,6 @@ def extract_text_from_pdf(file_path_or_obj):
                     ocr_text_parts.append(f"[Erro OCR Página {i+1}: {str(ocr_e)}]")
         pdf_reader.close()
         ocr_text = "\n".join(ocr_text_parts)
-
         if text.strip() and len(text) > len(ocr_text) * 0.7:
              logger.info(f"Usando texto extraído do PDF ({len(text)} chars).")
              return text
@@ -133,7 +133,6 @@ def extract_text_from_txt(file_path_or_obj):
             content = file_path_or_obj.read()
         else:
              return "❌ Tipo de entrada TXT inválido."
-
         encodings = ['utf-8', 'latin-1', 'cp1252']
         for encoding in encodings:
             try:
@@ -167,13 +166,9 @@ def process_file(file_obj):
                  return "⚠️ Arquivo muito grande (Máx 15MB)."
         except OSError as size_e:
              logger.warning(f"Não foi possível verificar o tamanho do arquivo: {size_e}")
-
-        if filename.endswith('.pdf'):
-            return extract_text_from_pdf(file_path)
-        elif filename.endswith('.docx'):
-            return extract_text_from_docx(file_path)
-        elif filename.endswith('.txt'):
-            return extract_text_from_txt(file_path)
+        if filename.endswith('.pdf'): return extract_text_from_pdf(file_path)
+        elif filename.endswith('.docx'): return extract_text_from_docx(file_path)
+        elif filename.endswith('.txt'): return extract_text_from_txt(file_path)
         else:
             logger.warning(f"Formato de arquivo não suportado: {filename}")
             return "⚠️ Formato de arquivo não suportado. Use PDF, DOCX ou TXT."
@@ -184,267 +179,60 @@ def process_file(file_obj):
 def get_instrucoes_gerais_avaliacao(modo_treinamento=False):
     base = """
     **Estrutura da Avaliação:**
-    1.  **Análise Geral:** Visão geral concisa (2-3 linhas) sobre a adequação da peça ao caso e tipo, consistência e clareza.
-    2.  **Nota Final:** 0 a 10 (uma casa decimal), com justificativa BREVE dos principais fatores.
-    3.  **Pontos Positivos:** Liste pelo menos 2-3 aspectos bem executados, com justificativa (legal/técnica).
-    4.  **Pontos a Melhorar:** Liste **TODOS** os problemas em ordem de gravidade (erros crassos primeiro). Para cada ponto:
-        *   Descrição clara do erro/omissão.
-        *   Fundamentação legal/doutrinária do porquê é um erro.
-        *   **Impacto estimado na nota** (ex: -0.5, -1.0, -2.0).
-        *   Sugestão de correção ou como deveria ter sido feito.
-    5.  **Análise Específica dos Requisitos:** Avalie os itens chave da peça (listados abaixo para cada tipo).
-
-    **Critérios Fundamentais (Aplicáveis a Quase Todos):**
-    *   **Coerência:** A peça responde ao caso/situação processual? Os argumentos são lógicos?
-    *   **Fundamentação:** Usou a lei, doutrina e jurisprudência corretamente? Citou artigos relevantes?
-    *   **Linguagem:** Clareza, objetividade, correção gramatical e formalidade adequada?
-    *   **Pedidos:** São claros, certos, determinados e coerentes com a fundamentação?
-    *   **NÃO INVENTAR FATOS:** Penalidade severa (-3.0 a -5.0) se criar fatos não presentes no caso.
-    *   **NÃO SE IDENTIFICAR:** Nota ZERO se houver nome, OAB, CPF, etc., do aluno na peça (exceto nomes das partes do caso). Use "ADVOGADO(A)", "OAB/...".
-    """
+    1.  **Análise Geral:** Visão geral concisa (2-3 linhas).
+    2.  **Nota Final:** 0 a 10 (uma casa decimal), com justificativa BREVE.
+    3.  **Pontos Positivos:** Liste 2-3 aspectos bem executados, com justificativa.
+    4.  **Pontos a Melhorar:** Liste **TODOS** os problemas em ordem de gravidade. Para cada: Descrição, Fundamentação legal, Impacto na nota, Sugestão.
+    5.  **Análise Específica dos Requisitos:** Avalie os itens chave da peça.
+    **Critérios Fundamentais:** Coerência, Fundamentação, Linguagem, Pedidos. **NÃO INVENTAR FATOS** (-3 a -5). **NÃO SE IDENTIFICAR** (Nota ZERO)."""
     if modo_treinamento:
         base += """
-    **Modo de Treinamento:**
-    *   Para cada Ponto a Melhorar, detalhe AINDA MAIS:
-        a) Explicação aprofundada do erro e sua consequência prática.
-        b) Base legal/doutrinária específica.
-        c) **Exemplo de Redação Corrigida** para aquele trecho específico.
-        d) Dica prática relevante (use o banco de dicas se aplicável).
-        e) Possível estratégia alternativa.
-    *   Destaque inconsistências entre a peça e o caso com citações diretas.
-    *   Sugira estratégias jurídicas adicionais ou alternativas viáveis.
-        """
+    **Modo de Treinamento:** Para cada Ponto a Melhorar: a) Explicação aprofundada. b) Base legal. c) Exemplo Redação Corrigida. d) Dica prática. e) Estratégia alternativa. Destaque inconsistências. Sugira estratégias adicionais."""
     return base
 
 def estruturar_prompt_analise(caso, peticao, tipo_peticao, modo_treinamento=False):
     instrucoes_gerais = get_instrucoes_gerais_avaliacao(modo_treinamento)
-    prompt_especifico = f"""
-    ## Análise de Peça Processual: {tipo_peticao} (Critérios OAB Simulados)
-    **Caso/Contexto Fornecido:**
-    ```
-    {caso}
-    ```
-    **Peça do Aluno ({tipo_peticao}):**
-    ```
-    {peticao}
-    ```
-    {instrucoes_gerais}
-    **Requisitos Específicos para {tipo_peticao}:**
-    """
+    prompt_especifico = f"## Análise: {tipo_peticao}\n**Caso:**\n```\n{caso}\n```\n**Peça Aluno:**\n```\n{peticao}\n```\n{instrucoes_gerais}\n**Requisitos Específicos ({tipo_peticao}):**\n"
     if tipo_peticao == "Petição Inicial":
-        prompt_especifico += """
-       - Endereçamento e competência (Art. 319, I, CPC; leis especiais como CDC Art. 101, I).
-       - Qualificação completa das partes (Art. 319, II, CPC).
-       - Exposição clara e lógica dos fatos (causa de pedir remota).
-       - Fundamentação jurídica pertinente (causa de pedir próxima - Art. 319, III, CPC).
-       - Pedidos certos, determinados e líquidos (se possível) (Art. 319, IV, CPC).
-       - Valor da causa correto e justificado (Art. 291-292, 319, V, CPC).
-       - Indicação das provas pretendidas (Art. 319, VI, CPC).
-       - Opção pela audiência de conciliação/mediação (Art. 319, VII, CPC).
-       - Pedido de citação do réu (forma específica se necessário).
-       - Requerimento de juntada de documentos essenciais (procuração, custas/JG).
-       - Fechamento formal ("Nestes termos pede deferimento", Local, data, Advogado, OAB).
-    **Critérios Adicionais (Inicial):**
-    *   Uso de "XXX" para dados ausentes. Penalizar invenção (-0.5 por ocorrência).
-    *   Falta de pedido de juntada de custas/JG: -1.0 ponto.
-    *   Erro em "Nestes termos, pede deferimento" (com vírgula): -0.2 ponto.
-    *   Analisar foro (Art. 46 CPC vs. Art. 101 CDC): Escolha do foro do consumidor é válida se aplicável; não penalizar, apenas comentar se gerar dificuldades práticas.
-        """
+        prompt_especifico += "- Endereçamento/competência (Art. 319, I; CDC 101, I).\n- Qualificação (Art. 319, II).\n- Fatos.\n- Fundamentação (Art. 319, III).\n- Pedidos (Art. 319, IV).\n- Valor causa (Art. 291-292, 319, V).\n- Provas (Art. 319, VI).\n- Audiência (Art. 319, VII).\n- Citação.\n- Docs essenciais (procuração, custas/JG).\n- Fechamento.\n**Critérios Adicionais:** Usar 'XXX'. Falta custas/JG (-1.0). Vírgula em 'pede deferimento' (-0.2). Foro consumidor OK."
     elif tipo_peticao == "Contestação":
-        prompt_especifico += """
-       - Endereçamento ao juízo correto onde tramita a ação.
-       - Qualificação completa do réu (se já não constante nos autos, referenciar).
-       - Indicação do processo (número).
-       - Tempestividade (menção implícita ou explícita de que está no prazo).
-       - **Preliminares (Art. 337, CPC):** Alegar TODAS as aplicáveis (inexistência/nulidade citação, incompetência, inépcia, perempção, litispendência, coisa julgada, conexão, incapacidade, convenção de arbitragem, ausência de legitimidade/interesse, falta de caução, indevida concessão de JG).
-       - **Impugnação Específica dos Fatos:** Rebater PONTO A PONTO os fatos alegados na inicial (Art. 341, CPC). A falta de impugnação específica torna o fato incontroverso!
-       - **Mérito:** Apresentar a versão do réu sobre os fatos; apresentar a defesa de mérito direta (negando direito do autor) e/ou indireta (fatos impeditivos, modificativos, extintivos do direito do autor - ex: pagamento, prescrição, compensação).
-       - Fundamentação jurídica da defesa.
-       - **Pedidos:** Requerer acolhimento das preliminares (com extinção ou remessa); NO MÉRITO, requerer a IMPROCEDÊNCIA TOTAL dos pedidos do autor; Requerer a condenação do autor nas custas e honorários advocatícios (Art. 85, CPC).
-       - Indicação das provas que pretende produzir.
-       - Fechamento formal.
-    **Critérios Adicionais (Contestação):**
-    *   A não alegação de preliminar arguível (exceto incompetência absoluta, conexão, convenção de arbitragem) preclui? Avaliar impacto.
-    *   Falha grave na impugnação específica: -2.0 a -4.0 pontos.
-    *   Ausência de pedido de improcedência: -1.5 pontos.
-        """
+        prompt_especifico += "- Endereçamento. Qualificação réu. Processo nº. Tempestividade.\n- **Preliminares (Art. 337):** TODAS aplicáveis.\n- **Impugnação Específica Fatos (Art. 341):** PONTO A PONTO.\n- **Mérito:** Versão réu; defesa direta/indireta (fatos impeditivos/modificativos/extintivos).\n- Fundamentação defesa.\n- **Pedidos:** Acolher preliminares; IMPROCEDÊNCIA TOTAL; Condenação sucumbência (Art. 85).\n- Provas. Fechamento.\n**Critérios Adicionais:** Preliminar não arguida preclui? Falha grave impugnação (-2 a -4). Ausência pedido improcedência (-1.5)."
     elif tipo_peticao == "Reconvenção":
-         prompt_especifico += """
-       - Apresentada NA MESMA PEÇA da Contestação (Art. 343, CPC).
-       - Endereçamento ao mesmo juízo.
-       - Indica�o do processo.
-       - Qualificação completa do réu-reconvinte e do autor-reconvindo (podem ser referenciadas se já completas).
-       - **Conexão com a Ação Principal ou Fundamento de Defesa:** O pedido da reconvenção deve ser conexo (Art. 343, caput).
-       - **Estrutura Similar à Petição Inicial:** Fatos, Fundamentação, Pedidos específicos, Valor da causa, Provas.
-       - Pedido de intimação do autor-reconvindo para contestar a reconvenção (na pessoa de seu advogado - Art. 343, §1º).
-       - Fechamento formal (pode ser conjunto com a contestação).
-    **Critérios Adicionais (Reconvenção):**
-    *   Ausência de conexão clara: -2.0 pontos. Falta de pedido/valor da causa/provas específicos: -1.0 por item. Apresentada em peça separada (erro formal grave): -3.0 pontos.
-         """
+         prompt_especifico += "- NA MESMA PEÇA da Contestação (Art. 343). Endereçamento. Processo nº.\n- Qualificação réu-reconvinte e autor-reconvindo.\n- **Conexão** (Art. 343).\n- **Estrutura PI:** Fatos, Fundamentos, Pedidos específicos, Valor causa, Provas (da reconvenção).\n- Pedido intimação autor-reconvindo (Art. 343, §1º).\n**Critérios Adicionais:** Sem conexão (-2.0). Falta pedido/valor/provas reconv. (-1.0/item). Peça separada (-3.0)."
     elif tipo_peticao == "Impugnação à Contestação":
-         prompt_especifico += """
-       - Endereçamento ao juízo correto. Indicação do processo. Qualificação do autor (impugnante). Tempestividade (15 dias - Art. 350/351 CPC).
-       - **Resposta às Preliminares:** Rebater cada preliminar arguida.
-       - **Resposta a Fatos Impeditivos/Modificativos/Extintivos:** Manifestar-se sobre fatos novos (Art. 350).
-       - **Resposta a Documentos Novos:** Manifestar-se sobre documentos juntados (Art. 437 CPC).
-       - **Ratificação da Inicial:** Reiterar os termos e pedidos da inicial.
-       - **Especificação de Provas:** Indicar provas para contrapor defesa indireta/preliminares (Art. 350/351).
-       - Pedidos: Rejeição das preliminares, refutação da defesa, procedência dos pedidos da inicial. Fechamento formal.
-    **Critérios Adicionais (Impugnação):**
-    *   Não responder a preliminar relevante: -1.5 pontos. Não se manifestar sobre fato novo: -2.0 pontos. Não ratificar a inicial: -0.5 pontos.
-         """
+         prompt_especifico += "- Endereçamento. Processo nº. Qualificação autor. Tempestividade (15d - Art. 350/351).\n- **Resposta Preliminares.**\n- **Resposta Fatos Novos** (Art. 350).\n- **Resposta Documentos** (Art. 437).\n- **Ratificação Inicial.**\n- **Especificação Provas** (contra defesa indireta/preliminares).\n- Pedidos: Rejeitar preliminares; refutar defesa; proceder inicial.\n**Critérios Adicionais:** Não responder preliminar (-1.5). Não manifestar fato novo (-2.0). Não ratificar (-0.5)."
     elif tipo_peticao == "Embargos de Declaração":
-         prompt_especifico += """
-       - **Contra Decisão Específica:** Indicar claramente qual decisão está sendo embargada. Endereçamento ao PRÓPRIO juízo prolator. Indicação do processo. Qualificação das partes. Tempestividade (5 dias - Art. 1023 CPC).
-       - **Cabimento (Art. 1022, CPC):** Apontar **PRECISAMENTE** e **FUNDAMENTADAMENTE** a ocorrência de: Omissão, Contradição, Obscuridade, Erro Material.
-       - **NÃO PODE REJULGAR A CAUSA:** Objetivo é sanar vício, não modificar o mérito (salvo efeitos infringentes excepcionais).
-       - **Pedido:** Requerer o conhecimento e ACOLHIMENTO para sanar o vício (com ou sem efeitos infringentes, se for o caso). Fechamento formal.
-    **Critérios Adicionais (Embargos):**
-    *   Usar para rediscutir mérito (erro grave): -4.0 pontos. Não apontar vício claramente: -3.0 pontos. Endereçar ao tribunal (erro): -1.0 ponto.
-         """
+         prompt_especifico += "- **Contra Decisão Específica.** Endereçamento ao juízo prolator. Processo nº. Partes. Tempestividade (5d - Art. 1023).\n- **Cabimento (Art. 1022):** Apontar PRECISAMENTE: Omissão, Contradição, Obscuridade ou Erro Material.\n- **NÃO REJULGAR CAUSA.**\n- **Pedido:** Conhecimento e ACOLHIMENTO para sanar vício.\n**Critérios Adicionais:** Rediscutir mérito (-4.0). Não apontar vício (-3.0). Endereçar tribunal (-1.0)."
     elif tipo_peticao == "Recurso de Apelação":
-        prompt_especifico += """
-       - **Peça de Interposição:** Endereçamento ao juízo a quo. Indicação do processo. Qualificação das partes. Pressupostos (cabimento - Art. 1009; tempestividade - 15 dias Art. 1003, §5º; preparo/JG; regularidade). Pedido de recebimento e remessa ao Tribunal.
-       - **Razões Recursais:** Endereçamento ao TRIBUNAL competente. Exposição dos fatos e da sentença. **Fundamentos para Reforma/Anulação (Art. 1010, II e III):** Error in procedendo (anulação) ou Error in judicando (reforma). **Princípio da Dialeticidade:** Impugnar ESPECIFICAMENTE os fundamentos da sentença.
-       - **Pedidos:** Conhecimento; PROVIMENTO para ANULAR ou REFORMAR (especificar); inversão da sucumbência. Fechamento formal.
-    **Critérios Adicionais (Apelação):**
-    *   Falta de interposição ou razões: Nota zero. Endereçamento incorreto das razões: -1.0. Ausência de dialeticidade: -3.0 a -5.0. Não pedir anulação/reforma: -1.5. Falta de preparo/JG: -2.0.
-        """
+        prompt_especifico += "- **Interposição:** Ao juízo a quo. Processo nº. Partes. Pressupostos (cabimento Art. 1009; tempestividade 15d; preparo/JG). Pedido recebimento/remessa.\n- **Razões:** Ao TRIBUNAL. Relato. **Fundamentos Reforma/Anulação (Art. 1010):** Error in procedendo/judicando. **Dialeticidade.**\n- **Pedidos:** Conhecimento; PROVIMENTO (anular/reformar); Inversão sucumbência.\n**Critérios Adicionais:** Falta peça (-10). Endereço razões (-1.0). Sem dialeticidade (-3 a -5). Sem pedido reforma/anulação (-1.5). Falta preparo/JG (-2.0)."
     elif tipo_peticao == "Agravo de Instrumento":
-        prompt_especifico += """
-       - **Peça Única:** Endereçamento direto ao TRIBUNAL. Indicação processo origem. Qualificação partes e advogados (com endereços - Art. 1016, IV). Cópia da decisão agravada (OBRIGATÓRIA - Art. 1017, I).
-       - **Cabimento (Art. 1015 ou taxatividade mitigada):** Demonstrar hipótese legal ou urgência (Tema 988 STJ). Tempestividade (15 dias). Preparo/JG.
-       - **Peças Obrigatórias (Art. 1017, I):** Decisão agravada, certidão de intimação, procurações. Peças Facultativas (Art. 1017, III).
-       - **Razões (Art. 1016, II e III):** Exposição do fato e direito; razões para reforma/invalidação da decisão interlocutória.
-       - **Pedido de Efeito Suspensivo ou Tutela Antecipada Recursal (Art. 1019, I):** Se houver risco, pedir fundamentadamente.
-       - **Pedidos Finais:** Conhecimento; (se aplicável) efeito suspensivo/tutela antecipada; PROVIMENTO para reformar/invalidar; comunicação ao juiz (Art. 1018 - opcional se eletrônico). Fechamento formal.
-    **Critérios Adicionais (Agravo):**
-    *   Ausência de peça obrigatória: Inadmissibilidade (-4.0). Não demonstrar cabimento: -3.0. Endereçar ao juiz a quo: -1.0. Não indicar advogados: -0.5.
-        """
+        prompt_especifico += "- Peça única ao TRIBUNAL. Processo origem. Partes e Advogados (endereços Art. 1016, IV). Cópia decisão agravada (Art. 1017, I).\n- **Cabimento (Art. 1015 / mitigada).** Tempestividade (15d). Preparo/JG.\n- **Peças Obrigatórias (Art. 1017, I):** Decisão, Intimação, Procurações. Facultativas (III).\n- **Razões (Art. 1016):** Motivos reforma/invalidação.\n- **Efeito Suspensivo / Tutela Antecipada Recursal (Art. 1019, I)** (se risco).\n- **Pedidos Finais:** Conhecimento; Efeito/Tutela (se aplicável); PROVIMENTO; Comunicação juiz.\n**Critérios Adicionais:** Falta peça obrigatória (-4.0). Sem cabimento (-3.0). Endereço juiz (-1.0). Sem advogados (-0.5)."
     elif tipo_peticao == "Petição de Tutela Provisória":
-        prompt_especifico += """
-       - **Tipo (Urgência ou Evidência):** Deixar claro. Antecedente ou incidental. Endereçamento (competente ou da causa). Qualificação partes. Indicação processo (se incidental).
-       - **Tutela de Urgência (Art. 300):** **Fumus Boni Iuris** (probabilidade do direito) E **Periculum in Mora** (perigo de dano/risco ao resultado útil). **Reversibilidade** (Art. 300, §3º - se possível).
-       - **Tutela de Evidência (Art. 311):** Demonstrar uma das hipóteses (I a IV). **NÃO precisa periculum in mora.**
-       - **Pedido Específico:** Indicar CLARAMENTE a medida liminar solicitada.
-       - **Se Antecedente (Art. 303 ou 305):** Indicar pedido final ou aditar/apresentar inicial no prazo. Valor da Causa.
-       - **Pedidos:** Concessão da tutela (liminar/justificação prévia); citação/intimação; (se antecedente) indicação da ação principal/aditamento. Fechamento formal.
-    **Critérios Adicionais (Tutela):**
-    *   Não demonstrar Fumus/Periculum (Urgência): -3.0 a -5.0. Não enquadrar na Evidência: -3.0. Pedido genérico: -2.0. Confundir requisitos: -1.5.
-        """
-    else:
-        prompt_especifico += """
-       - **Adequação ao Tipo:** A peça corresponde à estrutura e finalidade do tipo?
-       - **Clareza:** É possível entender a pretensão?
-       - **Fundamentação Mínima:** Tentativa de basear em lei ou fatos?
-       - **Pedido:** Existe um pedido?
-        """
-    prompt_especifico += "\n\n**Instruções Finais:** Analise a peça do aluno estritamente com base no caso/contexto fornecido e nos critérios acima. Seja rigoroso como um examinador da OAB, mas forneça feedback construtivo e detalhado. Gere a resposta **exclusivamente** no formato solicitado."
+        prompt_especifico += "- Tipo (Urgência/Evidência). Caráter (Antecedente/Incidental). Endereçamento. Qualificação. Processo (se incidental).\n- **Tutela Urgência (Art. 300):** **Fumus Boni Iuris** E **Periculum in Mora**. **Reversibilidade** (Art. 300, §3º).\n- **Tutela Evidência (Art. 311):** Hipótese I a IV. **NÃO precisa periculum.**\n- **Pedido Específico:** Medida liminar CLARA.\n- **Se Antecedente (Art. 303/305):** Indicar pedido final ou aditar/apresentar inicial. Valor Causa.\n- **Pedidos:** Concessão tutela; citação/intimação; indicação ação/aditamento.\n**Critérios Adicionais:** Sem Fumus/Periculum (-3 a -5). Erro hipótese Evidência (-3.0). Pedido genérico (-2.0)."
+    else: prompt_especifico += "- Adequação ao tipo? Clareza? Fundamentação Mínima? Pedido?"
+    prompt_especifico += "\n\n**Instruções Finais:** Analise estritamente com base no caso e critérios. Seja rigoroso mas construtivo. Gere **exclusivamente** no formato solicitado."
     return prompt_especifico
 
 def estruturar_prompt_peticao_corrigida(caso, peticao_original, tipo_peticao):
-    prompt = f"""
-    **Caso/Contexto Fornecido:**
-    ```
-    {caso}
-    ```
-    **Peça Original do Aluno ({tipo_peticao}):**
-    ```
-    {peticao_original}
-    ```
-    **Tarefa:** Com base no caso e nos problemas da peça original, **gere uma versão corrigida e aprimorada** da peça ({tipo_peticao}). Siga **rigorosamente** as melhores práticas e requisitos formais/materiais para este tipo de peça no exame da OAB.
-    **Instruções Específicas para a Peça Corrigida ({tipo_peticao}):**
-    """
+    prompt = f"**Caso:**\n```\n{caso}\n```\n**Peça Original ({tipo_peticao}):**\n```\n{peticao_original}\n```\n**Tarefa:** Gere versão corrigida da peça ({tipo_peticao}), seguindo rigorosamente práticas OAB.\n**Instruções Específicas ({tipo_peticao}):**\n"
     if tipo_peticao == "Petição Inicial":
-        prompt += """
-    1.  **Endereçamento:** Correto e fundamentado (Art. 46 CPC ou Art. 101 CDC se aplicável).
-    2.  **Qualificação:** Completa (Art. 319, II), usando "XXX" para dados ausentes.
-    3.  **Fatos:** Narre de forma cronológica, clara e fiel ao caso.
-    4.  **Fundamentação:** Cite artigos pertinentes (CC, CDC, CPC) e súmulas/jurisprudência, se aplicável.
-    5.  **Pedidos:** Claros, certos, determinados (quantificar danos se possível). Cumulados se cabível.
-    6.  **Valor da Causa:** Correto (soma dos benefícios - Art. 292).
-    7.  **Provas:** Indicar ("protesta provar o alegado por todos os meios...").
-    8.  **Audiência:** Indicar opção (Art. 319, VII).
-    9.  **Citação:** Pedido de citação (ex: "via postal, Art. 246, I, CPC").
-    10. **Custas:** Requerimento expresso de juntada da guia OU pedido de gratuidade (com pedido de declaração). **NUNCA OMITIR.**
-    11. **Fechamento:** "Nestes termos pede deferimento." (SEM vírgula). Seguido de "Local, data.", "ADVOGADO(A)", "OAB/...". **NUNCA identificar.**
-        """
+        prompt += "1.Endereçamento correto/fundamentado. 2.Qualificação completa (Art.319,II,'XXX'). 3.Fatos cronológicos/fiéis. 4.Fundamentação (artigos, súmulas). 5.Pedidos certos/determinados (quantificar). 6.Valor causa (Art.292). 7.Provas ('protesta provar...'). 8.Audiência (Art.319,VII). 9.Citação (Art.246,I). 10.Custas/JG (NÃO OMITIR). 11.Fechamento ('Nestes termos pede deferimento.', Local, data., ADVOGADO(A), OAB/...). NUNCA identificar."
     elif tipo_peticao == "Contestação":
-        prompt += """
-    1.  **Endereçamento:** Ao juízo da ação.
-    2.  **Identificação:** Número do processo, qualificação do réu.
-    3.  **Tempestividade:** Mencionar ("A presente contestação é tempestiva...").
-    4.  **Estrutura:** Síntese da Inicial; Preliminares (Art. 337, fundamentadas); Mérito (Impugnação Específica + Defesa de Mérito Direta/Indireta com fundamentos); Reconvenção (Se houver, ANTES dos pedidos da contestação).
-    5.  **Pedidos da Contestação:** Acolhimento das preliminares (com consequência); **IMPROCEDÊNCIA TOTAL** dos pedidos do autor; Condenação em custas e honorários.
-    6.  **Provas:** Indicar as provas do réu.
-    7.  **Fechamento:** Padrão OAB.
-        """
+        prompt += "1.Endereçamento juízo ação. 2.Identificação (proc. nº, réu). 3.Tempestividade. 4.Estrutura: Síntese Inicial; Preliminares (Art.337, fund.); Mérito (Impug. Específica + Defesa fund.); Reconvenção (se houver, antes pedidos cont.). 5.Pedidos Cont.: Acolher prelim.; IMPROCEDÊNCIA TOTAL; Sucumbência. 6.Provas réu. 7.Fechamento OAB."
     elif tipo_peticao == "Reconvenção":
-         prompt += """
-    **IMPORTANTE:** Gere a Reconvenção como parte da Contestação.
-    1.  **Após a defesa de mérito da Contestação e ANTES dos pedidos da Contestação**, insira: "DA RECONVENÇÃO".
-    2.  **Qualificação:** Réu-Reconvinte e Autor-Reconvindo.
-    3.  **Conexão:** Justifique brevemente.
-    4.  **Fatos e Direito Reconvencionais:** Narre e fundamente o pedido do reconvinte.
-    5.  **Pedidos da Reconvenção:** Claros e específicos contra o autor-reconvindo.
-    6.  **Valor da Causa e Provas da Reconvenção:** Específicos.
-    7.  **Intimação:** Peça a intimação do autor-reconvindo para contestar.
-    8.  **Continue com os Pedidos da Contestação**.
-    9.  **Fechamento:** Padrão OAB.
-         """
+         prompt += "**IMPORTANTE:** Gere como parte da Contestação.\n1.Após defesa mérito cont., ANTES pedidos cont.: Tópico 'DA RECONVENÇÃO'. 2.Qualificação Reconvinte/Reconvindo. 3.Conexão. 4.Fatos e Direito Reconvencionais. 5.Pedidos Reconv.: Claros contra autor-reconvindo. 6.Valor Causa e Provas Reconv. 7.Intimação autor-reconvindo. 8.Continue com Pedidos Contestação. 9.Fechamento OAB."
     elif tipo_peticao == "Impugnação à Contestação":
-         prompt += """
-    1. Endereçamento, processo, qualificação autor, tempestividade.
-    2. Tópico: **DA(S) PRELIMINAR(ES) ARGUIDA(S)** - Rebater cada uma.
-    3. Tópico: **DO MÉRITO E DOS FATOS NOVOS** - Manifestar-se sobre fatos impeditivos/modificativos/extintivos e documentos.
-    4. Tópico: **DA RATIFICAÇÃO DA INICIAL** - Reiterar termos e pedidos.
-    5. Tópico: **DAS PROVAS** - Especificar provas contrapostas.
-    6. **Pedidos:** Rejeição das preliminares, refutação da defesa, procedência dos pedidos da inicial.
-    7. Fechamento padrão OAB.
-         """
+         prompt += "1.Endereçamento, proc, autor, tempestividade. 2.Tópico: DA(S) PRELIMINAR(ES) - Rebater. 3.Tópico: DO MÉRITO E FATOS NOVOS - Manifestar. 4.Tópico: DA RATIFICAÇÃO INICIAL. 5.Tópico: DAS PROVAS - Especificar. 6.Pedidos: Rejeitar prelim., refutar defesa, proceder inicial. 7.Fechamento OAB."
     elif tipo_peticao == "Embargos de Declaração":
-         prompt += """
-    1. Endereçamento ao juízo prolator. Processo, Embargante, Embargado. Decisão embargada identificada. Tempestividade (5 dias).
-    2. Tópico para cada vício (Art. 1022): **DA OMISSÃO / DA CONTRADIÇÃO / DA OBSCURIDADE / DO ERRO MATERIAL**.
-    3. Dentro de cada tópico: **Transcrever trecho relevante da decisão** e explicar **objetivamente** o vício. NÃO REJULGAR.
-    4. **Pedido:** Conhecimento e ACOLHIMENTO para sanar o(s) vício(s) apontado(s), especificando o que se espera. Pedir efeitos infringentes se cabível e fundamentado.
-    5. Fechamento padrão OAB.
-         """
+         prompt += "1.Endereçamento juízo prolator. Proc, Partes. Decisão embargada ID. Tempestividade (5d). 2.Tópico para cada vício (Art.1022): DA OMISSÃO/CONTRADIÇÃO/OBSCURIDADE/ERRO MATERIAL. 3.Dentro: Transcrever trecho + explicar vício OBJETIVAMENTE. NÃO REJULGAR. 4.Pedido: Conhecimento e ACOLHIMENTO p/ sanar vício(s). 5.Fechamento OAB."
     elif tipo_peticao == "Recurso de Apelação":
-        prompt += """
-    1.  **Peça de Interposição:** Endereçamento ao juízo a quo. Processo, Apelante, Apelado. Pressupostos (cabimento, tempestividade, preparo/JG). Pedido de recebimento e remessa.
-    2.  **Razões Recursais:** Endereçamento ao Tribunal. Breve relato. **DOS FUNDAMENTOS PARA REFORMA/ANULAÇÃO:** Error in procedendo ou Error in judicando. Impugnar especificamente a sentença (dialeticidade).
-    3.  **Pedidos:** Conhecimento; PROVIMENTO para ANULAR ou REFORMAR (especificar); inversão sucumbência.
-    4.  Fechamento padrão OAB.
-        """
+        prompt += "1.Interposição: Juízo a quo. Proc, Partes. Pressupostos (cabim., temp., prep./JG). Pedido receb./remessa. 2.Razões: Tribunal. Relato. FUNDAMENTOS REFORMA/ANULAÇÃO (Error in proc./judic.). DIALETICIDADE. 3.Pedidos: Conhec.; PROVIMENTO (anular/reformar); Inversão sucumb. 4.Fechamento OAB."
     elif tipo_peticao == "Agravo de Instrumento":
-        prompt += """
-    1. Peça única ao Tribunal. Processo origem, Agravante, Agravado, Advogados (com endereços). Decisão agravada identificada (juntar cópia).
-    2. **DO CABIMENTO:** Demonstrar hipótese Art. 1015 ou mitigação. **DA TEMPESTIVIDADE.** **DO PREPARO/JG.** **DAS PEÇAS OBRIGATÓRIAS E FACULTATIVAS.**
-    3. **DAS RAZÕES RECURSAIS:** Exposição fato/direito, motivos para reforma/invalidação da interlocutória.
-    4. **DO PEDIDO DE EFEITO SUSPENSIVO / TUTELA ANTECIPADA RECURSAL** (se cabível e fundamentado).
-    5. **Pedidos:** Conhecimento; (se aplicável) efeito suspensivo/tutela; PROVIMENTO para reformar/invalidar; comunicação ao juiz.
-    6. Fechamento padrão OAB.
-        """
+        prompt += "1.Peça única Tribunal. Proc. origem, Partes, Advogados (endereços). Decisão agravada ID (juntar cópia). 2.CABIMENTO (Art.1015/mitig.). TEMPESTIVIDADE. PREPARO/JG. PEÇAS OBRIG./FACULT. 3.RAZÕES RECURSAIS: Motivos reforma/invalidação. 4.EFEITO SUSPENSIVO/TUTELA ANTECIPADA (se cabível). 5.PEDIDOS: Conhec.; Efeito/Tutela; PROVIMENTO; Comunicação juiz. 6.Fechamento OAB."
     elif tipo_peticao == "Petição de Tutela Provisória":
-        prompt += """
-    1. Indicar TIPO (Urgência/Evidência) e CARÁTER (Antecedente/Incidental). Endereçamento. Qualificação. Processo (se incidental).
-    2. **DOS REQUISITOS:**
-        *   **Urgência:** Tópico **DA PROBABILIDADE DO DIREITO (FUMUS BONI IURIS)** e tópico **DO PERIGO DE DANO OU RISCO AO RESULTADO ÚTIL (PERICULUM IN MORA)**. Se possível, **DA REVERSIBILIDADE**.
-        *   **Evidência:** Tópico **DA HIPÓTESE DE EVIDÊNCIA (ART. 311, INCISO __)** - Demonstrar o enquadramento.
-    3. **DO PEDIDO LIMINAR:** Descrever CLARAMENTE a medida solicitada.
-    4. **Se Antecedente:** Indicar pedido final ou aditamento/inicial completa. Valor da Causa.
-    5. **Pedidos:** Concessão da tutela; citação/intimação; (se antecedente) indicação ação principal/aditamento.
-    6. Fechamento padrão OAB.
-        """
-    else:
-        prompt += """
-    1.  Estrutura Lógica: Começo, meio, fim.
-    2.  Argumentos Claros.
-    3.  Pedido Claro.
-    4.  Formalidades: Linguagem adequada, fechamento OAB.
-        """
-    prompt += "\n\n**Instrução Final:** Gere **APENAS** o texto completo da peça corrigida abaixo, começando pelo endereçamento e terminando com 'OAB/...'. Não inclua NENHUM comentário, introdução ou explicação ANTES ou DEPOIS do texto da peça."
+        prompt += "1.Indicar TIPO(Urg/Evid) e CARÁTER(Antec/Incid). Endereç. Qualif. Proc(se incid). 2.REQUISITOS: Urgência=Fumus+Periculum(+Reversib.). Evidência=Hipótese Art.311. 3.PEDIDO LIMINAR: Medida CLARA. 4.Se Antec.: Indicar pedido final/aditar. Valor Causa. 5.PEDIDOS: Concessão tutela; citação/intim.; indic. ação/adit. 6.Fechamento OAB."
+    else: prompt += "1.Estrutura Lógica. 2.Argumentos Claros. 3.Pedido Claro. 4.Formalidades OAB."
+    prompt += "\n\n**Instrução Final:** Gere **APENAS** o texto completo da peça corrigida abaixo, começando pelo endereçamento e terminando com 'OAB/...'. Sem comentários extras."
     return prompt
 
 def pos_corrigir_peticao(peticao_corrigida, tipo_peticao):
@@ -454,24 +242,17 @@ def pos_corrigir_peticao(peticao_corrigida, tipo_peticao):
         peticao_lower = peticao_corrigida.lower()
         if "juntada da guia de custas" not in peticao_lower and "gratuidade de justiça" not in peticao_lower:
              partes = peticao_corrigida.split("Nestes termos pede deferimento")
-             if len(partes) == 2:
-                 peticao_corrigida = partes[0].strip() + "\nRequer, ainda, a juntada da guia de custas devidamente recolhida.\nNestes termos pede deferimento" + partes[1]
-             else:
-                 peticao_corrigida = peticao_corrigida.replace("Local, data.", "Requer, ainda, a juntada da guia de custas devidamente recolhida.\n\nLocal, data.")
+             if len(partes) == 2: peticao_corrigida = partes[0].strip() + "\nRequer, ainda, a juntada da guia de custas devidamente recolhida.\nNestes termos pede deferimento" + partes[1]
+             else: peticao_corrigida = peticao_corrigida.replace("Local, data.", "Requer, ainda, a juntada da guia de custas devidamente recolhida.\n\nLocal, data.")
         if "audiência de conciliação" not in peticao_lower and "audiência de mediação" not in peticao_lower:
              partes = peticao_corrigida.split("Nestes termos pede deferimento")
-             if len(partes) == 2:
-                 peticao_corrigida = partes[0].strip() + "\nOpta o Autor pela realização da audiência de conciliação ou mediação (Art. 319, VII, CPC).\nNestes termos pede deferimento" + partes[1]
-             else:
-                 peticao_corrigida = peticao_corrigida.replace("Local, data.", "Opta o Autor pela realização da audiência de conciliação ou mediação (Art. 319, VII, CPC).\n\nLocal, data.")
-
+             if len(partes) == 2: peticao_corrigida = partes[0].strip() + "\nOpta o Autor pela realização da audiência de conciliação ou mediação (Art. 319, VII, CPC).\nNestes termos pede deferimento" + partes[1]
+             else: peticao_corrigida = peticao_corrigida.replace("Local, data.", "Opta o Autor pela realização da audiência de conciliação ou mediação (Art. 319, VII, CPC).\n\nLocal, data.")
     linhas = [l.strip() for l in peticao_corrigida.strip().split('\n') if l.strip()]
     fechamento_padrao = ["Local, data.", "ADVOGADO(A)", "OAB/..."]
-    while linhas and any(term in linhas[-1] for term in ["ADVOGADO", "OAB", "Local", "data"]):
-        linhas.pop()
+    while linhas and any(term in linhas[-1] for term in ["ADVOGADO", "OAB", "Local", "data"]): linhas.pop()
     linhas.extend(fechamento_padrao)
-    peticao_corrigida = "\n".join(linhas)
-    return peticao_corrigida
+    return "\n".join(linhas)
 
 def chamar_api(prompt):
     payload = {"contents": [{"parts": [{"text": prompt}]}],"generationConfig": {"temperature": CONFIG["temperatura"],"maxOutputTokens": CONFIG["max_tokens"],"topP": 0.95,}}
@@ -483,71 +264,58 @@ def chamar_api(prompt):
                 logger.debug(f"API Call - Tentativa {tentativa + 1}/{CONFIG['max_retry_attempts']}")
                 response = requests.post(GEMINI_API_URL, headers=headers, data=json.dumps(payload), timeout=CONFIG["timeout"])
             logger.debug(f"API Response - Status: {response.status_code}")
-
             if response.status_code == 429:
                 retry_after = int(response.headers.get("Retry-After", CONFIG["retry_delay"] * (tentativa + 1)))
-                logger.warning(f"Erro 429 (Too Many Requests). Aguardando {retry_after}s...")
+                logger.warning(f"Erro 429. Aguardando {retry_after}s...")
                 if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(retry_after); continue
-                else: return "❌ Erro 429: Muitas requisições. Tente novamente mais tarde."
-
+                else: return "❌ Erro 429: Muitas requisições."
             if response.status_code != 200:
-                error_msg = "Erro desconhecido na API"
-                try:
-                    error_info = response.json()
-                    error_msg = error_info.get("error", {}).get("message", error_msg)
-                except json.JSONDecodeError:
-                    error_msg = f"Erro {response.status_code}: {response.text[:200]}" # Mostra início do erro não-JSON
-                logger.error(f"API Error (Status {response.status_code}): {error_msg}")
+                error_msg = f"Erro {response.status_code}"
+                try: error_msg = response.json().get("error", {}).get("message", error_msg)
+                except json.JSONDecodeError: error_msg = f"Erro {response.status_code}: {response.text[:200]}"
+                logger.error(f"API Error: {error_msg}")
                 if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(CONFIG['retry_delay'] * (tentativa + 1)); continue
-                return f"❌ Erro da API ({response.status_code}): {error_msg}"
-
+                return f"❌ Erro API ({response.status_code}): {error_msg}"
             response_data = response.json()
-
             if not response_data.get("candidates"):
                  prompt_feedback = response_data.get("promptFeedback", {})
                  block_reason = prompt_feedback.get("blockReason")
                  logger.error(f"API Response sem 'candidates'. Block Reason: {block_reason}")
-                 if block_reason: return f"❌ A solicitação foi bloqueada pela API. Motivo: {block_reason}. Tente reformular."
-                 else: return "❌ Resposta vazia ou inválida da API (sem 'candidates')."
-
+                 if block_reason: return f"❌ Bloqueado pela API: {block_reason}."
+                 else: return "❌ Resposta API vazia (sem 'candidates')."
             candidate = response_data["candidates"][0]
             finish_reason = candidate.get("finishReason")
-
             if finish_reason and finish_reason not in ["STOP", "MAX_TOKENS", "FINISH_REASON_UNSPECIFIED"]:
-                 logger.error(f"Geração interrompida pela API. Motivo: {finish_reason}")
+                 logger.error(f"Geração API interrompida: {finish_reason}")
                  safety_ratings = candidate.get("safetyRatings", [])
                  harm_categories = [r['category'] for r in safety_ratings if r['probability'] not in ['NEGLIGIBLE', 'LOW']]
-                 if harm_categories: return f"❌ Resposta bloqueada por segurança. Motivo: {finish_reason} ({', '.join(harm_categories)})."
-                 else: return f"❌ Geração interrompida. Motivo: {finish_reason}."
-
+                 if harm_categories: return f"❌ Bloqueado por segurança: {finish_reason} ({','.join(harm_categories)})."
+                 else: return f"❌ Geração interrompida: {finish_reason}."
             if not candidate.get("content") or not candidate["content"].get("parts"):
-                 logger.error("Estrutura de resposta inesperada: Faltando content/parts.")
+                 logger.error("Estrutura resposta API inesperada.")
                  if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(CONFIG['retry_delay'] * (tentativa + 1)); continue
-                 return "❌ Resposta inválida da API (estrutura inesperada)."
-
+                 return "❌ Resposta API inválida (estrutura)."
             texto_gerado = candidate["content"]["parts"][0]["text"].strip()
-            logger.info(f"API retornou com sucesso ({len(texto_gerado)} chars). Finish Reason: {finish_reason}")
+            logger.info(f"API retornou com sucesso ({len(texto_gerado)} chars). Finish: {finish_reason}")
             return texto_gerado
-
         except requests.Timeout:
-            logger.warning(f"Timeout na API - Tentativa {tentativa + 1}.")
+            logger.warning(f"Timeout API - Tentativa {tentativa + 1}.")
             if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(CONFIG['retry_delay'] * (tentativa + 1)); continue
-            return "⏱️ Tempo esgotado na comunicação com a API."
+            return "⏱️ Tempo esgotado API."
         except requests.RequestException as e:
-            logger.error(f"Erro de Rede/Requisição API - Tentativa {tentativa + 1}: {e}")
+            logger.error(f"Erro Rede/Requisição API - Tentativa {tentativa + 1}: {e}")
             if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(CONFIG['retry_delay'] * (tentativa + 1)); continue
-            return f"❌ Erro de conexão com a API: {e}"
+            return f"❌ Erro conexão API: {e}"
         except json.JSONDecodeError as e:
-             logger.error(f"Erro ao decodificar JSON da API: {e}")
+             logger.error(f"Erro JSON API: {e}")
              logger.debug(f"Resposta não-JSON: {response.text[:500]}")
-             return f"❌ Erro ao processar a resposta da API (JSON inválido)."
+             return f"❌ Erro processar resposta API (JSON inválido)."
         except Exception as e:
-            logger.exception(f"Erro inesperado na chamada da API - Tentativa {tentativa + 1}: {str(e)}")
+            logger.exception(f"Erro inesperado API - Tentativa {tentativa + 1}: {str(e)}")
             if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(CONFIG['retry_delay'] * (tentativa + 1)); continue
-            return f"❌ Erro inesperado no processamento da API: {str(e)}"
-
-    logger.error("Falha ao chamar a API após todas as tentativas.")
-    return "❌ Falha ao comunicar com a API após múltiplas tentativas."
+            return f"❌ Erro inesperado API: {str(e)}"
+    logger.error("Falha API após todas as tentativas.")
+    return "❌ Falha API após múltiplas tentativas."
 
 def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=None, modo_treinamento=False):
     logger.info(f"Iniciando correção. Tipo={tipo_peticao}, Treinamento={modo_treinamento}")
@@ -555,60 +323,32 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
     analise_formatada, peticao_corrigida_final, resumo_diff, criticas_diff, diff_html = "", "", "", "", ""
     peticao_conteudo = ""
     try:
-        if not caso or not caso.strip():
-            logger.warning("Caso não fornecido.")
-            return "⚠️ Forneça o caso/contexto da peça.", "", "", "", ""
-        if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO:
-             logger.warning(f"Tipo de petição inválido ou não fornecido: {tipo_peticao}")
-             return "⚠️ Selecione um tipo de petição válido.", "", "", "", ""
-
+        if not caso or not caso.strip(): return "⚠️ Forneça o caso.", "", "", "", ""
+        if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO: return "⚠️ Selecione tipo.", "", "", "", ""
         if peticao_arquivo is not None:
-            logger.info("Processando arquivo de petição...")
             peticao_conteudo = process_file(peticao_arquivo)
-            if peticao_conteudo.startswith("❌") or peticao_conteudo.startswith("⚠️"):
-                logger.error(f"Erro ao processar arquivo: {peticao_conteudo}")
-                return peticao_conteudo, "", "", "", ""
-        elif peticao_texto and peticao_texto.strip():
-             peticao_conteudo = peticao_texto
-        else:
-            logger.warning("Nenhuma petição fornecida (texto ou arquivo).")
-            return "⚠️ Forneça a petição (em texto ou arquivo).", "", "", "", ""
+            if peticao_conteudo.startswith(("❌", "⚠️")): return peticao_conteudo, "", "", "", ""
+        elif peticao_texto and peticao_texto.strip(): peticao_conteudo = peticao_texto
+        else: return "⚠️ Forneça a petição.", "", "", "", ""
         logger.info(f"Petição recebida ({len(peticao_conteudo)} chars).")
-
         troll_triggers = ["escreva a petição", "faça a petição", "redija a petição", "elabore a petição", "crie a petição", "gere a petição", "faça para mim", "faça por mim"]
         if any(trigger in peticao_conteudo.lower() for trigger in troll_triggers):
             logger.info("Detectado pedido para escrever petição.")
-            return random.choice([
-                "Hummm... Parece que você quer que *eu* faça o trabalho, né? 😉 Que tal você tentar escrever a peça e *eu* te ajudo a corrigir?",
-                "🚫 Opa! Meu trabalho é *corrigir* e *ensinar*, não fazer a peça do zero. Mostre o que você fez e eu te dou o feedback!",
-            ]), "", "", "", ""
-
+            return random.choice(["Hummm... 😉", "🚫 Opa! Corrijo, não crio."]), "", "", "", ""
         cache_key = f"{tipo_peticao}|{caso[:100]}|{peticao_conteudo[:100]}|{modo_treinamento}"
         if cache_key in CORRECAO_CACHE:
             logger.info("Correção encontrada no cache.")
-            cached_data = CORRECAO_CACHE[cache_key]
-            return cached_data["analise_formatada"], cached_data["peticao_corrigida"], cached_data["resumo_diff"], cached_data["criticas_diff"], cached_data["diff_html"]
-
-        logger.info("Estruturando prompt de análise...")
+            cached = CORRECAO_CACHE[cache_key]
+            return cached["analise_formatada"], cached["peticao_corrigida"], cached["resumo_diff"], cached["criticas_diff"], cached["diff_html"]
         prompt_analise = estruturar_prompt_analise(caso, peticao_conteudo, tipo_peticao, modo_treinamento)
-        logger.info("Chamando API para análise...")
         analise_bruta = chamar_api(prompt_analise)
-        if analise_bruta.startswith(("❌", "⏱️", "⚠️")):
-            logger.error(f"Erro retornado pela API (Análise): {analise_bruta}")
-            return analise_bruta, "", "", "", ""
-        logger.info("Análise recebida. Formatando...")
+        if analise_bruta.startswith(("❌", "⏱️", "⚠️")): return analise_bruta, "", "", "", ""
         analise_formatada = formatar_correcao(analise_bruta)
-
-        logger.info("Estruturando prompt para peça corrigida...")
         prompt_peticao = estruturar_prompt_peticao_corrigida(caso, peticao_conteudo, tipo_peticao)
-        logger.info("Chamando API para gerar peça corrigida...")
         peticao_corrigida_bruta = chamar_api(prompt_peticao)
-
         if peticao_corrigida_bruta.startswith(("❌", "⏱️", "⚠️")):
-            logger.error(f"Erro retornado pela API (Correção): {peticao_corrigida_bruta}")
-            peticao_corrigida_final = f"⚠️ Falha ao gerar a versão corrigida:\n{peticao_corrigida_bruta}"
+            peticao_corrigida_final = f"⚠️ Falha ao gerar versão corrigida:\n{peticao_corrigida_bruta}"
         else:
-            logger.info("Peça corrigida recebida. Aplicando pós-correção...")
             start_markers = ["excelentíssimo", "eméritos julgadores", "meritíssimo juízo"]
             start_index = -1
             peticao_lower_corr = peticao_corrigida_bruta.lower()
@@ -617,390 +357,268 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
                 if idx != -1: start_index = idx; break
             peticao_extraida = peticao_corrigida_bruta[start_index:] if start_index != -1 else peticao_corrigida_bruta
             peticao_corrigida_final = pos_corrigir_peticao(peticao_extraida, tipo_peticao)
-            logger.info("Pós-correção aplicada.")
-
-        logger.info("Calculando diferenças...")
         diff_html, resumo_diff, criticas_diff = calcular_diff_interno(peticao_conteudo, peticao_corrigida_final)
-        logger.info("Diferenças calculadas.")
-
         resultado_cache = {"analise_formatada": analise_formatada,"peticao_corrigida": peticao_corrigida_final,"resumo_diff": resumo_diff,"criticas_diff": criticas_diff,"diff_html": diff_html}
         CORRECAO_CACHE[cache_key] = resultado_cache
         HISTORICO.append({"data": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),"tipo_peticao": tipo_peticao,"caso": caso,"peticao_original": peticao_conteudo,**resultado_cache})
         if len(HISTORICO) > 10: HISTORICO.pop(0)
-
         end_time = time.time()
         logger.info(f"Correção concluída em {end_time - start_time:.2f} segundos.")
         return analise_formatada, peticao_corrigida_final, resumo_diff, criticas_diff, diff_html
-
     except Exception as e:
         logger.exception("Erro GERAL inesperado dentro de corrigir_peticao:")
-        error_message = f"❌ Erro inesperado na função de correção: {str(e)}\nConsulte os logs para detalhes."
-        return error_message, "", "", "", ""
+        return f"❌ Erro inesperado correção: {str(e)}", "", "", "", ""
 
 def formatar_correcao(texto):
     texto = texto.replace("### Análise Geral", "## 📝 Análise Geral")
     texto = texto.replace("### Nota Final", "## ⭐ Nota Final")
     texto = texto.replace("### Pontos Positivos", "## ✅ Pontos Positivos")
     texto = texto.replace("### Pontos a Melhorar", "## ⚠️ Pontos a Melhorar")
-    texto = texto.replace("### Análise Específica dos Requisitos", "## 🔎 Análise Específica dos Requisitos")
-    linhas = texto.split('\n')
-    linhas_formatadas = []
+    texto = texto.replace("### Análise Específica dos Requisitos", "## 🔎 Análise Específica")
+    linhas = texto.split('\n'); linhas_formatadas = []
     in_list = False
     for linha in linhas:
-        linha_strip = linha.strip()
-        if linha_strip.startswith(("1.","2.","3.","4.","5.")):
-             linhas_formatadas.append(f"\n**{linha_strip}**")
-             in_list = False
-        elif linha_strip.startswith(("- ","* ")):
-             prefix = "  * " if in_list else "* "
-             linhas_formatadas.append(prefix + linha_strip[2:])
-             in_list = True
-        elif linha_strip.startswith(("a)","b)","c)","d)","e)")):
-             linhas_formatadas.append(f"    * {linha_strip}")
-             in_list = True
-        else:
-            linhas_formatadas.append(linha)
-            if not linha_strip.startswith(("*", "- ", "a)", "b)", "c)", "d)", "e)"," ")):
-                 in_list = False
+        ls = linha.strip()
+        if ls.startswith(("1.","2.","3.","4.","5.")): linhas_formatadas.append(f"\n**{ls}**"); in_list = False
+        elif ls.startswith(("- ","* ")): prefix = "  * " if in_list else "* "; linhas_formatadas.append(prefix + ls[2:]); in_list = True
+        elif ls.startswith(("a)","b)","c)","d)","e)")): linhas_formatadas.append(f"    * {ls}"); in_list = True
+        else: linhas_formatadas.append(linha); in_list = False if not ls.startswith(("*","- ","a)","b)","c)","d)","e)"," ")) else in_list
     texto_final = "\n".join(linhas_formatadas)
-    nota_pattern = r"(\*\*Nota Final:?\*\*\s*)(\d{1,2}[,.]\d{1}|\d{1,2})"
-    match = re.search(nota_pattern, texto_final, re.IGNORECASE)
-    if match:
-        nota = match.group(2).replace(",",".")
-        texto_final = re.sub(nota_pattern, f"\\1**{nota}/10**", texto_final, count=1, flags=re.IGNORECASE)
+    m = re.search(r"(\*\*Nota Final:?\*\*\s*)(\d{1,2}[,.]\d{1}|\d{1,2})", texto_final, re.I)
+    if m: nota = m.group(2).replace(",","."); texto_final = re.sub(r"(\*\*Nota Final:?\*\*\s*)(\d{1,2}[,.]\d{1}|\d{1,2})", f"\\1**{nota}/10**", texto_final, count=1, flags=re.I)
     return texto_final
 
 def fornecer_dica_contextual(texto_peticao, tipo_peticao):
-    if not texto_peticao or not texto_peticao.strip():
-        return "*Digite algo na peça para receber dicas...*"
+    if not texto_peticao or not texto_peticao.strip(): return "*Digite para dicas...*"
     dicas_relevantes = []
     texto_lower = texto_peticao.lower()
     for chave in ["Clareza e Concisão", "Fundamentação Legal", "Revisão Ortográfica"]:
-        if chave in DICAS_OAB_MELHORADO:
-             dicas_relevantes.append(f"💡 **{chave}:** {DICAS_OAB_MELHORADO[chave]}")
+        if chave in DICAS_OAB_MELHORADO: dicas_relevantes.append(f"💡 **{chave}:** {DICAS_OAB_MELHORADO[chave]}")
     keywords_por_tipo = {
-        "Petição Inicial": ["endereçamento", "qualificação", "fatos", "fundamentos", "pedidos", "valor", "provas", "audiência", "citação", "custas"],
-        "Contestação": ["preliminar", "mérito", "impugnação", "improcedência", "honorários", "art. 337", "art. 341"],
-        "Reconvenção": ["reconvinte", "reconvindo", "conexão", "art. 343"],
-        "Impugnação à Contestação": ["réplica", "preliminar", "fatos novos", "documentos", "ratifica", "art. 350"],
-        "Embargos de Declaração": ["omissão", "contradição", "obscuridade", "erro material", "art. 1022"],
-        "Recurso de Apelação": ["sentença", "reforma", "anulação", "dialeticidade", "preparo", "tribunal", "art. 1009"],
-        "Agravo de Instrumento": ["interlocutória", "cabimento", "urgência", "efeito suspensivo", "art. 1015", "art. 1017"],
-        "Petição de Tutela Provisória": ["urgência", "evidência", "liminar", "periculum", "fumus boni", "art. 300", "art. 311"],
+        "Petição Inicial": ["endereçamento","qualificação","fatos","fundamentos","pedidos","valor","provas","audiência","citação","custas"],
+        "Contestação": ["preliminar","mérito","impugnação","improcedência","honorários","art. 337","art. 341"],
+        "Embargos de Declaração": ["omissão","contradição","obscuridade","erro material","art. 1022"],
+        "Recurso de Apelação": ["sentença","reforma","anulação","dialeticidade","preparo","tribunal","art. 1009"],
+        "Agravo de Instrumento": ["interlocutória","cabimento","urgência","efeito suspensivo","art. 1015"],
+        "Petição de Tutela Provisória": ["urgência","evidência","liminar","periculum","fumus boni","art. 300"],
     }
     if tipo_peticao in keywords_por_tipo:
          for chave, dica in DICAS_OAB_MELHORADO.items():
-              chave_lower = chave.lower()
-              if f"({tipo_peticao.split()[0].lower()})" in chave_lower or \
-                 any(kw in chave_lower for kw in keywords_por_tipo[tipo_peticao] if kw in texto_lower):
-                    dica_formatada = f"💡 **{chave}:** {dica}"
-                    if dica_formatada not in dicas_relevantes:
-                         dicas_relevantes.append(dica_formatada)
-    if not dicas_relevantes:
-        return "*Continue escrevendo ou selecione o tipo de peça para dicas mais específicas.*"
+              cl = chave.lower()
+              if f"({tipo_peticao.split()[0].lower()})" in cl or any(kw in cl for kw in keywords_por_tipo[tipo_peticao] if kw in texto_lower):
+                    dica_fmt = f"💡 **{chave}:** {dica}"
+                    if dica_fmt not in dicas_relevantes: dicas_relevantes.append(dica_fmt)
+    if not dicas_relevantes: return "*Continue escrevendo para dicas...*"
     return "\n\n".join(dicas_relevantes[:4])
 
 def calcular_diff_interno(texto_original, texto_corrigido):
-    if not texto_original or not texto_corrigido or texto_corrigido.startswith(("⚠️","❌")):
-        return "","",""
-    orig_lines = texto_original.splitlines()
-    corr_lines = texto_corrigido.splitlines()
+    if not texto_original or not texto_corrigido or texto_corrigido.startswith(("⚠️","❌")): return "","",""
+    orig_lines = texto_original.splitlines(); corr_lines = texto_corrigido.splitlines()
     diff = difflib.ndiff(orig_lines, corr_lines)
-    resultado_diff_html = []
-    criticas = []
-    linhas_removidas = 0
-    linhas_adicionadas = 0
-    keywords_criticas_removidas = ["invenção", "identificação", "erro crasso", "incorreto", "prazo"]
-    keywords_criticas_adicionadas = ["custas", "art. 319", "art. 337", "art. 1022", "art. 1015", "art. 300", "fumus", "periculum", "essencial", "preliminar", "tempestividade", "cabimento"]
+    res_html, crit, l_rem, l_add = [], [], 0, 0
+    kw_rem = ["invenção", "identificação", "erro crasso", "incorreto", "prazo"]
+    kw_add = ["custas", "art. 319", "art. 337", "art. 1022", "art. 1015", "art. 300", "fumus", "periculum", "essencial", "preliminar", "tempestividade", "cabimento"]
     for linha in diff:
-        texto = linha[2:]
-        texto_escaped = escape(texto)
-        if linha.startswith('  '): resultado_diff_html.append(f"<div class='linha-igual'>{texto_escaped}</div>")
-        elif linha.startswith('- '):
-            linhas_removidas += 1
-            resultado_diff_html.append(f"<div class='linha-removida' title='Removido'><del>{texto_escaped}</del></div>")
-            if texto.strip() and any(kw in texto.lower() for kw in keywords_criticas_removidas): criticas.append(f"<span style='color: red;'>🔴 REMOVIDO:</span> {texto_escaped}")
-        elif linha.startswith('+ '):
-            linhas_adicionadas += 1
-            resultado_diff_html.append(f"<div class='linha-adicionada' title='Adicionado'><ins>{texto_escaped}</ins></div>")
-            if texto.strip() and any(kw in texto.lower() for kw in keywords_criticas_adicionadas): criticas.append(f"<span style='color: green;'>🟢 ADICIONADO:</span> {texto_escaped}")
-    resumo_estatistico = f"**Resumo:**\n* Removidas: {linhas_removidas}\n* Adicionadas: {linhas_adicionadas}\n* **Saldo:** {linhas_adicionadas - linhas_removidas} linhas"
-    criticas_texto = "### 🚨 Mudanças Críticas / Essenciais:\n" + "\n".join(criticas) if criticas else "*Nenhuma mudança crítica/essencial detectada.*"
-    css = """<style>.diff-container { font-family: monospace; white-space: pre-wrap; border: 1px solid #ccc; padding: 10px; background-color: #f9f9f9; max-height: 600px; overflow-y: auto;} .linha-igual { color: #555; margin: 1px 0; } .linha-removida { background-color: #ffebee; color: #c62828; margin: 1px 0; } .linha-adicionada { background-color: #e8f5e9; color: #2e7d32; margin: 1px 0; } .linha-removida del, .linha-adicionada ins { text-decoration: none; padding: 0 2px; border-radius: 2px; } .linha-removida del { background-color: #ffcdd2; } .linha-adicionada ins { background-color: #c8e6c9; }</style>"""
-    visualizacao_detalhada_html = f"{css}<div class='diff-container'>{''.join(resultado_diff_html)}</div>"
-    return visualizacao_detalhada_html, resumo_estatistico, criticas_texto
+        txt = linha[2:]; txt_esc = escape(txt)
+        if linha.startswith('  '): res_html.append(f"<div class='linha-igual'>{txt_esc}</div>")
+        elif linha.startswith('- '): l_rem += 1; res_html.append(f"<div class='linha-removida'><del>{txt_esc}</del></div>"); \
+                                       if txt.strip() and any(kw in txt.lower() for kw in kw_rem): crit.append(f"<span style='color:red'>🔴 REMOVIDO:</span> {txt_esc}")
+        elif linha.startswith('+ '): l_add += 1; res_html.append(f"<div class='linha-adicionada'><ins>{txt_esc}</ins></div>"); \
+                                       if txt.strip() and any(kw in txt.lower() for kw in kw_add): crit.append(f"<span style='color:green'>🟢 ADICIONADO:</span> {txt_esc}")
+    resumo = f"**Resumo:** Rem={l_rem}, Add={l_add}, Saldo={l_add - l_rem}"
+    crit_txt = "### 🚨 Mudanças Críticas:\n" + "\n".join(crit) if crit else "*Nenhuma mudança crítica detectada.*"
+    css = "<style>.diff-container{font-family:monospace;white-space:pre-wrap;border:1px solid #ccc;padding:10px;background-color:#f9f9f9;max-height:600px;overflow-y:auto}.linha-igual{color:#555}.linha-removida{background-color:#ffebee;color:#c62828}.linha-adicionada{background-color:#e8f5e9;color:#2e7d32}.linha-removida del,.linha-adicionada ins{text-decoration:none;padding:0 2px;border-radius:2px}.linha-removida del{background-color:#ffcdd2}.linha-adicionada ins{background-color:#c8e6c9}</style>"
+    html_diff = f"{css}<div class='diff-container'>{''.join(res_html)}</div>"
+    return html_diff, resumo, crit_txt
 
 def calcular_progresso():
-    if not HISTORICO: return "📊 Nenhum progresso registrado ainda."
-    notas = []
-    tipos_corrigidos = set()
+    if not HISTORICO: return "📊 Nenhum progresso."
+    notas, tipos = [], set()
     for entry in HISTORICO:
-        tipos_corrigidos.add(entry["tipo_peticao"])
-        match = re.search(r"Nota Final:?\s*\**(\d{1,2}[,.]\d{1}|\d{1,2})\s*/\s*10", entry["analise_formatada"], re.IGNORECASE)
-        if match:
-            try: notas.append(float(match.group(1).replace(",", ".")))
-            except ValueError: pass
-    total_corridas = len(HISTORICO)
-    media = sum(notas) / len(notas) if notas else 0
-    tendencia = ""
-    if len(notas) > 1:
-        if notas[-1] > notas[-2]: tendencia = "⬆️ Melhorando"
-        elif notas[-1] < notas[-2]: tendencia = "⬇️ Piorando"
-        else: tendencia = "↔️ Estável"
-    progresso_texto = f"**📊 Resumo:**\n* Correções: {total_corridas}\n* Tipos: {', '.join(sorted(list(tipos_corrigidos)))}\n* Média: {media:.1f}/10 ({len(notas)} válidas)\n* Tendência: {tendencia if tendencia else 'N/A'}"
-    return progresso_texto
+        tipos.add(entry["tipo_peticao"])
+        m = re.search(r"Nota Final:?\s*\**(\d{1,2}[,.]\d{1}|\d{1,2})\s*/\s*10", entry["analise_formatada"], re.I)
+        if m: try: notas.append(float(m.group(1).replace(",", "."))) except ValueError: pass
+    tot = len(HISTORICO); media = sum(notas)/len(notas) if notas else 0
+    tend = ""
+    if len(notas) > 1: tend = "⬆️" if notas[-1] > notas[-2] else ("⬇️" if notas[-1] < notas[-2] else "↔️")
+    return f"**📊 Resumo:** Corrs:{tot}, Tipos:{len(tipos)}, Média:{media:.1f}/10 ({len(notas)} val), Tend:{tend if tend else 'N/A'}"
 
 def mostrar_historico():
     if not HISTORICO: return "📜 Histórico vazio."
-    historico_md = "### 📜 Histórico (Últimas 10)\n---\n"
+    md = "### 📜 Histórico (Últimas 10)\n---\n"
     for i, entry in enumerate(reversed(HISTORICO)):
-        caso_resumo = (entry['caso'][:80] + '...') if len(entry['caso']) > 80 else entry['caso']
-        nota_str = "N/A"
-        match = re.search(r"Nota Final:?\s*\**(\d{1,2}[,.]\d{1}|\d{1,2})\s*/\s*10", entry["analise_formatada"], re.IGNORECASE)
-        if match: nota_str = f"{match.group(1).replace(',', '.')}/10"
-        historico_md += f"**{len(HISTORICO)-i}.** {entry['data']} | **Tipo:** {entry['tipo_peticao']} | **Nota:** {nota_str}\n   **Caso:** _{caso_resumo}_\n---\n"
-    return historico_md
+        caso = (entry['caso'][:70] + '...') if len(entry['caso']) > 70 else entry['caso']
+        nota = "N/A"; m = re.search(r"Nota Final:?\s*\**(\d{1,2}[,.]\d{1}|\d{1,2})\s*/\s*10", entry["analise_formatada"], re.I)
+        if m: nota = f"{m.group(1).replace(',', '.')}/10"
+        md += f"**{len(HISTORICO)-i}.** {entry['data']} | **{entry['tipo_peticao']}** | **Nota:{nota}**\n   **Caso:** _{caso}_\n---\n"
+    return md
 
 def salvar_progresso(caso, peticao, tipo_peticao):
-    logger.info("Iniciando salvamento de progresso...")
+    logger.info("Salvando progresso...")
     try:
-        if not caso or not peticao or not tipo_peticao:
-            logger.warning("Inputs insuficientes para salvar progresso.")
-            return "", "⚠️ Caso, Petição e Tipo são necessários para salvar.", None
-        dados_progresso = {"tipo_peticao": tipo_peticao, "caso": caso, "peticao": peticao, "timestamp": datetime.now().isoformat()}
-        json_content = json.dumps(dados_progresso, ensure_ascii=False, indent=4)
-        timestamp_str = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"progresso_peticao_{timestamp_str}.json"
-        temp_dir = tempfile.gettempdir()
-        temp_file_path = os.path.join(temp_dir, filename)
-        with open(temp_file_path, 'w', encoding='utf-8') as f: f.write(json_content)
-        logger.info(f"Progresso salvo com sucesso em: {temp_file_path}")
-        success_message = f"✅ Progresso salvo! Baixe `{filename}`."
-        return json_content, success_message, temp_file_path
-    except Exception as e:
-        logger.error(f"Erro ao salvar progresso: {str(e)}", exc_info=True)
-        return "", f"❌ Erro ao salvar: {str(e)}", None
+        if not caso or not peticao or not tipo_peticao: return "", "⚠️ Inputs necessários.", None
+        dados = {"tipo_peticao": tipo_peticao, "caso": caso, "peticao": peticao, "timestamp": datetime.now().isoformat()}
+        json_cont = json.dumps(dados, ensure_ascii=False, indent=4)
+        fname = f"progresso_peticao_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        fpath = os.path.join(tempfile.gettempdir(), fname)
+        with open(fpath, 'w', encoding='utf-8') as f: f.write(json_cont)
+        logger.info(f"Progresso salvo: {fpath}")
+        msg = f"✅ Salvo! Baixe `{fname}`."
+        return json_cont, msg, fpath
+    except Exception as e: logger.error(f"Erro salvar: {e}", exc_info=True); return "", f"❌ Erro salvar: {e}", None
 
 def carregar_progresso(arquivo_entrada):
-    logger.info("Iniciando carregamento de progresso...")
-    if arquivo_entrada is None: return "", "", "", "⚠️ Nenhum arquivo selecionado."
+    logger.info("Carregando progresso...")
+    if arquivo_entrada is None: return "", "", "", "⚠️ Nenhum arquivo."
     try:
-        file_path = arquivo_entrada.name
-        logger.info(f"Carregando progresso do arquivo: {file_path}")
-        with open(file_path, 'r', encoding='utf-8') as f: dados = json.load(f)
-        caso = dados.get("caso")
-        peticao = dados.get("peticao")
-        tipo_peticao = dados.get("tipo_peticao")
-        if caso is None or peticao is None or tipo_peticao is None:
-             logger.warning(f"Arquivo JSON carregado não contém chaves esperadas: {dados.keys()}")
-             return "", "", "", "❌ Erro: Arquivo de progresso inválido."
-        if tipo_peticao not in TIPOS_DE_PETICAO:
-             logger.warning(f"Tipo de petição '{tipo_peticao}' do arquivo não é válido.")
-             return caso, peticao, "", f"⚠️ Tipo '{tipo_peticao}' inválido. Selecione manualmente."
-        logger.info("Progresso carregado com sucesso.")
-        return tipo_peticao, caso, peticao, "✅ Progresso carregado!"
-    except json.JSONDecodeError:
-        logger.error(f"Erro ao decodificar JSON do arquivo: {file_path}")
-        return "", "", "", "❌ Erro: Arquivo não é JSON válido."
-    except Exception as e:
-        logger.error(f"Erro ao carregar o progresso: {str(e)}", exc_info=True)
-        return "", "", "", f"❌ Erro inesperado ao carregar: {str(e)}"
+        fpath = arquivo_entrada.name
+        logger.info(f"Carregando: {fpath}")
+        with open(fpath, 'r', encoding='utf-8') as f: dados = json.load(f)
+        caso, peticao, tipo = dados.get("caso"), dados.get("peticao"), dados.get("tipo_peticao")
+        if not all([caso, peticao, tipo]): return "", "", "", "❌ Arquivo inválido."
+        if tipo not in TIPOS_DE_PETICAO: return caso, peticao, "", f"⚠️ Tipo '{tipo}' inválido."
+        logger.info("Progresso carregado.")
+        return tipo, caso, peticao, "✅ Progresso carregado!"
+    except Exception as e: logger.error(f"Erro carregar: {e}", exc_info=True); return "", "", "", f"❌ Erro carregar: {e}"
 
 def estruturar_prompt_geracao_caso(tipo_peticao="Petição Inicial"):
-    prompt = f"""
-    Crie um caso fictício **detalhado e realista** para um exercício prático de elaboração de uma peça do tipo **"{tipo_peticao}"**, simulando um cenário de Exame de Ordem (OAB).
-    **Instruções Gerais:**
-    1. Complexidade Adequada (15-25 linhas).
-    2. Dados Essenciais: Nomes, locais, datas, valores, relação jurídica, conflito.
-    3. Coerência: Fatos lógicos justificando a peça.
-    4. Foco no Tipo de Peça: Cenário deve exigir a **{tipo_peticao}**.
-    **Instruções Específicas para "{tipo_peticao}":**
-    """
-    if tipo_peticao == "Petição Inicial":
-        prompt += """* Descreva violação de direitos (contrato descumprido, dano, etc.) onde cliente busca tutela inicial. * Inclua elementos para danos materiais/morais. * Forneça dados para qualificação das partes. * **Exemplo Tema:** Consumo, inadimplemento, cobrança indevida, despejo."""
-    elif tipo_peticao == "Contestação":
-        prompt += """* **PRIMEIRO:** Resumo da Petição Inicial recebida pelo réu (autor, alegações, pedidos). * **DEPOIS:** Versão dos fatos do RÉU, incluindo informações para: Alegar preliminares; Impugnar fatos; Apresentar defesa de mérito (pagamento, prescrição, etc.). * Forneça dados qualificação réu."""
-    elif tipo_peticao == "Reconvenção":
-         prompt += """* Siga estrutura **Contestação**: Resumo Petição Inicial + Versão Réu. * **ADICIONE fatos/fundamentos** para RÉU fazer pedido PRÓPRIO contra AUTOR ORIGINAL (CONEXO com ação/defesa). * **Exemplo:** Cobrança -> Réu contesta e reconvém pedindo indenização por danos no mesmo negócio."""
-    elif tipo_peticao == "Impugnação à Contestação":
-        prompt += """* Resumo Petição Inicial do Autor. * **Resumo Contestação** do réu, destacando: Preliminares arguidas; Fatos novos (impeditivos/modificativos/extintivos); Documentos juntados. * Objetivo: fornecer elementos para Autor rebater contestação."""
-    elif tipo_peticao == "Embargos de Declaração":
-        prompt += """* Breve descrição caso original. * **Apresente DISPOSITIVO ou TRECHO FUNDAMENTAL de DECISÃO JUDICIAL** (sentença/acórdão). * **INDIQUE CLARAMENTE vício** (omissão, contradição, obscuridade, erro material) NESSA DECISÃO, dando contexto. * **Exemplo:** "Sentença julgou X, mas omissa quanto a Y." OU "Acórdão afirmou X e concluiu Y (contradição)." """
-    elif tipo_peticao == "Recurso de Apelação":
-        prompt += """* Descrição caso original. * **Resumo da SENTENÇA** (procedente/improcedente/parcial, fundamentos juiz). * **FORNEÇA ELEMENTOS indicando ERRO na sentença** (in judicando/in procedendo) que justifiquem reforma/anulação. * **Exemplo:** "Sentença ignorou prova X." OU "Juiz indeferiu testemunha chave Y (cerceamento)." * Indique cliente (apelante)."""
-    elif tipo_peticao == "Agravo de Instrumento":
-        prompt += """* Descrição caso em andamento. * **Apresente DECISÃO INTERLOCUTÓRIA específica**. * Decisão DEVE se enquadrar no Art. 1015 ou justificar mitigação. * **FORNEÇA ELEMENTOS indicando ERRO** na decisão E, se possível, **URGÊNCIA**. * **Exemplo:** "Juiz indeferiu JG apesar de prova." OU "Deferiu liminar sem comprovação mora." * Indique cliente (agravante)."""
-    elif tipo_peticao == "Petição de Tutela Provisória":
-        prompt += """* Situação de conflito com **urgência** (risco iminente) ou direito **evidente**. * **FORNEÇA ELEMENTOS claros demonstrando:** **Urgência:** Probabilidade do direito (fumus) E Perigo de dano (periculum). **Evidência:** Hipótese do Art. 311 (abuso defesa, repetitivo, etc.). * Indique medida específica desejada. * Especifique se antecedente ou incidental."""
-    else:
-         prompt += "* Crie cenário jurídico cível com conflito claro."
-    prompt += """
-    **Finalize o caso com:**
-    "**Situação-Problema:** Na qualidade de advogado(a) de [Nome do Cliente], elabore a peça processual cabível ({tipo_peticao})."
-    **Importante:** Evite casos muito específicos. Foque em temas comuns. Seja criativo!
-    """
+    prompt = f"Crie caso fictício **detalhado e realista** p/ peça **'{tipo_peticao}'** (simulado OAB).\n**Geral:**\n1.Complexidade adequada (15-25l).\n2.Dados Essenciais (nomes,locais,datas,valores,relação,conflito).\n3.Coerência.\n4.Foco no Tipo Peça.\n**Específico '{tipo_peticao}':**\n"
+    if tipo_peticao == "Petição Inicial": prompt += "* Descreva violação direitos. * Inclua danos. * Dados qualificação. * Tema: Consumo, Contrato, etc."
+    elif tipo_peticao == "Contestação": prompt += "* Resumo PI recebida. * Versão Réu (p/ preliminares, impugnação, mérito). * Dados qualificação réu."
+    elif tipo_peticao == "Reconvenção": prompt += "* Estrutura Contestação + Fatos/Fundamentos p/ pedido PRÓPRIO CONEXO do Réu contra Autor."
+    elif tipo_peticao == "Impugnação à Contestação": prompt += "* Resumo PI Autor. * Resumo Contestação Réu (preliminares, fatos novos, docs). * Objetivo: Rebater contestação."
+    elif tipo_peticao == "Embargos de Declaração": prompt += "* Breve caso. * TRECHO DECISÃO JUDICIAL. * INDIQUE VÍCIO (omissão/contradição/obscuridade/erro material) NESSA DECISÃO."
+    elif tipo_peticao == "Recurso de Apelação": prompt += "* Caso original. * Resumo SENTENÇA. * ELEMENTOS indicando ERRO (in judicando/procedendo). * Indique cliente (apelante)."
+    elif tipo_peticao == "Agravo de Instrumento": prompt += "* Caso em andamento. * DECISÃO INTERLOCUTÓRIA. * Enquadrar Art.1015/mitigação. * ELEMENTOS indicando ERRO + URGÊNCIA. * Indique cliente (agravante)."
+    elif tipo_peticao == "Petição de Tutela Provisória": prompt += "* Situação URGENTE ou EVIDENTE. * ELEMENTOS: Urgência=Fumus+Periculum; Evidência=Hipótese Art.311. * Medida específica. * Antecedente ou Incidental."
+    else: prompt += "* Crie cenário cível com conflito claro."
+    prompt += f'\n**Finalize:**\n"**Situação-Problema:** Advogado(a) de [Nome Cliente], elabore a peça cabível ({tipo_peticao})."\n**Importante:** Temas comuns. Seja criativo!'
     return prompt
 
 def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
-    logger.info(f"Solicitada geração de caso para: {tipo_peticao}")
+    logger.info(f"Gerando caso para: {tipo_peticao}")
     try:
-        if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO:
-            logger.warning(f"Tentativa de gerar caso com tipo inválido: {tipo_peticao}")
-            return "⚠️ Erro: Selecione um tipo de petição válido antes de gerar o caso."
-        logger.info("Estruturando prompt para geração de caso...")
+        if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO: return "⚠️ Selecione tipo válido."
         prompt = estruturar_prompt_geracao_caso(tipo_peticao)
-        logger.info("Chamando API para gerar caso...")
         caso_gerado = chamar_api(prompt)
-        if caso_gerado.startswith(("❌","⏱️","⚠️")):
-            logger.error(f"Erro da API ao gerar caso: {caso_gerado}")
-            return f"⚠️ Falha ao gerar caso fictício:\n{caso_gerado}"
-        frase_final_padrao = f"**Situação-Problema:** Na qualidade de advogado(a) de"
-        if frase_final_padrao.lower() not in caso_gerado.lower():
-            logger.warning("Frase 'Situação-Problema' não encontrada. Adicionando manualmente.")
-            nomes_possiveis = re.findall(r"[A-Z][a-z]+(?:\s[A-Z][a-z]+)+", caso_gerado)
-            cliente_nome = nomes_possiveis[0] if nomes_possiveis else "[Cliente]"
-            caso_gerado += f"\n\n**Situação-Problema:** Na qualidade de advogado(a) de {cliente_nome}, elabore a peça processual cabível ({tipo_peticao})."
-        logger.info("Caso fictício gerado com sucesso.")
+        if caso_gerado.startswith(("❌","⏱️","⚠️")): return f"⚠️ Falha gerar caso:\n{caso_gerado}"
+        frase_final = "**Situação-Problema:** Na qualidade de advogado(a) de"
+        if frase_final.lower() not in caso_gerado.lower():
+            logger.warning("Frase final não encontrada. Adicionando.")
+            nomes = re.findall(r"[A-Z][a-z]+(?:\s[A-Z][a-z]+)+", caso_gerado)
+            cliente = nomes[0] if nomes else "[Cliente]"
+            caso_gerado += f"\n\n**Situação-Problema:** Na qualidade de advogado(a) de {cliente}, elabore a peça processual cabível ({tipo_peticao})."
+        logger.info("Caso gerado.")
         return caso_gerado
-    except Exception as e:
-        logger.exception("Erro inesperado dentro de gerar_caso_ficticio:")
-        return f"❌ Erro inesperado ao gerar o caso: {str(e)}"
+    except Exception as e: logger.exception("Erro gerar_caso:"); return f"❌ Erro gerar caso: {e}"
+
+# Função para atualizar config (faltante no traceback anterior)
+def atualizar_config(temp, timeout, tokens):
+    CONFIG["temperatura"] = temp
+    CONFIG["timeout"] = timeout
+    CONFIG["max_tokens"] = tokens
+    logger.info(f"Configs atualizadas: Temp={temp}, Timeout={timeout}, Tokens={tokens}")
+    return "✅ Configs Atualizadas!"
 
 def interface_gradio():
     with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="orange")) as demo:
-        gr.Markdown("# ⚖️ Corretor Jurídico OAB Master ⚖️")
-        gr.Markdown("Analise e aprimore suas peças processuais!")
+        gr.Markdown("# ⚖️ Corretor Jurídico OAB Master ⚖️\nAnalise e aprimore suas peças processuais!")
         with gr.Row():
             with gr.Column(scale=1):
                 gr.Markdown("### ⚙️ Configurações")
-                tipo_peticao_input = gr.Dropdown(label="1. Selecione o Tipo de Peça", choices=TIPOS_DE_PETICAO, value="Petição Inicial")
+                tipo_peticao_input = gr.Dropdown(label="1. Selecione o Tipo", choices=TIPOS_DE_PETICAO, value="Petição Inicial")
                 modo_treinamento = gr.Checkbox(label="🎓 Modo Treinamento", value=False)
-                with gr.Accordion("🛠️ Opções Avançadas da IA", open=False):
-                    temperatura_slider = gr.Slider(minimum=0.0, maximum=1.0, value=CONFIG["temperatura"], step=0.1, label="Criatividade")
-                    timeout_slider = gr.Slider(minimum=30, maximum=180, value=CONFIG["timeout"], step=10, label="Timeout API (seg)")
-                    max_tokens_slider = gr.Slider(minimum=2048, maximum=8192, value=CONFIG["max_tokens"], step=256, label="Max Resposta (Tokens)")
+                with gr.Accordion("🛠️ Opções Avançadas", open=False):
+                    temperatura_slider = gr.Slider(0.0, 1.0, value=CONFIG["temperatura"], step=0.1, label="Criatividade")
+                    timeout_slider = gr.Slider(30, 180, value=CONFIG["timeout"], step=10, label="Timeout (s)")
+                    max_tokens_slider = gr.Slider(2048, 8192, value=CONFIG["max_tokens"], step=256, label="Max Tokens")
                     config_update_btn = gr.Button("💾 Salvar Configs")
                     config_status = gr.Textbox(label="Status", interactive=False, lines=1)
                 with gr.Accordion("📊 Dashboard", open=False):
-                    progresso_output = gr.Markdown("*Atualize para ver estatísticas.*")
+                    progresso_output = gr.Markdown("*Atualize para ver.*")
                     progresso_btn = gr.Button("🔄 Atualizar Progresso")
                 with gr.Accordion("📜 Histórico", open=False):
-                    historico_output = gr.Markdown("*Atualize para ver histórico.*")
+                    historico_output = gr.Markdown("*Atualize para ver.*")
                     historico_btn = gr.Button("🔄 Ver Histórico")
                 with gr.Accordion("💾📂 Salvar/Carregar", open=False):
-                     salvar_btn = gr.Button("💾 Salvar Caso/Peça")
-                     carregar_btn = gr.Button("📂 Carregar Caso/Peça")
-                     arquivo_progresso_upload = gr.File(label="Selecione .json", file_types=[".json"], scale=2)
+                     salvar_btn = gr.Button("💾 Salvar")
+                     carregar_btn = gr.Button("📂 Carregar")
+                     arquivo_progresso_upload = gr.File(label="Selecione .json", file_types=[".json"])
                      progresso_download_file = gr.File(label="Baixar Progresso", interactive=False)
             with gr.Column(scale=3):
-                gr.Markdown("### 1. Forneça o Caso / Contexto")
+                gr.Markdown("### 1. Caso / Contexto")
                 with gr.Row():
-                     caso_input = gr.Textbox(label="📋 Caso ou Situação", lines=8, placeholder="Insira o texto COMPLETO do caso...")
-                     caso_btn = gr.Button("🎲 Gerar Caso", variant="secondary", scale=0)
-                gr.Markdown("### 2. Insira Sua Peça")
+                     caso_input = gr.Textbox(label="📋 Caso", lines=8, placeholder="Insira o texto do caso...")
+                     caso_btn = gr.Button("🎲 Gerar", variant="secondary", scale=0)
+                gr.Markdown("### 2. Sua Peça")
                 with gr.Tabs():
-                    with gr.TabItem("✏️ Digitar Texto"):
-                        peticao_texto_input = gr.Textbox(label="Texto da Peça", lines=12, placeholder="Cole ou digite sua peça aqui...")
-                        dica_contextual_output = gr.Markdown(value="*Dicas aparecerão aqui...*")
-                        btn_corrigir = gr.Button("🚀 CORRIGIR E ANALISAR!", variant="primary")
-                    with gr.TabItem("📎 Anexar Arquivo"):
-                        peticao_arquivo_input = gr.File(label="Arquivo (.pdf, .docx, .txt - Máx 15MB)", file_types=[".pdf", ".docx", ".txt"])
-                        arquivo_preview_output = gr.Textbox(label="🔍 Prévia do Arquivo", lines=4, interactive=False)
-                        btn_corrigir_arquivo = gr.Button("🚀 CORRIGIR E ANALISAR ARQUIVO!", variant="primary")
+                    with gr.TabItem("✏️ Texto"):
+                        peticao_texto_input = gr.Textbox(label="Texto da Peça", lines=12, placeholder="Cole ou digite...")
+                        dica_contextual_output = gr.Markdown("*Dicas...*")
+                        btn_corrigir = gr.Button("🚀 CORRIGIR!", variant="primary")
+                    with gr.TabItem("📎 Arquivo"):
+                        peticao_arquivo_input = gr.File(label="Arquivo (.pdf,.docx,.txt)", file_types=[".pdf",".docx",".txt"])
+                        arquivo_preview_output = gr.Textbox(label="🔍 Prévia", lines=4, interactive=False)
+                        btn_corrigir_arquivo = gr.Button("🚀 CORRIGIR ARQUIVO!", variant="primary")
 
         processing_message = gr.Markdown("", visible=False)
-
-        gr.Markdown("--- \n ### 3. Resultados da Correção")
+        gr.Markdown("--- \n ### 3. Resultados")
         with gr.Tabs():
-             with gr.TabItem("📊 Análise e Correção Sugerida"):
-                  resultado_analise_output = gr.Markdown(label="Análise Detalhada e Nota")
+             with gr.TabItem("📊 Análise e Correção"):
+                  resultado_analise_output = gr.Markdown(label="Análise e Nota")
                   resultado_peticao_corrigida_output = gr.Textbox(label="✨ Versão Sugerida", lines=18, show_copy_button=True)
-             with gr.TabItem("⚖️ Comparativo (Diff)"):
-                  gr.Markdown("### ↔️ Comparativo: Sua Peça vs. Versão Sugerida")
+             with gr.TabItem("⚖️ Comparativo"):
+                  gr.Markdown("### ↔️ Comparativo (Diff)")
                   with gr.Row():
-                       with gr.Column(scale=1):
-                            resumo_alteracoes_output = gr.Markdown(label="Resumo")
-                            criticas_output = gr.Markdown(label="Mudanças Críticas")
-                       with gr.Column(scale=3):
-                            visualizacao_detalhada_output = gr.HTML(label="Alterações Detalhadas")
-
-        clear_btn = gr.Button("🗑️ Limpar Campos e Resultados")
+                       with gr.Column(scale=1): resumo_alteracoes_output = gr.Markdown(label="Resumo"); criticas_output = gr.Markdown(label="Críticas")
+                       with gr.Column(scale=3): visualizacao_detalhada_output = gr.HTML(label="Detalhes")
+        clear_btn = gr.Button("🗑️ Limpar Tudo")
 
-        caso_btn.click(
-             fn=lambda: gr.update(value="⏳ Gerando caso...", visible=True), outputs=processing_message
-        ).then(
+        # --- Eventos ---
+        caso_btn.click(lambda: gr.update(value="⏳ Gerando...", visible=True), outputs=processing_message).then(
              fn=gerar_caso_ficticio, inputs=[tipo_peticao_input], outputs=[caso_input]
-        ).then(
-             fn=lambda: gr.update(value="", visible=False), outputs=processing_message
-        )
+        ).then(lambda: gr.update(value="", visible=False), outputs=processing_message)
 
-        peticao_texto_input.change(fn=fornecer_dica_contextual, inputs=[peticao_texto_input, tipo_peticao_input], outputs=dica_contextual_output)
-        tipo_peticao_input.change(fn=fornecer_dica_contextual, inputs=[peticao_texto_input, tipo_peticao_input], outputs=dica_contextual_output)
-        peticao_arquivo_input.change(fn=process_file, inputs=[peticao_arquivo_input], outputs=[arquivo_preview_output])
+        peticao_texto_input.change(fornecer_dica_contextual, [peticao_texto_input, tipo_peticao_input], dica_contextual_output)
+        tipo_peticao_input.change(fornecer_dica_contextual, [peticao_texto_input, tipo_peticao_input], dica_contextual_output)
+        peticao_arquivo_input.change(process_file, [peticao_arquivo_input], [arquivo_preview_output])
 
-        btn_corrigir.click(
-            fn=lambda: gr.update(value="⏳ Processando texto... Gerando análise e correção...", visible=True),
-            outputs=processing_message
-        ).then(
+        btn_corrigir.click(lambda: gr.update(value="⏳ Processando texto...", visible=True), outputs=processing_message).then(
             fn=corrigir_peticao,
             inputs=[caso_input, tipo_peticao_input, peticao_texto_input, gr.State(None), modo_treinamento],
-            outputs=[resultado_analise_output, resultado_peticao_corrigida_output,
-                     resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
+            outputs=[resultado_analise_output, resultado_peticao_corrigida_output, resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
             concurrency_limit=1
-        ).then(
-            fn=lambda: gr.update(value="", visible=False),
-            outputs=processing_message
-        )
+        ).then(lambda: gr.update(value="", visible=False), outputs=processing_message)
 
-        btn_corrigir_arquivo.click(
-            fn=lambda: gr.update(value="⏳ Processando arquivo... Gerando análise e correção...", visible=True),
-            outputs=processing_message
-        ).then(
+        btn_corrigir_arquivo.click(lambda: gr.update(value="⏳ Processando arquivo...", visible=True), outputs=processing_message).then(
             fn=corrigir_peticao,
             inputs=[caso_input, tipo_peticao_input, gr.State(None), peticao_arquivo_input, modo_treinamento],
-            outputs=[resultado_analise_output, resultado_peticao_corrigida_output,
-                     resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
+            outputs=[resultado_analise_output, resultado_peticao_corrigida_output, resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
             concurrency_limit=1
-        ).then(
-            fn=lambda: gr.update(value="", visible=False),
-            outputs=processing_message
-        )
+        ).then(lambda: gr.update(value="", visible=False), outputs=processing_message)
 
-        config_update_btn.click(atualizar_config, inputs=[temperatura_slider, timeout_slider, max_tokens_slider], outputs=config_status)
-        progresso_btn.click(fn=calcular_progresso, outputs=progresso_output)
-        historico_btn.click(fn=mostrar_historico, outputs=historico_output)
+        config_update_btn.click(atualizar_config, [temperatura_slider, timeout_slider, max_tokens_slider], config_status)
+        progresso_btn.click(calcular_progresso, outputs=progresso_output)
+        historico_btn.click(mostrar_historico, outputs=historico_output)
 
-        salvar_btn.click(
-             fn=lambda: gr.update(value="⏳ Salvando...", visible=True), outputs=processing_message
-        ).then(
+        salvar_btn.click(lambda: gr.update(value="⏳ Salvando...", visible=True), outputs=processing_message).then(
              fn=salvar_progresso, inputs=[caso_input, peticao_texto_input, tipo_peticao_input],
              outputs=[gr.Textbox(visible=False), config_status, progresso_download_file]
-        ).then(
-            fn=lambda x: gr.update(visible=bool(x)), inputs=[progresso_download_file], outputs=[progresso_download_file]
-        ).then(
-            lambda: gr.update(value="", visible=False), None, processing_message
-        )
+        ).then(lambda x: gr.update(visible=bool(x)), [progresso_download_file], [progresso_download_file]
+        ).then(lambda: gr.update(value="", visible=False), None, processing_message)
 
-        carregar_btn.click(
-             fn=lambda: gr.update(value="⏳ Carregando...", visible=True), outputs=processing_message
-        ).then(
+        carregar_btn.click(lambda: gr.update(value="⏳ Carregando...", visible=True), outputs=processing_message).then(
              fn=carregar_progresso, inputs=[arquivo_progresso_upload],
              outputs=[tipo_peticao_input, caso_input, peticao_texto_input, config_status]
-         ).then(
-            lambda: gr.update(value="", visible=False), None, processing_message
-        )
+         ).then(lambda: gr.update(value="", visible=False), None, processing_message)
 
         clear_btn.click(
-            fn=lambda: ["Petição Inicial", False, None, None, None, None, "*Dicas aparecerão aqui...*", "", "", "", "", "", None, None, ""],
-            outputs=[
-                tipo_peticao_input, modo_treinamento, caso_input, peticao_texto_input,
-                peticao_arquivo_input, arquivo_preview_output, dica_contextual_output,
-                resultado_analise_output, resultado_peticao_corrigida_output,
-                resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output,
-                arquivo_progresso_upload, progresso_download_file, config_status
-            ]
+            fn=lambda: ["Petição Inicial", False, None, None, None, None, "*Dicas...*", "", "", "", "", "", None, None, ""],
+            outputs=[tipo_peticao_input, modo_treinamento, caso_input, peticao_texto_input, peticao_arquivo_input,
+                     arquivo_preview_output, dica_contextual_output, resultado_analise_output, resultado_peticao_corrigida_output,
+                     resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output,
+                     arquivo_progresso_upload, progresso_download_file, config_status]
         )
-
     return demo
 
 if __name__ == "__main__":