Update app.py

app.py

@@ -24,30 +24,24 @@ from html import escape
 import random
 import logging
 import traceback
-import re # Importado para regex
+import re
 
-# Configuração do Logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - [%(funcName)s] - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Carregar Variáveis de Ambiente
 load_dotenv()
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY") or os.environ.get("GEMINI_API_KEY")
 if not GEMINI_API_KEY:
     raise ValueError("❌ A chave GEMINI_API_KEY não foi encontrada. Configure-a no arquivo .env ou como Secret no Hugging Face.")
 
-# API URL (Ajuste conforme sua chave/acesso)
 GEMINI_API_URL = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent?key={GEMINI_API_KEY}"
 logger.info(f"Usando API URL: ...{GEMINI_API_URL[-50:]}")
 
-# Configurações Globais
 CONFIG = {"max_retry_attempts": 3, "retry_delay": 5, "timeout": 120, "temperatura": 0.3, "max_tokens": 8192}
 rate_limiter = RateLimiter(max_calls=20, period=60)
 
-# Tipos de Petição
 TIPOS_DE_PETICAO = ["Petição Inicial", "Contestação", "Reconvenção", "Impugnação à Contestação", "Embargos de Declaração", "Recurso de Apelação", "Agravo de Instrumento", "Petição de Tutela Provisória"]
 
-# Dicas (Amostra)
 DICAS_OAB_MELHORADO = {
     "Clareza e Concisão": "Seja direto e evite jargões excessivos.",
     "Fundamentação Legal": "Sempre cite os artigos de lei, súmulas e jurisprudência pertinentes.",
@@ -56,14 +50,11 @@ DICAS_OAB_MELHORADO = {
     "Pedidos (Inicial)": "Certos, determinados e líquidos (se possível).",
     "Preliminares (Contestação)": "Alegue todas as matérias do Art. 337 do CPC antes do mérito.",
     "Impugnação Específica (Contestação)": "Conteste cada fato alegado (Art. 341, CPC)."
-    # Adicionar mais dicas...
 }
 
-# Globais para Histórico e Cache
 HISTORICO = []
 CORRECAO_CACHE = {}
 
-# --- Funções de Extração de Texto (sem alterações) ---
 def preprocess_image_for_ocr(img_pil):
     if not CV2_AVAILABLE:
         logger.warning("OpenCV não disponível, usando conversão simples para OCR.")
@@ -190,10 +181,7 @@ def process_file(file_obj):
         logger.error(f"Erro GERAL ao processar o arquivo '{getattr(file_obj, 'name', 'N/A')}': {str(e)}", exc_info=True)
         return f"❌ Erro inesperado ao processar o arquivo: {str(e)}"
 
-
-# --- Estruturação de Prompts (sem alterações) ---
 def get_instrucoes_gerais_avaliacao(modo_treinamento=False):
-    # (Mantido como na versão anterior)
     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.
@@ -229,7 +217,6 @@ def get_instrucoes_gerais_avaliacao(modo_treinamento=False):
     return base
 
 def estruturar_prompt_analise(caso, peticao, tipo_peticao, modo_treinamento=False):
-    # (Mantido como na versão anterior)
     instrucoes_gerais = get_instrucoes_gerais_avaliacao(modo_treinamento)
     prompt_especifico = f"""
     ## Análise de Peça Processual: {tipo_peticao} (Critérios OAB Simulados)
@@ -244,16 +231,118 @@ def estruturar_prompt_analise(caso, peticao, tipo_peticao, modo_treinamento=Fals
     {instrucoes_gerais}
     **Requisitos Específicos para {tipo_peticao}:**
     """
-    # Adiciona requisitos específicos por tipo (mantidos)
-    if tipo_peticao == "Petição Inicial": prompt_especifico += """...""" # Omitido para brevidade
-    elif tipo_peticao == "Contestação": prompt_especifico += """...""" # Omitido para brevidade
-    # ... (outros tipos) ...
-    else: prompt_especifico += """...""" # Fallback genérico
-    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..."
+    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.
+        """
+    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.
+        """
+    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.
+         """
+    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.
+         """
+    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.
+         """
+    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.
+        """
+    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.
+        """
+    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."
     return prompt_especifico
 
 def estruturar_prompt_peticao_corrigida(caso, peticao_original, tipo_peticao):
-    # (Mantido como na versão anterior)
     prompt = f"""
     **Caso/Contexto Fornecido:**
     ```
@@ -263,24 +352,119 @@ def estruturar_prompt_peticao_corrigida(caso, peticao_original, tipo_peticao):
     ```
     {peticao_original}
     ```
-    **Tarefa:** Com base no caso e nos problemas identificados na peça original..., gere uma versão corrigida e aprimorada...
+    **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}):**
     """
-    # Adiciona instruções específicas por tipo (mantidas)
-    if tipo_peticao == "Petição Inicial": prompt += """...""" # Omitido para brevidade
-    elif tipo_peticao == "Contestação": prompt += """...""" # Omitido para brevidade
-    # ... (outros tipos) ...
-    else: prompt += """...""" # Fallback genérico
-    prompt += "\n\n**Instrução Final:** Gere **APENAS** o texto completo da peça corrigida abaixo..."
+    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.**
+        """
+    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.
+        """
+    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.
+         """
+    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.
+         """
+    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.
+         """
+    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.
+        """
+    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.
+        """
+    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."
     return prompt
 
 def pos_corrigir_peticao(peticao_corrigida, tipo_peticao):
-    # (Mantido como na versão anterior)
     if "Nestes termos, pede deferimento" in peticao_corrigida:
         peticao_corrigida = peticao_corrigida.replace("Nestes termos, pede deferimento", "Nestes termos pede deferimento")
     if tipo_peticao == "Petição Inicial":
         peticao_lower = peticao_corrigida.lower()
-        # ... (lógica para adicionar custas e audiência mantida) ...
+        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 "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.")
+
     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"]):
@@ -289,10 +473,7 @@ def pos_corrigir_peticao(peticao_corrigida, tipo_peticao):
     peticao_corrigida = "\n".join(linhas)
     return peticao_corrigida
 
-
-# --- Chamada à API (sem alterações) ---
 def chamar_api(prompt):
-    # (Mantido como na versão anterior)
     payload = {"contents": [{"parts": [{"text": prompt}]}],"generationConfig": {"temperature": CONFIG["temperatura"],"maxOutputTokens": CONFIG["max_tokens"],"topP": 0.95,}}
     headers = {"Content-Type": "application/json"}
     logger.info(f"Chamando API Gemini. Temp={CONFIG['temperatura']}, MaxTokens={CONFIG['max_tokens']}")
@@ -301,76 +482,147 @@ def chamar_api(prompt):
             with rate_limiter:
                 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"])
-            # ... (lógica de tratamento de resposta e erro mantida) ...
-            if response.status_code == 200:
-                 response_data = response.json()
-                 # ... (verificações de candidates, finishReason, etc.) ...
-                 if response_data.get("candidates") and response_data["candidates"][0].get("content"):
-                     texto_gerado = response_data["candidates"][0]["content"]["parts"][0]["text"].strip()
-                     logger.info(f"API retornou com sucesso ({len(texto_gerado)} chars).")
-                     return texto_gerado
-                 else:
-                     # Tratar caso de resposta 200 mas sem conteúdo válido
-                     logger.error(f"API retornou 200 OK mas sem conteúdo válido: {response_data}")
-                     return "❌ Erro: Resposta da API recebida, mas sem conteúdo útil."
-            # ... (outros tratamentos de erro: 429, != 200) ...
-        # ... (tratamento de exceções: Timeout, RequestException, JSONDecodeError, Exception) ...
-        except requests.Timeout: logger.warning(f"Timeout na API - Tentativa {tentativa + 1}.") # ... retry logic ...
-        except requests.RequestException as e: logger.error(f"Erro de Rede/Requisição API - Tentativa {tentativa + 1}: {e}") # ... retry logic ...
-        except json.JSONDecodeError as e: logger.error(f"Erro ao decodificar JSON da API: {e}") # ... return error ...
-        except Exception as e: logger.exception(f"Erro inesperado na chamada da API - Tentativa {tentativa + 1}: {str(e)}") # ... retry logic ...
+            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...")
+                if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(retry_after); continue
+                else: return "❌ Erro 429: Muitas requisições. Tente novamente mais tarde."
+
+            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}")
+                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}"
+
+            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')."
+
+            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}")
+                 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 not candidate.get("content") or not candidate["content"].get("parts"):
+                 logger.error("Estrutura de resposta inesperada: Faltando content/parts.")
+                 if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(CONFIG['retry_delay'] * (tentativa + 1)); continue
+                 return "❌ Resposta inválida da API (estrutura inesperada)."
+
+            texto_gerado = candidate["content"]["parts"][0]["text"].strip()
+            logger.info(f"API retornou com sucesso ({len(texto_gerado)} chars). Finish Reason: {finish_reason}")
+            return texto_gerado
+
+        except requests.Timeout:
+            logger.warning(f"Timeout na 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."
+        except requests.RequestException as e:
+            logger.error(f"Erro de 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}"
+        except json.JSONDecodeError as e:
+             logger.error(f"Erro ao decodificar JSON da API: {e}")
+             logger.debug(f"Resposta não-JSON: {response.text[:500]}")
+             return f"❌ Erro ao processar a resposta da API (JSON inválido)."
+        except Exception as e:
+            logger.exception(f"Erro inesperado na chamada da 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."
 
-
-# --- Função Principal de Correção (sem alterações na lógica interna) ---
 def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=None, modo_treinamento=False):
-    # (Mantida como na versão anterior, com try-except e retorno de 5 valores)
     logger.info(f"Iniciando correção. Tipo={tipo_peticao}, Treinamento={modo_treinamento}")
     start_time = time.time()
     analise_formatada, peticao_corrigida_final, resumo_diff, criticas_diff, diff_html = "", "", "", "", ""
     peticao_conteudo = ""
     try:
-        # ... (validações iniciais: caso, tipo_peticao) ...
-        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 um tipo...", "", "", "", ""
-
-        # ... (processa input: texto ou arquivo) ...
-        if peticao_arquivo: peticao_conteudo = process_file(peticao_arquivo)
-        elif peticao_texto: peticao_conteudo = peticao_texto
-        else: return "⚠️ Forneça a petição...", "", "", "", ""
-        if peticao_conteudo.startswith("❌") or peticao_conteudo.startswith("⚠️"): return peticao_conteudo, "", "", "", ""
-
-        # ... (anti-troll) ...
-        troll_triggers = ["escreva a petição", "faça a petição", "redija a petição"]
-        if any(t in peticao_conteudo.lower() for t in troll_triggers): return random.choice(["Hummm...", "Opa!"]), "", "", "", ""
+        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 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).", "", "", "", ""
+        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!",
+            ]), "", "", "", ""
 
-        # ... (cache check) ...
         cache_key = f"{tipo_peticao}|{caso[:100]}|{peticao_conteudo[:100]}|{modo_treinamento}"
-        if cache_key in CORRECAO_CACHE: # Retorna os 5 valores do cache
-            cached = CORRECAO_CACHE[cache_key]
-            return cached["analise_formatada"], cached["peticao_corrigida"], cached["resumo_diff"], cached["criticas_diff"], cached["diff_html"]
+        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"]
 
-        # ... (chamada API para análise) ...
+        logger.info("Estruturando prompt de análise...")
         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("❌") or analise_bruta.startswith("⏱️") or analise_bruta.startswith("⚠️"):
+        if analise_bruta.startswith(("❌", "⏱️", "⚠️")):
+            logger.error(f"Erro retornado pela API (Análise): {analise_bruta}")
             return analise_bruta, "", "", "", ""
+        logger.info("Análise recebida. Formatando...")
         analise_formatada = formatar_correcao(analise_bruta)
 
-        # ... (chamada API para peça corrigida) ...
+        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("❌") or peticao_corrigida_bruta.startswith("⏱️") or peticao_corrigida_bruta.startswith("⚠️"):
+
+        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}"
         else:
-            # ... (pós-correção) ...
-            peticao_corrigida_final = pos_corrigir_peticao(peticao_corrigida_bruta, tipo_peticao)
-
-        # ... (calcular diff) ...
+            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()
+            for marker in start_markers:
+                idx = peticao_lower_corr.find(marker)
+                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.")
 
-        # ... (histórico e cache) ...
         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})
@@ -385,97 +637,241 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
         error_message = f"❌ Erro inesperado na função de correção: {str(e)}\nConsulte os logs para detalhes."
         return error_message, "", "", "", ""
 
-
-# --- Formatação e Dicas (sem alterações) ---
 def formatar_correcao(texto):
-    # (Mantido como na versão anterior)
     texto = texto.replace("### Análise Geral", "## 📝 Análise Geral")
     texto = texto.replace("### Nota Final", "## ⭐ Nota Final")
-    # ... (outras formatações) ...
-    return texto
+    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 = []
+    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
+    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)
+    return texto_final
 
 def fornecer_dica_contextual(texto_peticao, tipo_peticao):
-    # (Mantido como na versão anterior)
-    if not texto_peticao or not texto_peticao.strip(): return "*Digite algo na peça para receber dicas...*"
-    # ... (lógica de dicas) ...
+    if not texto_peticao or not texto_peticao.strip():
+        return "*Digite algo na peça para receber 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]}")
+    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"],
+    }
+    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.*"
     return "\n\n".join(dicas_relevantes[:4])
 
-
-# --- Funções de Comparação (Diff) (sem alterações) ---
 def calcular_diff_interno(texto_original, texto_corrigido):
-    # (Mantido como na versão anterior)
-    if not texto_original or not texto_corrigido or texto_corrigido.startswith(("⚠️","❌")): return "","",""
-    # ... (lógica do difflib) ...
+    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"]
+    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
 
-
-# --- Funções de Progresso e Histórico (sem alterações) ---
 def calcular_progresso():
-    # (Mantido como na versão anterior)
     if not HISTORICO: return "📊 Nenhum progresso registrado ainda."
-    # ... (lógica de cálculo) ...
+    notas = []
+    tipos_corrigidos = 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
 
 def mostrar_historico():
-    # (Mantido como na versão anterior)
     if not HISTORICO: return "📜 Histórico vazio."
-    # ... (lógica de formatação do histórico) ...
+    historico_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
 
-
-# --- Salvar/Carregar Progresso (sem alterações) ---
 def salvar_progresso(caso, peticao, tipo_peticao):
-    # (Mantido como na versão anterior)
     logger.info("Iniciando salvamento de progresso...")
     try:
-        # ... (lógica de salvar) ...
+        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: # ... (tratamento de erro) ...
-        return "", f"❌ Erro ao salvar o progresso: {str(e)}", None
+    except Exception as e:
+        logger.error(f"Erro ao salvar progresso: {str(e)}", exc_info=True)
+        return "", f"❌ Erro ao salvar: {str(e)}", None
 
 def carregar_progresso(arquivo_entrada):
-    # (Mantido como na versão anterior)
     logger.info("Iniciando carregamento de progresso...")
     if arquivo_entrada is None: return "", "", "", "⚠️ Nenhum arquivo selecionado."
     try:
-        # ... (lógica de carregar) ...
+        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 Exception as e: # ... (tratamento de erro) ...
-        return "", "", "", f"❌ Erro ao carregar: {str(e)}"
-
+    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)}"
 
-# --- Geração de Casos (sem alterações na lógica interna) ---
 def estruturar_prompt_geracao_caso(tipo_peticao="Petição Inicial"):
-    # (Mantido como na versão anterior)
-    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}"**..."""
-    # ... (instruções específicas por tipo mantidas) ...
+    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!
+    """
     return prompt
 
 def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
-    # (Mantido como na versão anterior, com try-except)
     logger.info(f"Solicitada gera��ão de caso para: {tipo_peticao}")
     try:
         if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO:
-            return "⚠️ Erro: Selecione um tipo de petição válido."
+            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...")
         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}"
-        # ... (pós-processamento da frase final mantido) ...
+        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.")
         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)}"
 
-
-# --- Interface Gradio (com handlers .click() ajustados) ---
 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!")
-
         with gr.Row():
-            with gr.Column(scale=1): # Coluna Configurações
+            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")
                 modo_treinamento = gr.Checkbox(label="🎓 Modo Treinamento", value=False)
@@ -496,8 +892,7 @@ def interface_gradio():
                      carregar_btn = gr.Button("📂 Carregar Caso/Peça")
                      arquivo_progresso_upload = gr.File(label="Selecione .json", file_types=[".json"], scale=2)
                      progresso_download_file = gr.File(label="Baixar Progresso", interactive=False)
-
-            with gr.Column(scale=3): # Coluna Inputs
+            with gr.Column(scale=3):
                 gr.Markdown("### 1. Forneça o Caso / Contexto")
                 with gr.Row():
                      caso_input = gr.Textbox(label="📋 Caso ou Situação", lines=8, placeholder="Insira o texto COMPLETO do caso...")
@@ -513,7 +908,7 @@ def interface_gradio():
                         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")
 
-        processing_message = gr.Markdown("", visible=False) # Movido para local acessível
+        processing_message = gr.Markdown("", visible=False)
 
         gr.Markdown("--- \n ### 3. Resultados da Correção")
         with gr.Tabs():
@@ -531,9 +926,6 @@ def interface_gradio():
 
         clear_btn = gr.Button("🗑️ Limpar Campos e Resultados")
 
-        # --- LÓGICA DOS EVENTOS (Handlers .click() ajustados) ---
-
-        # Gerar Caso
         caso_btn.click(
              fn=lambda: gr.update(value="⏳ Gerando caso...", visible=True), outputs=processing_message
         ).then(
@@ -542,37 +934,30 @@ def interface_gradio():
              fn=lambda: gr.update(value="", visible=False), outputs=processing_message
         )
 
-        # Dicas Contextuais
         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)
-
-        # Preview Arquivo
         peticao_arquivo_input.change(fn=process_file, inputs=[peticao_arquivo_input], outputs=[arquivo_preview_output])
 
-        # Botão Corrigir Texto
         btn_corrigir.click(
             fn=lambda: gr.update(value="⏳ Processando texto... Gerando análise e correção...", visible=True),
-            outputs=processing_message # Mostra a mensagem imediatamente
+            outputs=processing_message
         ).then(
-            fn=corrigir_peticao, # Função principal
-            inputs=[caso_input, tipo_peticao_input, peticao_texto_input, gr.State(None), modo_treinamento], # Inputs para corrigir_peticao
-            # Outputs DEVE CORRESPONDER ao retorno de corrigir_peticao (5 valores)
+            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],
             concurrency_limit=1
         ).then(
             fn=lambda: gr.update(value="", visible=False),
-            outputs=processing_message # Esconde a mensagem após a conclusão
+            outputs=processing_message
         )
 
-        # Botão Corrigir Arquivo
         btn_corrigir_arquivo.click(
             fn=lambda: gr.update(value="⏳ Processando arquivo... Gerando análise e correção...", visible=True),
             outputs=processing_message
         ).then(
             fn=corrigir_peticao,
             inputs=[caso_input, tipo_peticao_input, gr.State(None), peticao_arquivo_input, modo_treinamento],
-            # Outputs DEVE CORRESPONDER ao retorno de corrigir_peticao (5 valores)
             outputs=[resultado_analise_output, resultado_peticao_corrigida_output,
                      resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
             concurrency_limit=1
@@ -581,26 +966,21 @@ def interface_gradio():
             outputs=processing_message
         )
 
-        # Configurações Avançadas
         config_update_btn.click(atualizar_config, inputs=[temperatura_slider, timeout_slider, max_tokens_slider], outputs=config_status)
-
-        # Progresso e Histórico
         progresso_btn.click(fn=calcular_progresso, outputs=progresso_output)
         historico_btn.click(fn=mostrar_historico, outputs=historico_output)
 
-        # Salvar Progresso
         salvar_btn.click(
              fn=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] # O primeiro output (JSON) é oculto
+             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] # Mostra/esconde botão download
+            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 # Limpa mensagem
+            lambda: gr.update(value="", visible=False), None, processing_message
         )
 
-        # Carregar Progresso
         carregar_btn.click(
              fn=lambda: gr.update(value="⏳ Carregando...", visible=True), outputs=processing_message
         ).then(
@@ -610,21 +990,19 @@ def interface_gradio():
             lambda: gr.update(value="", visible=False), None, processing_message
         )
 
-        # Botão Limpar
         clear_btn.click(
-            fn=lambda: ["Petição Inicial", False, None, None, None, None, "*Dicas aparecerão aqui...*", "", "", "", "", "", None, None, ""], # Adicionado estado inicial dica e config_status
+            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 # Limpa status também
+                arquivo_progresso_upload, progresso_download_file, config_status
             ]
         )
 
     return demo
 
-# --- Execução Principal ---
 if __name__ == "__main__":
     logger.info("Iniciando a aplicação Gradio...")
     app = interface_gradio()