diff --git a/backend/src/modulos/documentos/rotas.ts b/backend/src/modulos/documentos/rotas.ts
index e0679e9..22e7ac8 100644
--- a/backend/src/modulos/documentos/rotas.ts
+++ b/backend/src/modulos/documentos/rotas.ts
@@ -97,6 +97,21 @@ router.post('/', autenticar, exigirPerfil('estudante'), upload.single('arquivo')
     return;
   }
 
+  const TIPOS_VALIDOS = [
+    'certificado_curso',
+    'certificado_evento',
+    'declaracao_participacao',
+    'comprovante_atividade',
+    'artigo_publicado',
+    'outro',
+  ];
+  if (!TIPOS_VALIDOS.includes(tipo)) {
+    res.status(400).json({
+      erro: `Tipo inválido. Valores aceitos: ${TIPOS_VALIDOS.join(', ')}`,
+    });
+    return;
+  }
+
   try {
     const usuario = await buscarUsuario(req.usuario!.sub);
     if (!usuario?.curso_id) {
diff --git a/backend/src/servicos/gerador-certificado.ts b/backend/src/servicos/gerador-certificado.ts
index 7761bb9..eec8528 100644
--- a/backend/src/servicos/gerador-certificado.ts
+++ b/backend/src/servicos/gerador-certificado.ts
@@ -23,10 +23,12 @@ export function gerarHash(documentoId: string): string {
 }
 
 const TIPO_LEGIVEL: Record<string, string> = {
-  estagio: 'Estágio',
-  tcc: 'Trabalho de Conclusão de Curso',
-  extensao: 'Atividade de Extensão',
-  monitoria: 'Monitoria',
+  certificado_curso: 'Certificado de Curso',
+  certificado_evento: 'Certificado de Evento',
+  declaracao_participacao: 'Declaração de Participação',
+  comprovante_atividade: 'Comprovante de Atividade',
+  artigo_publicado: 'Artigo Publicado',
+  outro: 'Outro',
 };
 
 export async function gerarPDF(dados: DadosCertificado, urlVerificacao: string): Promise<Buffer> {
diff --git a/backend/testes/helpers/fixtures.ts b/backend/testes/helpers/fixtures.ts
index 1a9bb49..4ae8a0c 100644
--- a/backend/testes/helpers/fixtures.ts
+++ b/backend/testes/helpers/fixtures.ts
@@ -2,15 +2,15 @@ import type { Documento } from '../../src/modulos/documentos/repositorio';
 
 export const DOC_MOCK: Documento = {
   id: 'doc-1',
-  titulo: 'Estágio XYZ',
-  tipo: 'estagio',
+  titulo: 'Certificado XYZ',
+  tipo: 'certificado_curso',
   carga_horaria: 40,
   estudante_id: 'estudante-id',
   curso_id: 'curso-1',
   status: 'pendente',
   coordenador_id: null,
-  nome_arquivo: 'estagio.pdf',
-  caminho_arquivo: 'documentos/estudante-id/estagio.pdf',
+  nome_arquivo: 'certificado.pdf',
+  caminho_arquivo: 'documentos/estudante-id/certificado.pdf',
   tamanho_arquivo: 1024,
   mime_type: 'application/pdf',
   criado_em: new Date(),
diff --git a/backend/testes/rotas/documentos.test.ts b/backend/testes/rotas/documentos.test.ts
index 840a96e..c68e0bc 100644
--- a/backend/testes/rotas/documentos.test.ts
+++ b/backend/testes/rotas/documentos.test.ts
@@ -55,7 +55,7 @@ describe('GET /:id', () => {
     const res = await request(app).get('/doc-1');
     expect(res.status).toBe(200);
     expect(res.body.id).toBe('doc-1');
-    expect(res.body.titulo).toBe('Estágio XYZ');
+    expect(res.body.titulo).toBe('Certificado XYZ');
   });
 
   it('retorna 404 quando o documento não existe', async () => {
@@ -106,8 +106,8 @@ describe('POST /', () => {
   it('retorna 400 quando nenhum arquivo é enviado', async () => {
     const res = await request(app)
       .post('/')
-      .field('titulo', 'Estágio')
-      .field('tipo', 'estagio')
+      .field('titulo', 'Certificado')
+      .field('tipo', 'certificado_curso')
       .field('carga_horaria', '40');
     expect(res.status).toBe(400);
     expect(res.body.erro).toContain('arquivo');
@@ -132,8 +132,8 @@ describe('POST /', () => {
         filename: 'test.pdf',
         contentType: 'application/pdf',
       })
-      .field('titulo', 'Estágio')
-      .field('tipo', 'estagio')
+      .field('titulo', 'Certificado')
+      .field('tipo', 'certificado_curso')
       .field('carga_horaria', 'abc');
     expect(res.status).toBe(400);
     expect(res.body.erro).toContain('carga_horaria');
@@ -147,8 +147,8 @@ describe('POST /', () => {
         filename: 'test.pdf',
         contentType: 'application/pdf',
       })
-      .field('titulo', 'Estágio XYZ')
-      .field('tipo', 'estagio')
+      .field('titulo', 'Certificado XYZ')
+      .field('tipo', 'certificado_curso')
       .field('carga_horaria', '40');
     expect(res.status).toBe(422);
     expect(res.body.erro).toContain('curso');
@@ -156,29 +156,29 @@ describe('POST /', () => {
 
   it('retorna 201 com o documento criado após upload bem-sucedido', async () => {
     mockUsr.buscarPorId.mockResolvedValueOnce({ id: 'estudante-id', curso_id: 'curso-1' } as any);
-    mockArm.fazerUpload.mockResolvedValueOnce('documentos/estudante-id/estagio.pdf');
+    mockArm.fazerUpload.mockResolvedValueOnce('documentos/estudante-id/certificado.pdf');
     mockDoc.criar.mockResolvedValueOnce(DOC_MOCK);
 
     const res = await request(app)
       .post('/')
       .attach('arquivo', Buffer.from('%PDF-1.4'), {
-        filename: 'estagio.pdf',
+        filename: 'certificado.pdf',
         contentType: 'application/pdf',
       })
-      .field('titulo', 'Estágio XYZ')
-      .field('tipo', 'estagio')
+      .field('titulo', 'Certificado XYZ')
+      .field('tipo', 'certificado_curso')
       .field('carga_horaria', '40');
     expect(res.status).toBe(201);
     expect(res.body.id).toBe('doc-1');
-    expect(res.body.titulo).toBe('Estágio XYZ');
+    expect(res.body.titulo).toBe('Certificado XYZ');
     expect(mockEmitir).toHaveBeenCalledWith(
       'documento_submetido',
       expect.objectContaining({
         documentoId: 'doc-1',
         estudanteId: 'estudante-id',
         cursoId: 'curso-1',
-        titulo: 'Estágio XYZ',
-        tipo: 'estagio',
+        titulo: 'Certificado XYZ',
+        tipo: 'certificado_curso',
       }),
     );
   });
@@ -189,9 +189,9 @@ describe('POST /', () => {
 
     await request(app)
       .post('/')
-      .attach('arquivo', Buffer.from('%PDF-1.4'), { filename: 'estagio.pdf', contentType: 'application/pdf' })
-      .field('titulo', 'Estágio XYZ')
-      .field('tipo', 'estagio')
+      .attach('arquivo', Buffer.from('%PDF-1.4'), { filename: 'certificado.pdf', contentType: 'application/pdf' })
+      .field('titulo', 'Certificado XYZ')
+      .field('tipo', 'certificado_curso')
       .field('carga_horaria', '40');
 
     expect(mockEmitir).not.toHaveBeenCalled();
diff --git a/backend/testes/rotas/publica.test.ts b/backend/testes/rotas/publica.test.ts
index 7daf00f..9337b2d 100644
--- a/backend/testes/rotas/publica.test.ts
+++ b/backend/testes/rotas/publica.test.ts
@@ -57,7 +57,7 @@ describe('GET /verificar/:hash', () => {
     expect(res.status).toBe(200);
     expect(res.body.valido).toBe(true);
     expect(res.body.certificado.id).toBe('cert-1');
-    expect(res.body.documento.titulo).toBe('Estágio XYZ');
+    expect(res.body.documento.titulo).toBe('Certificado XYZ');
     expect(res.body.estudante.nome).toBe('João Silva');
   });
 
diff --git a/backend/testes/unitarios/eventos/barramento.test.ts b/backend/testes/unitarios/eventos/barramento.test.ts
index d7b0aab..12cfbed 100644
--- a/backend/testes/unitarios/eventos/barramento.test.ts
+++ b/backend/testes/unitarios/eventos/barramento.test.ts
@@ -12,15 +12,15 @@ const submetido: EventoDocumentoSubmetido = {
   documentoId: 'doc-1',
   estudanteId: 'est-1',
   cursoId: 'curso-1',
-  titulo: 'Estágio XYZ',
-  tipo: 'estagio',
+  titulo: 'Certificado XYZ',
+  tipo: 'certificado_curso',
 };
 
 const aprovado: EventoDocumentoAprovado = {
   documentoId: 'doc-1',
   estudanteId: 'est-1',
   coordenadorId: 'coord-1',
-  titulo: 'Estágio XYZ',
+  titulo: 'Certificado XYZ',
 };
 
 const reprovado: EventoDocumentoReprovado = {
diff --git a/backend/testes/unitarios/eventos/handlers.test.ts b/backend/testes/unitarios/eventos/handlers.test.ts
index dc2e2d0..8a370e8 100644
--- a/backend/testes/unitarios/eventos/handlers.test.ts
+++ b/backend/testes/unitarios/eventos/handlers.test.ts
@@ -43,15 +43,15 @@ const ESTUDANTE_MOCK = {
 
 const DOCUMENTO_MOCK = {
   id: 'doc-1',
-  titulo: 'Estágio XYZ',
-  tipo: 'estagio',
+  titulo: 'Certificado XYZ',
+  tipo: 'certificado_curso',
   carga_horaria: 40,
   estudante_id: 'est-1',
   curso_id: 'curso-1',
   status: 'aprovado',
   coordenador_id: 'coord-1',
-  nome_arquivo: 'estagio.pdf',
-  caminho_arquivo: 'documentos/est-1/estagio.pdf',
+  nome_arquivo: 'certificado.pdf',
+  caminho_arquivo: 'documentos/est-1/certificado.pdf',
   tamanho_arquivo: 1024,
   mime_type: 'application/pdf',
   criado_em: new Date(),
@@ -85,8 +85,8 @@ describe('aoDocumentoSubmetido', () => {
     documentoId: 'doc-1',
     estudanteId: 'est-1',
     cursoId: 'curso-1',
-    titulo: 'Estágio XYZ',
-    tipo: 'estagio',
+    titulo: 'Certificado XYZ',
+    tipo: 'certificado_curso',
   };
 
   it('notifica cada coordenador encontrado para o curso', async () => {
@@ -105,7 +105,7 @@ describe('aoDocumentoSubmetido', () => {
         destinatarioId: 'coord-1',
         destinatarioEmail: 'maria@uni.edu',
         assunto: expect.stringContaining('validação'),
-        mensagem: expect.stringContaining('Estágio XYZ'),
+        mensagem: expect.stringContaining('Certificado XYZ'),
       }),
     );
   });
@@ -134,7 +134,7 @@ describe('aoDocumentoAprovado', () => {
     documentoId: 'doc-1',
     estudanteId: 'est-1',
     coordenadorId: 'coord-1',
-    titulo: 'Estágio XYZ',
+    titulo: 'Certificado XYZ',
   };
 
   it('gera certificado, persiste no banco e notifica o estudante', async () => {
@@ -161,7 +161,7 @@ describe('aoDocumentoAprovado', () => {
         destinatarioId: 'est-1',
         destinatarioEmail: 'joao@uni.edu',
         assunto: expect.stringContaining('aprovado'),
-        mensagem: expect.stringContaining('Estágio XYZ'),
+        mensagem: expect.stringContaining('Certificado XYZ'),
       }),
     );
   });
@@ -208,7 +208,7 @@ describe('aoDocumentoReprovado', () => {
     documentoId: 'doc-1',
     estudanteId: 'est-1',
     coordenadorId: 'coord-1',
-    titulo: 'Estágio XYZ',
+    titulo: 'Certificado XYZ',
     observacoes: 'Documentação incompleta',
   };
 
@@ -250,7 +250,7 @@ describe('aoDocumentoRevisaoSolicitada', () => {
     documentoId: 'doc-1',
     estudanteId: 'est-1',
     coordenadorId: 'coord-1',
-    titulo: 'Estágio XYZ',
+    titulo: 'Certificado XYZ',
     observacoes: 'Ajustar carga horária',
   };
 
diff --git a/backend/testes/unitarios/repositorios/documento.test.ts b/backend/testes/unitarios/repositorios/documento.test.ts
index c5aeb9a..e81c527 100644
--- a/backend/testes/unitarios/repositorios/documento.test.ts
+++ b/backend/testes/unitarios/repositorios/documento.test.ts
@@ -14,15 +14,15 @@ const mockQuery = pool.query as jest.Mock;
 
 const DOC_ROW = {
   id: 'doc-1',
-  titulo: 'Estágio XYZ',
-  tipo: 'estagio',
+  titulo: 'Certificado XYZ',
+  tipo: 'certificado_curso',
   carga_horaria: 40,
   estudante_id: 'est-1',
   curso_id: 'curso-1',
   status: 'pendente',
   coordenador_id: null,
-  nome_arquivo: 'estagio.pdf',
-  caminho_arquivo: 'documentos/est-1/estagio.pdf',
+  nome_arquivo: 'certificado.pdf',
+  caminho_arquivo: 'documentos/est-1/certificado.pdf',
   tamanho_arquivo: 1024,
   mime_type: 'application/pdf',
   criado_em: new Date(),
@@ -39,13 +39,13 @@ describe('criar', () => {
     mockQuery.mockResolvedValueOnce({ rows: [DOC_ROW] });
 
     const resultado = await criar({
-      titulo: 'Estágio XYZ',
-      tipo: 'estagio',
+      titulo: 'Certificado XYZ',
+      tipo: 'certificado_curso',
       carga_horaria: 40,
       estudante_id: 'est-1',
       curso_id: 'curso-1',
-      nome_arquivo: 'estagio.pdf',
-      caminho_arquivo: 'documentos/est-1/estagio.pdf',
+      nome_arquivo: 'certificado.pdf',
+      caminho_arquivo: 'documentos/est-1/certificado.pdf',
       tamanho_arquivo: 1024,
       mime_type: 'application/pdf',
     });
diff --git a/backend/testes/unitarios/repositorios/validacao.test.ts b/backend/testes/unitarios/repositorios/validacao.test.ts
index 7faa470..f859193 100644
--- a/backend/testes/unitarios/repositorios/validacao.test.ts
+++ b/backend/testes/unitarios/repositorios/validacao.test.ts
@@ -21,7 +21,7 @@ const clienteMock = {
 
 const DOC_ROW = {
   id: 'doc-1',
-  titulo: 'Estágio XYZ',
+  titulo: 'Certificado XYZ',
   status: 'pendente',
   estudante_id: 'est-1',
   curso_id: 'curso-1',
diff --git a/backend/testes/unitarios/servicos/gerador-certificado.test.ts b/backend/testes/unitarios/servicos/gerador-certificado.test.ts
index d84115a..685ff98 100644
--- a/backend/testes/unitarios/servicos/gerador-certificado.test.ts
+++ b/backend/testes/unitarios/servicos/gerador-certificado.test.ts
@@ -20,8 +20,8 @@ const DADOS_BASE: DadosCertificado = {
   documentoId: 'doc-1',
   estudanteNome: 'João Silva',
   estudanteEmail: 'joao@uni.edu',
-  titulo: 'Estágio XYZ',
-  tipo: 'estagio',
+  titulo: 'Certificado XYZ',
+  tipo: 'certificado_curso',
   cargaHoraria: 40,
   dataAprovacao: new Date('2024-06-01'),
 };
diff --git a/frontend/src/pages/Cursos.tsx b/frontend/src/pages/Cursos.tsx
index b6b9fad..1044455 100644
--- a/frontend/src/pages/Cursos.tsx
+++ b/frontend/src/pages/Cursos.tsx
@@ -1,4 +1,4 @@
-import { useState } from 'react';
+import { useState, useEffect } from 'react';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import { cursosService, type CursoComContagem, type CriarCursoInput } from '../services/cursos';
 import { instituicoesService, type Instituicao } from '../services/instituicoes';
@@ -47,21 +47,40 @@ function Modal({
   onClose: () => void;
   children: React.ReactNode;
 }) {
+  useEffect(() => {
+    document.body.style.overflow = 'hidden';
+    return () => { document.body.style.overflow = ''; };
+  }, []);
+
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => { if (e.key === 'Escape') onClose(); };
+    document.addEventListener('keydown', onKey);
+    return () => document.removeEventListener('keydown', onKey);
+  }, [onClose]);
+
   return (
-    <div className="fixed inset-0 z-50 flex items-start justify-center overflow-y-auto bg-black/40 px-4 py-8">
-      <div className="w-full max-w-lg rounded-2xl bg-[#011140] shadow-xl">
-        <div className="flex items-center justify-between border-b border-white/8 px-6 py-4">
-          <h2 className="text-base font-semibold text-white">{titulo}</h2>
-          <button
-            onClick={onClose}
-            className="rounded-lg p-1.5 text-white/45 hover:bg-white/6 hover:text-white/70"
-          >
-            <svg className="h-5 w-5" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
-              <path strokeLinecap="round" strokeLinejoin="round" d="M6 18L18 6M6 6l12 12" />
-            </svg>
-          </button>
+    <div
+      className="fixed inset-0 z-50 overflow-y-auto bg-black/50"
+      onClick={onClose}
+    >
+      <div className="flex min-h-full items-start justify-center px-4 py-8">
+        <div
+          className="w-full max-w-lg rounded-2xl bg-[#011140] shadow-xl"
+          onClick={(e) => e.stopPropagation()}
+        >
+          <div className="flex items-center justify-between border-b border-white/8 px-6 py-4">
+            <h2 className="text-base font-semibold text-white">{titulo}</h2>
+            <button
+              onClick={onClose}
+              className="rounded-lg p-1.5 text-white/45 hover:bg-white/6 hover:text-white/70"
+            >
+              <svg className="h-5 w-5" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
+                <path strokeLinecap="round" strokeLinejoin="round" d="M6 18L18 6M6 6l12 12" />
+              </svg>
+            </button>
+          </div>
+          <div className="px-6 py-5">{children}</div>
         </div>
-        <div className="px-6 py-5">{children}</div>
       </div>
     </div>
   );
diff --git a/frontend/src/pages/DetalheDocumento.tsx b/frontend/src/pages/DetalheDocumento.tsx
index 51245f0..54c95fa 100644
--- a/frontend/src/pages/DetalheDocumento.tsx
+++ b/frontend/src/pages/DetalheDocumento.tsx
@@ -75,6 +75,13 @@ export function DetalheDocumento() {
     onError: () => addToast('Erro ao cancelar o documento.', 'error'),
   });
 
+  const { data: previewData, isLoading: previewLoading } = useQuery({
+    queryKey: ['documento-url', id],
+    queryFn: () => documentosService.buscarUrlDownload(id!),
+    enabled: !!id && !!doc,
+    staleTime: 50 * 60 * 1000,
+  });
+
   const mutDownload = useMutation({
     mutationFn: () => documentosService.buscarUrlDownload(id!),
     onSuccess: ({ url }) => window.open(url, '_blank'),
@@ -139,6 +146,33 @@ export function DetalheDocumento() {
         </div>
       </Card>
 
+      {/* Pré-visualização PDF */}
+      <Card>
+        <h3 className="mb-4 font-medium text-white">Pré-visualização</h3>
+        {previewLoading && (
+          <div className="flex items-center justify-center py-12">
+            <Spinner className="h-6 w-6 text-[#618C7C]" />
+            <span className="ml-3 text-sm text-white/45">Carregando documento...</span>
+          </div>
+        )}
+        {previewData && (
+          <iframe
+            src={previewData.url}
+            title="Pré-visualização do documento PDF"
+            className="w-full rounded-lg border border-white/10 bg-black/20"
+            style={{ height: '65vh', minHeight: '420px' }}
+          />
+        )}
+        {!previewLoading && !previewData && (
+          <div className="flex flex-col items-center gap-3 py-12 text-center">
+            <p className="text-sm text-white/40">Não foi possível carregar a pré-visualização.</p>
+            <Button variant="secondary" loading={mutDownload.isPending} onClick={() => mutDownload.mutate()}>
+              Baixar PDF
+            </Button>
+          </div>
+        )}
+      </Card>
+
       {/* Ações do coordenador */}
       {podeAvaliar && (
         <Card>
diff --git a/frontend/src/pages/Instituicoes.tsx b/frontend/src/pages/Instituicoes.tsx
index d3a6d37..df9e089 100644
--- a/frontend/src/pages/Instituicoes.tsx
+++ b/frontend/src/pages/Instituicoes.tsx
@@ -1,4 +1,4 @@
-import { useState } from 'react';
+import { useState, useEffect } from 'react';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import {
   instituicoesService,
@@ -48,21 +48,40 @@ const ESTADOS_BR = [
 
 // ─── Modal ────────────────────────────────────────────────────
 function Modal({ titulo, onClose, children }: { titulo: string; onClose: () => void; children: React.ReactNode }) {
+  useEffect(() => {
+    document.body.style.overflow = 'hidden';
+    return () => { document.body.style.overflow = ''; };
+  }, []);
+
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => { if (e.key === 'Escape') onClose(); };
+    document.addEventListener('keydown', onKey);
+    return () => document.removeEventListener('keydown', onKey);
+  }, [onClose]);
+
   return (
-    <div className="fixed inset-0 z-50 flex items-start justify-center overflow-y-auto bg-black/40 px-4 py-8">
-      <div className="w-full max-w-xl rounded-2xl bg-[#011140] shadow-xl">
-        <div className="flex items-center justify-between border-b border-white/8 px-6 py-4">
-          <h2 className="text-base font-semibold text-white">{titulo}</h2>
-          <button
-            onClick={onClose}
-            className="rounded-lg p-1.5 text-white/45 hover:bg-white/6 hover:text-white/70"
-          >
-            <svg className="h-5 w-5" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
-              <path strokeLinecap="round" strokeLinejoin="round" d="M6 18L18 6M6 6l12 12" />
-            </svg>
-          </button>
+    <div
+      className="fixed inset-0 z-50 overflow-y-auto bg-black/50"
+      onClick={onClose}
+    >
+      <div className="flex min-h-full items-start justify-center px-4 py-8">
+        <div
+          className="w-full max-w-xl rounded-2xl bg-[#011140] shadow-xl"
+          onClick={(e) => e.stopPropagation()}
+        >
+          <div className="flex items-center justify-between border-b border-white/8 px-6 py-4">
+            <h2 className="text-base font-semibold text-white">{titulo}</h2>
+            <button
+              onClick={onClose}
+              className="rounded-lg p-1.5 text-white/45 hover:bg-white/6 hover:text-white/70"
+            >
+              <svg className="h-5 w-5" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
+                <path strokeLinecap="round" strokeLinejoin="round" d="M6 18L18 6M6 6l12 12" />
+              </svg>
+            </button>
+          </div>
+          <div className="px-6 py-5">{children}</div>
         </div>
-        <div className="px-6 py-5">{children}</div>
       </div>
     </div>
   );
diff --git a/frontend/src/pages/MeusCertificados.tsx b/frontend/src/pages/MeusCertificados.tsx
index 487c346..9aa09f5 100644
--- a/frontend/src/pages/MeusCertificados.tsx
+++ b/frontend/src/pages/MeusCertificados.tsx
@@ -6,10 +6,12 @@ import { Button } from '../components/ui/Button';
 import { EmojiEventsIcon } from '../components/icons';
 
 const TIPO_LEGIVEL: Record<string, string> = {
-  estagio: 'Estágio',
-  tcc: 'TCC',
-  extensao: 'Extensão',
-  monitoria: 'Monitoria',
+  certificado_curso: 'Certificado de Curso',
+  certificado_evento: 'Certificado de Evento',
+  declaracao_participacao: 'Declaração de Participação',
+  comprovante_atividade: 'Comprovante de Atividade',
+  artigo_publicado: 'Artigo Publicado',
+  outro: 'Outro',
 };
 
 export function MeusCertificados() {
diff --git a/frontend/src/pages/Usuarios.tsx b/frontend/src/pages/Usuarios.tsx
index 9817172..d29dcd5 100644
--- a/frontend/src/pages/Usuarios.tsx
+++ b/frontend/src/pages/Usuarios.tsx
@@ -1,4 +1,4 @@
-import { useState } from 'react';
+import { useState, useEffect } from 'react';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import { usuariosService, type CriarUsuarioInput, type AtualizarUsuarioInput } from '../services/usuarios';
 import { cursosService, type Curso } from '../services/cursos';
@@ -56,18 +56,37 @@ function formatarCpf(valor: string) {
 
 // ─── Modal ────────────────────────────────────────────────────
 function Modal({ titulo, onClose, children }: { titulo: string; onClose: () => void; children: React.ReactNode }) {
+  useEffect(() => {
+    document.body.style.overflow = 'hidden';
+    return () => { document.body.style.overflow = ''; };
+  }, []);
+
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => { if (e.key === 'Escape') onClose(); };
+    document.addEventListener('keydown', onKey);
+    return () => document.removeEventListener('keydown', onKey);
+  }, [onClose]);
+
   return (
-    <div className="fixed inset-0 z-50 flex items-start justify-center overflow-y-auto bg-black/40 px-4 py-8">
-      <div className="w-full max-w-md rounded-2xl bg-[#011140] shadow-xl">
-        <div className="flex items-center justify-between border-b border-white/8 px-6 py-4">
-          <h2 className="text-base font-semibold text-white">{titulo}</h2>
-          <button onClick={onClose} className="rounded-lg p-1.5 text-white/45 hover:bg-white/6">
-            <svg className="h-5 w-5" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
-              <path strokeLinecap="round" strokeLinejoin="round" d="M6 18L18 6M6 6l12 12" />
-            </svg>
-          </button>
+    <div
+      className="fixed inset-0 z-50 overflow-y-auto bg-black/50"
+      onClick={onClose}
+    >
+      <div className="flex min-h-full items-start justify-center px-4 py-8">
+        <div
+          className="w-full max-w-md rounded-2xl bg-[#011140] shadow-xl"
+          onClick={(e) => e.stopPropagation()}
+        >
+          <div className="flex items-center justify-between border-b border-white/8 px-6 py-4">
+            <h2 className="text-base font-semibold text-white">{titulo}</h2>
+            <button onClick={onClose} className="rounded-lg p-1.5 text-white/45 hover:bg-white/6 hover:text-white/70">
+              <svg className="h-5 w-5" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
+                <path strokeLinecap="round" strokeLinejoin="round" d="M6 18L18 6M6 6l12 12" />
+              </svg>
+            </button>
+          </div>
+          <div className="px-6 py-5">{children}</div>
         </div>
-        <div className="px-6 py-5">{children}</div>
       </div>
     </div>
   );
diff --git a/frontend/src/pages/Verificar.tsx b/frontend/src/pages/Verificar.tsx
index 1e4705d..76633e3 100644
--- a/frontend/src/pages/Verificar.tsx
+++ b/frontend/src/pages/Verificar.tsx
@@ -3,10 +3,12 @@ import { useQuery } from '@tanstack/react-query';
 import axios from 'axios';
 
 const TIPO_LEGIVEL: Record<string, string> = {
-  estagio:  'Estágio',
-  tcc:      'Trabalho de Conclusão de Curso',
-  extensao: 'Atividade de Extensão',
-  monitoria:'Monitoria',
+  certificado_curso: 'Certificado de Curso',
+  certificado_evento: 'Certificado de Evento',
+  declaracao_participacao: 'Declaração de Participação',
+  comprovante_atividade: 'Comprovante de Atividade',
+  artigo_publicado: 'Artigo Publicado',
+  outro: 'Outro',
 };
 
 interface RespostaVerificacao {
diff --git a/frontend/src/test/components/PrivateRoute.test.tsx b/frontend/src/test/components/PrivateRoute.test.tsx
index c0acd57..3a9a75d 100644
--- a/frontend/src/test/components/PrivateRoute.test.tsx
+++ b/frontend/src/test/components/PrivateRoute.test.tsx
@@ -62,4 +62,21 @@ describe('PrivateRoute', () => {
     renderComAuth('tok-123', USUARIO_MOCK, ['admin']);
     expect(screen.getByText('Conteúdo Protegido')).toBeInTheDocument();
   });
+
+  it('renderiza Outlet quando usado como elemento de rota sem children', () => {
+    localStorage.setItem('token', 'tok-123');
+    localStorage.setItem('usuario', JSON.stringify(USUARIO_MOCK));
+    render(
+      <MemoryRouter initialEntries={['/protegido']}>
+        <AuthProvider>
+          <Routes>
+            <Route element={<PrivateRoute />}>
+              <Route path="/protegido" element={<div>Conteúdo via Outlet</div>} />
+            </Route>
+          </Routes>
+        </AuthProvider>
+      </MemoryRouter>,
+    );
+    expect(screen.getByText('Conteúdo via Outlet')).toBeInTheDocument();
+  });
 });
diff --git a/frontend/src/test/contexts/ThemeContext.test.tsx b/frontend/src/test/contexts/ThemeContext.test.tsx
index 78c9c7e..e54e2ad 100644
--- a/frontend/src/test/contexts/ThemeContext.test.tsx
+++ b/frontend/src/test/contexts/ThemeContext.test.tsx
@@ -50,4 +50,17 @@ describe('ThemeContext', () => {
     await act(async () => { screen.getByText('alternar').click(); });
     expect(localStorage.getItem('tema')).toBe('light');
   });
+
+  it('atualiza o meta color-scheme quando o elemento existe', async () => {
+    const meta = document.createElement('meta');
+    meta.setAttribute('name', 'color-scheme');
+    document.head.appendChild(meta);
+    try {
+      render(<ThemeProvider><Probe /></ThemeProvider>);
+      await act(async () => { screen.getByText('alternar').click(); });
+      expect(meta.content).toBe('light');
+    } finally {
+      document.head.removeChild(meta);
+    }
+  });
 });
diff --git a/frontend/src/test/pages/Cursos.test.tsx b/frontend/src/test/pages/Cursos.test.tsx
new file mode 100644
index 0000000..3b9639d
--- /dev/null
+++ b/frontend/src/test/pages/Cursos.test.tsx
@@ -0,0 +1,364 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { screen, fireEvent, waitFor } from '@testing-library/react';
+import { renderWithProviders, USUARIO_ADMIN } from '../helpers/renderWithProviders';
+import { Cursos } from '../../pages/Cursos';
+
+const { mockCursosService, mockInstituicoesService } = vi.hoisted(() => ({
+  mockCursosService: {
+    listarAdmin: vi.fn(),
+    criar: vi.fn(),
+    atualizar: vi.fn(),
+    alterarAtivo: vi.fn(),
+  },
+  mockInstituicoesService: {
+    listar: vi.fn(),
+  },
+}));
+
+vi.mock('../../services/api', () => ({
+  default: {
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    interceptors: { request: { use: vi.fn() }, response: { use: vi.fn() } },
+  },
+}));
+
+vi.mock('../../services/cursos', () => ({ cursosService: mockCursosService }));
+vi.mock('../../services/instituicoes', () => ({ instituicoesService: mockInstituicoesService }));
+
+const INST_MOCK = [
+  {
+    id: 'i-1', nome: 'Universidade Teste', sigla: 'UT', ativa: true,
+    dominios_email: [], cnpj: null, email_contato: null, telefone: null,
+    site: null, endereco: null, cidade: null, estado: null,
+    criado_em: '', atualizado_em: '',
+  },
+];
+
+const CURSOS_MOCK = [
+  {
+    id: 'c-1', nome: 'Ciência da Computação', codigo: 'CC-001',
+    carga_horaria_complementar: 200, turno: 'noturno', modalidade: 'presencial',
+    instituicao_id: 'i-1', instituicao_nome: 'Universidade Teste', instituicao_sigla: 'UT',
+    ativo: true, total_estudantes: 5, criado_em: '', atualizado_em: '',
+  },
+  {
+    id: 'c-2', nome: 'Engenharia de Software', codigo: 'ES-001',
+    carga_horaria_complementar: 160, turno: null, modalidade: null,
+    instituicao_id: 'i-1', instituicao_nome: 'Universidade Teste', instituicao_sigla: 'UT',
+    ativo: false, total_estudantes: 0, criado_em: '', atualizado_em: '',
+  },
+];
+
+function renderCursos() {
+  return renderWithProviders(<Cursos />, { token: 'tok', usuario: USUARIO_ADMIN });
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  localStorage.clear();
+  mockCursosService.listarAdmin.mockResolvedValue(CURSOS_MOCK);
+  mockInstituicoesService.listar.mockResolvedValue(INST_MOCK);
+});
+
+describe('Cursos — renderização', () => {
+  it('exibe título Cursos', async () => {
+    renderCursos();
+    await waitFor(() => expect(screen.getByText('Cursos')).toBeInTheDocument());
+  });
+
+  it('exibe lista de cursos após carregar', async () => {
+    renderCursos();
+    await waitFor(() => {
+      expect(screen.getByText('Ciência da Computação')).toBeInTheDocument();
+      expect(screen.getByText('Engenharia de Software')).toBeInTheDocument();
+    });
+  });
+
+  it('exibe badge Inativo para curso inativo', async () => {
+    renderCursos();
+    await waitFor(() => expect(screen.getByText('Inativo')).toBeInTheDocument());
+  });
+
+  it('exibe estado de carregamento inicialmente', () => {
+    mockCursosService.listarAdmin.mockReturnValue(new Promise(() => {}));
+    renderCursos();
+    expect(screen.getByText('Carregando cursos...')).toBeInTheDocument();
+  });
+
+  it('exibe mensagem quando não há cursos', async () => {
+    mockCursosService.listarAdmin.mockResolvedValue([]);
+    renderCursos();
+    await waitFor(() => expect(screen.getByText('Nenhum curso cadastrado ainda.')).toBeInTheDocument());
+  });
+
+  it('exibe código do curso', async () => {
+    renderCursos();
+    await waitFor(() => expect(screen.getByText('CC-001')).toBeInTheDocument());
+  });
+
+  it('exibe total de estudantes', async () => {
+    renderCursos();
+    await waitFor(() => expect(screen.getByText('5 alunos')).toBeInTheDocument());
+  });
+
+  it('exibe estatística com total de cursos', async () => {
+    renderCursos();
+    await waitFor(() => expect(screen.getByText(/2 cursos/)).toBeInTheDocument());
+  });
+
+  it('exibe turno e modalidade como badges', async () => {
+    renderCursos();
+    await waitFor(() => {
+      expect(screen.getByText('noturno')).toBeInTheDocument();
+      expect(screen.getByText('presencial')).toBeInTheDocument();
+    });
+  });
+
+  it('exibe carga horária complementar', async () => {
+    renderCursos();
+    await waitFor(() => expect(screen.getByText('200h complementares')).toBeInTheDocument());
+  });
+
+  it('exibe instituição dos cursos', async () => {
+    renderCursos();
+    await waitFor(() => expect(screen.getAllByText('Universidade Teste').length).toBeGreaterThan(0));
+  });
+
+  it('botão Novo curso está presente', async () => {
+    renderCursos();
+    await waitFor(() => expect(screen.getByText('Novo curso')).toBeInTheDocument());
+  });
+});
+
+describe('Cursos — filtros', () => {
+  it('filtra cursos por busca de nome', async () => {
+    renderCursos();
+    await waitFor(() => screen.getByText('Ciência da Computação'));
+    fireEvent.change(screen.getByPlaceholderText(/buscar por nome/i), { target: { value: 'Engenharia' } });
+    expect(screen.queryByText('Ciência da Computação')).not.toBeInTheDocument();
+    expect(screen.getByText('Engenharia de Software')).toBeInTheDocument();
+  });
+
+  it('busca por código retorna resultado correto', async () => {
+    renderCursos();
+    await waitFor(() => screen.getByText('Ciência da Computação'));
+    fireEvent.change(screen.getByPlaceholderText(/buscar por nome/i), { target: { value: 'CC-001' } });
+    expect(screen.getByText('Ciência da Computação')).toBeInTheDocument();
+    expect(screen.queryByText('Engenharia de Software')).not.toBeInTheDocument();
+  });
+
+  it('exibe mensagem de nenhum resultado após filtro', async () => {
+    renderCursos();
+    await waitFor(() => screen.getByText('Ciência da Computação'));
+    fireEvent.change(screen.getByPlaceholderText(/buscar por nome/i), { target: { value: 'xyzinexistente' } });
+    await waitFor(() => {
+      expect(screen.getByText(/Nenhum curso encontrado para os filtros aplicados/)).toBeInTheDocument();
+    });
+  });
+
+  it('exibe campo de filtro por instituição', async () => {
+    renderCursos();
+    await waitFor(() => expect(screen.getByText('Todas as instituições')).toBeInTheDocument());
+  });
+});
+
+describe('Cursos — modal criar', () => {
+  it('abre modal ao clicar em Novo curso', async () => {
+    renderCursos();
+    await waitFor(() => screen.getByText('Novo curso'));
+    fireEvent.click(screen.getByText('Novo curso'));
+    expect(screen.getByText('Novo curso', { selector: 'h2' })).toBeInTheDocument();
+  });
+
+  it('fecha modal ao clicar em Cancelar', async () => {
+    renderCursos();
+    await waitFor(() => screen.getByText('Novo curso'));
+    fireEvent.click(screen.getByText('Novo curso'));
+    fireEvent.click(screen.getByText('Cancelar'));
+    expect(screen.queryByText('Criar curso')).not.toBeInTheDocument();
+  });
+
+  it('não chama criar quando nome está vazio', async () => {
+    renderCursos();
+    await waitFor(() => screen.getByText('Novo curso'));
+    fireEvent.click(screen.getByText('Novo curso'));
+    fireEvent.click(screen.getByText('Criar curso'));
+    expect(mockCursosService.criar).not.toHaveBeenCalled();
+  });
+
+  it('não chama criar quando instituição não está selecionada', async () => {
+    renderCursos();
+    await waitFor(() => screen.getByText('Novo curso'));
+    fireEvent.click(screen.getByText('Novo curso'));
+    fireEvent.change(screen.getByPlaceholderText('Ex: Ciência da Computação'), {
+      target: { value: 'Novo Curso' },
+    });
+    fireEvent.click(screen.getByText('Criar curso'));
+    expect(mockCursosService.criar).not.toHaveBeenCalled();
+  });
+
+  it('chama cursosService.criar com dados válidos', async () => {
+    mockCursosService.criar.mockResolvedValue({ id: 'c-3', nome: 'Novo Curso' });
+    renderCursos();
+    await waitFor(() => screen.getByText('Novo curso'));
+    fireEvent.click(screen.getByText('Novo curso'));
+
+    // Usa o texto único do placeholder do select dentro do modal
+    const instSelect = screen.getByText('Selecione uma instituição...').closest('select')!;
+    fireEvent.change(instSelect, { target: { value: 'i-1' } });
+    fireEvent.change(screen.getByPlaceholderText('Ex: Ciência da Computação'), {
+      target: { value: 'Novo Curso Teste' },
+    });
+    fireEvent.click(screen.getByText('Criar curso'));
+    await waitFor(() => expect(mockCursosService.criar).toHaveBeenCalled());
+  });
+
+  it('modal exibe select de turno e modalidade', async () => {
+    renderCursos();
+    await waitFor(() => screen.getByText('Novo curso'));
+    fireEvent.click(screen.getByText('Novo curso'));
+    expect(screen.getByText('Não definido')).toBeInTheDocument();
+    expect(screen.getByText('Não definida')).toBeInTheDocument();
+  });
+});
+
+describe('Cursos — modal editar', () => {
+  it('abre modal de edição ao clicar em Editar', async () => {
+    renderCursos();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    expect(screen.getByText('Salvar alterações')).toBeInTheDocument();
+  });
+
+  it('preenche modal com nome do curso', async () => {
+    renderCursos();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    expect(screen.getByDisplayValue('Ciência da Computação')).toBeInTheDocument();
+  });
+
+  it('fecha modal de edição ao clicar em Cancelar', async () => {
+    renderCursos();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    fireEvent.click(screen.getByText('Cancelar'));
+    expect(screen.queryByText('Salvar alterações')).not.toBeInTheDocument();
+  });
+
+  it('chama cursosService.atualizar ao salvar edição válida', async () => {
+    mockCursosService.atualizar.mockResolvedValue({ id: 'c-1' });
+    renderCursos();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    fireEvent.click(screen.getByText('Salvar alterações'));
+    await waitFor(() =>
+      expect(mockCursosService.atualizar).toHaveBeenCalledWith(
+        'c-1',
+        expect.objectContaining({ nome: 'Ciência da Computação' }),
+      ),
+    );
+  });
+});
+
+describe('Cursos — alterar ativo', () => {
+  it('chama cursosService.alterarAtivo ao desativar curso ativo', async () => {
+    mockCursosService.alterarAtivo.mockResolvedValue({ id: 'c-1', ativo: false });
+    renderCursos();
+    await waitFor(() => screen.getByText('Desativar'));
+    fireEvent.click(screen.getByText('Desativar'));
+    await waitFor(() =>
+      expect(mockCursosService.alterarAtivo).toHaveBeenCalledWith('c-1', false),
+    );
+  });
+
+  it('chama cursosService.alterarAtivo ao ativar curso inativo', async () => {
+    mockCursosService.alterarAtivo.mockResolvedValue({ id: 'c-2', ativo: true });
+    renderCursos();
+    await waitFor(() => screen.getByText('Ativar'));
+    fireEvent.click(screen.getByText('Ativar'));
+    await waitFor(() =>
+      expect(mockCursosService.alterarAtivo).toHaveBeenCalledWith('c-2', true),
+    );
+  });
+});
+
+describe('Cursos — erros de mutation', () => {
+  it('exibe erro personalizado da API ao falhar criação', async () => {
+    mockCursosService.criar.mockRejectedValue({
+      response: { data: { erro: 'Código duplicado' } },
+    });
+    renderCursos();
+    await waitFor(() => screen.getByText('Novo curso'));
+    fireEvent.click(screen.getByText('Novo curso'));
+
+    const instSelect = screen.getByText('Selecione uma instituição...').closest('select')!;
+    fireEvent.change(instSelect, { target: { value: 'i-1' } });
+    fireEvent.change(screen.getByPlaceholderText('Ex: Ciência da Computação'), {
+      target: { value: 'Curso Duplicado' },
+    });
+    fireEvent.click(screen.getByText('Criar curso'));
+    await waitFor(() => expect(mockCursosService.criar).toHaveBeenCalled());
+  });
+
+  it('exibe mensagem genérica ao falhar criação sem detalhe da API', async () => {
+    mockCursosService.criar.mockRejectedValue(new Error('Network error'));
+    renderCursos();
+    await waitFor(() => screen.getByText('Novo curso'));
+    fireEvent.click(screen.getByText('Novo curso'));
+
+    const instSelect = screen.getByText('Selecione uma instituição...').closest('select')!;
+    fireEvent.change(instSelect, { target: { value: 'i-1' } });
+    fireEvent.change(screen.getByPlaceholderText('Ex: Ciência da Computação'), {
+      target: { value: 'Curso Erro' },
+    });
+    fireEvent.click(screen.getByText('Criar curso'));
+    await waitFor(() => expect(mockCursosService.criar).toHaveBeenCalled());
+  });
+
+  it('exibe erro ao falhar atualização de curso', async () => {
+    mockCursosService.atualizar.mockRejectedValue(new Error('fail'));
+    renderCursos();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    fireEvent.click(screen.getByText('Salvar alterações'));
+    await waitFor(() => expect(mockCursosService.atualizar).toHaveBeenCalled());
+  });
+
+  it('exibe erro ao falhar alteração de status', async () => {
+    mockCursosService.alterarAtivo.mockRejectedValue(new Error('fail'));
+    renderCursos();
+    await waitFor(() => screen.getByText('Desativar'));
+    fireEvent.click(screen.getByText('Desativar'));
+    await waitFor(() => expect(mockCursosService.alterarAtivo).toHaveBeenCalled());
+  });
+});
+
+describe('Cursos — fechar modal pelo botão ×', () => {
+  it('fecha modal de criação pelo botão × do cabeçalho', async () => {
+    renderCursos();
+    await waitFor(() => screen.getByText('Novo curso'));
+    fireEvent.click(screen.getByText('Novo curso'));
+
+    // Clica no botão × do cabeçalho do modal (SVG button sem texto)
+    const overlay = document.querySelector('.fixed.inset-0');
+    const closeBtn = overlay?.querySelector('button');
+    expect(closeBtn).toBeTruthy();
+    fireEvent.click(closeBtn!);
+    expect(screen.queryByText('Criar curso')).not.toBeInTheDocument();
+  });
+
+  it('fecha modal de edição pelo botão × do cabeçalho', async () => {
+    renderCursos();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+
+    const overlay = document.querySelector('.fixed.inset-0');
+    const closeBtn = overlay?.querySelector('button');
+    expect(closeBtn).toBeTruthy();
+    fireEvent.click(closeBtn!);
+    expect(screen.queryByText('Salvar alterações')).not.toBeInTheDocument();
+  });
+});
diff --git a/frontend/src/test/pages/Dashboard.test.tsx b/frontend/src/test/pages/Dashboard.test.tsx
index 5301778..66e482a 100644
--- a/frontend/src/test/pages/Dashboard.test.tsx
+++ b/frontend/src/test/pages/Dashboard.test.tsx
@@ -1,12 +1,54 @@
-import { describe, it, expect, vi } from 'vitest';
-import { renderWithProviders, USUARIO_ESTUDANTE } from '../helpers/renderWithProviders';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { screen, waitFor } from '@testing-library/react';
+import { renderWithProviders, USUARIO_ESTUDANTE, USUARIO_COORD, USUARIO_ADMIN } from '../helpers/renderWithProviders';
 import { Dashboard } from '../../pages/Dashboard';
 
+const { mockDocumentosService } = vi.hoisted(() => ({
+  mockDocumentosService: { listar: vi.fn() },
+}));
+
 vi.mock('../../services/api', () => ({
-  default: { get: vi.fn().mockResolvedValue({ data: { total: 0, dados: [] } }) },
+  default: {
+    get: vi.fn(),
+    interceptors: { request: { use: vi.fn() }, response: { use: vi.fn() } },
+  },
 }));
 
-describe('Dashboard', () => {
+vi.mock('../../services/documentos', () => ({
+  documentosService: mockDocumentosService,
+}));
+
+const RESPOSTA_VAZIA = { total: 0, dados: [], pagina: 1, total_paginas: 1 };
+
+const DOCS_MOCK = {
+  total: 2,
+  pagina: 1,
+  total_paginas: 1,
+  dados: [
+    {
+      id: 'd-1', titulo: 'Certificado de Python', tipo: 'certificado_curso',
+      carga_horaria: 40, status: 'pendente',
+      estudante_id: 'u-1', estudante_nome: 'João',
+      criado_em: '2024-01-15T10:00:00Z', atualizado_em: '2024-01-15T10:00:00Z',
+      arquivo_url: null, observacoes: null, curso_id: null, instituicao_id: null,
+    },
+    {
+      id: 'd-2', titulo: 'Artigo de Pesquisa', tipo: 'artigo_publicado',
+      carga_horaria: 20, status: 'aprovado',
+      estudante_id: 'u-1', estudante_nome: 'João',
+      criado_em: '2024-02-10T08:00:00Z', atualizado_em: '2024-02-10T08:00:00Z',
+      arquivo_url: null, observacoes: null, curso_id: null, instituicao_id: null,
+    },
+  ],
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  localStorage.clear();
+  mockDocumentosService.listar.mockResolvedValue(RESPOSTA_VAZIA);
+});
+
+describe('Dashboard — estudante', () => {
   it('renderiza a página sem erros', () => {
     const { container } = renderWithProviders(<Dashboard />, {
       token: 'tok-123', usuario: USUARIO_ESTUDANTE,
@@ -14,10 +56,91 @@ describe('Dashboard', () => {
     expect(container).toBeTruthy();
   });
 
-  it('exibe algum conteúdo do dashboard', () => {
-    renderWithProviders(<Dashboard />, {
-      token: 'tok-123', usuario: USUARIO_ESTUDANTE,
+  it('exibe o primeiro nome do usuário', async () => {
+    renderWithProviders(<Dashboard />, { token: 'tok', usuario: USUARIO_ESTUDANTE });
+    await waitFor(() => expect(screen.getByText(/João/)).toBeInTheDocument());
+  });
+
+  it('exibe texto para estudante', async () => {
+    renderWithProviders(<Dashboard />, { token: 'tok', usuario: USUARIO_ESTUDANTE });
+    await waitFor(() =>
+      expect(screen.getByText(/Acompanhe o status dos seus documentos/)).toBeInTheDocument(),
+    );
+  });
+
+  it('exibe link Submeter Documento para estudante', async () => {
+    renderWithProviders(<Dashboard />, { token: 'tok', usuario: USUARIO_ESTUDANTE });
+    await waitFor(() =>
+      expect(screen.getByText('Submeter Documento')).toBeInTheDocument(),
+    );
+  });
+
+  it('exibe link Meus Certificados para estudante', async () => {
+    renderWithProviders(<Dashboard />, { token: 'tok', usuario: USUARIO_ESTUDANTE });
+    await waitFor(() =>
+      expect(screen.getByText('Meus Certificados')).toBeInTheDocument(),
+    );
+  });
+
+  it('exibe mensagem quando não há documentos recentes', async () => {
+    renderWithProviders(<Dashboard />, { token: 'tok', usuario: USUARIO_ESTUDANTE });
+    await waitFor(() =>
+      expect(screen.getByText('Nenhum documento encontrado.')).toBeInTheDocument(),
+    );
+  });
+
+  it('exibe documentos recentes quando há dados', async () => {
+    mockDocumentosService.listar.mockResolvedValue(DOCS_MOCK);
+    renderWithProviders(<Dashboard />, { token: 'tok', usuario: USUARIO_ESTUDANTE });
+    await waitFor(() => {
+      expect(screen.getByText('Certificado de Python')).toBeInTheDocument();
+      expect(screen.getByText('Artigo de Pesquisa')).toBeInTheDocument();
+    });
+  });
+
+  it('exibe link Ver para cada documento recente', async () => {
+    mockDocumentosService.listar.mockResolvedValue(DOCS_MOCK);
+    renderWithProviders(<Dashboard />, { token: 'tok', usuario: USUARIO_ESTUDANTE });
+    await waitFor(() => {
+      const links = screen.getAllByText('Ver');
+      expect(links.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+});
+
+describe('Dashboard — coordenador/admin', () => {
+  it('exibe texto de coordenador/admin', async () => {
+    renderWithProviders(<Dashboard />, { token: 'tok', usuario: USUARIO_COORD });
+    await waitFor(() =>
+      expect(screen.getByText(/Visão geral dos documentos do seu curso/)).toBeInTheDocument(),
+    );
+  });
+
+  it('exibe link Fila de Análise para coordenador', async () => {
+    renderWithProviders(<Dashboard />, { token: 'tok', usuario: USUARIO_COORD });
+    await waitFor(() =>
+      expect(screen.getByText('Fila de Análise')).toBeInTheDocument(),
+    );
+  });
+
+  it('não exibe link Submeter Documento para coordenador', async () => {
+    renderWithProviders(<Dashboard />, { token: 'tok', usuario: USUARIO_COORD });
+    await waitFor(() => screen.getByText(/Visão geral/));
+    expect(screen.queryByText('Submeter Documento')).not.toBeInTheDocument();
+  });
+
+  it('exibe texto correto para admin', async () => {
+    renderWithProviders(<Dashboard />, { token: 'tok', usuario: USUARIO_ADMIN });
+    await waitFor(() =>
+      expect(screen.getByText(/Visão geral dos documentos do seu curso/)).toBeInTheDocument(),
+    );
+  });
+
+  it('exibe cards de status para coordenador', async () => {
+    renderWithProviders(<Dashboard />, { token: 'tok', usuario: USUARIO_COORD });
+    await waitFor(() => {
+      expect(screen.getByText('Pendentes')).toBeInTheDocument();
+      expect(screen.getByText('Em Revisão')).toBeInTheDocument();
     });
-    expect(document.body).toBeTruthy();
   });
 });
diff --git a/frontend/src/test/pages/DetalheDocumento.test.tsx b/frontend/src/test/pages/DetalheDocumento.test.tsx
index 2e66516..692b5e1 100644
--- a/frontend/src/test/pages/DetalheDocumento.test.tsx
+++ b/frontend/src/test/pages/DetalheDocumento.test.tsx
@@ -62,6 +62,7 @@ beforeEach(() => {
   vi.clearAllMocks();
   mockDocumentosService.buscarPorId.mockResolvedValue(DOC_MOCK);
   mockDocumentosService.historico.mockResolvedValue([]);
+  mockDocumentosService.buscarUrlDownload.mockResolvedValue({ url: 'https://s3.test/doc.pdf', expira_em: '2025-01-01' });
 });
 
 describe('DetalheDocumento — loading e not found', () => {
@@ -147,6 +148,32 @@ describe('DetalheDocumento — detalhes do documento', () => {
   });
 });
 
+describe('DetalheDocumento — pré-visualização PDF', () => {
+  it('exibe seção de pré-visualização', async () => {
+    renderWithProviders(<DetalheDocumento />, { token: 'tok', usuario: USUARIO_ESTUDANTE });
+    await waitFor(() => {
+      expect(screen.getByText('Pré-visualização')).toBeInTheDocument();
+    });
+  });
+
+  it('renderiza iframe com src da URL assinada', async () => {
+    renderWithProviders(<DetalheDocumento />, { token: 'tok', usuario: USUARIO_ESTUDANTE });
+    await waitFor(() => {
+      const iframe = document.querySelector('iframe');
+      expect(iframe).toBeInTheDocument();
+      expect(iframe?.src).toContain('s3.test');
+    });
+  });
+
+  it('exibe fallback quando buscarUrlDownload falha', async () => {
+    mockDocumentosService.buscarUrlDownload.mockRejectedValue(new Error('Erro'));
+    renderWithProviders(<DetalheDocumento />, { token: 'tok', usuario: USUARIO_ESTUDANTE });
+    await waitFor(() => {
+      expect(screen.getByText(/Não foi possível carregar a pré-visualização/i)).toBeInTheDocument();
+    });
+  });
+});
+
 describe('DetalheDocumento — estudante com documento pendente', () => {
   it('exibe opção de cancelar para estudante com doc pendente', async () => {
     renderWithProviders(<DetalheDocumento />, { token: 'tok', usuario: USUARIO_ESTUDANTE });
diff --git a/frontend/src/test/pages/Instituicoes.test.tsx b/frontend/src/test/pages/Instituicoes.test.tsx
new file mode 100644
index 0000000..1d17574
--- /dev/null
+++ b/frontend/src/test/pages/Instituicoes.test.tsx
@@ -0,0 +1,411 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { screen, fireEvent, waitFor } from '@testing-library/react';
+import { renderWithProviders, USUARIO_ADMIN } from '../helpers/renderWithProviders';
+import { Instituicoes } from '../../pages/Instituicoes';
+
+const { mockInstituicoesService } = vi.hoisted(() => ({
+  mockInstituicoesService: {
+    listar: vi.fn(),
+    criar: vi.fn(),
+    atualizar: vi.fn(),
+    alterarAtiva: vi.fn(),
+  },
+}));
+
+vi.mock('../../services/api', () => ({
+  default: {
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    interceptors: { request: { use: vi.fn() }, response: { use: vi.fn() } },
+  },
+}));
+
+vi.mock('../../services/instituicoes', () => ({ instituicoesService: mockInstituicoesService }));
+
+const INST_MOCK = [
+  {
+    id: 'i-1', nome: 'Universidade Federal', sigla: 'UFSC',
+    cnpj: '00.000.000/0001-00', email_contato: 'contato@ufsc.br',
+    telefone: '(48) 3333-4444', site: 'https://ufsc.br',
+    endereco: 'Campus Trindade', cidade: 'Florianópolis', estado: 'SC',
+    dominios_email: ['ufsc.br', 'grad.ufsc.br'], ativa: true,
+    criado_em: '', atualizado_em: '',
+  },
+  {
+    id: 'i-2', nome: 'Instituto Estadual', sigla: 'IFE',
+    cnpj: null, email_contato: null, telefone: null, site: null,
+    endereco: null, cidade: null, estado: null,
+    dominios_email: [], ativa: false,
+    criado_em: '', atualizado_em: '',
+  },
+];
+
+function renderInstituicoes() {
+  return renderWithProviders(<Instituicoes />, { token: 'tok', usuario: USUARIO_ADMIN });
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  localStorage.clear();
+  mockInstituicoesService.listar.mockResolvedValue(INST_MOCK);
+});
+
+describe('Instituicoes — renderização', () => {
+  it('exibe título Instituições', async () => {
+    renderInstituicoes();
+    await waitFor(() => expect(screen.getByText('Instituições')).toBeInTheDocument());
+  });
+
+  it('exibe lista de instituições após carregar', async () => {
+    renderInstituicoes();
+    await waitFor(() => {
+      expect(screen.getByText('Universidade Federal')).toBeInTheDocument();
+      expect(screen.getByText('Instituto Estadual')).toBeInTheDocument();
+    });
+  });
+
+  it('exibe siglas das instituições', async () => {
+    renderInstituicoes();
+    await waitFor(() => {
+      expect(screen.getByText('UFSC')).toBeInTheDocument();
+      expect(screen.getByText('IFE')).toBeInTheDocument();
+    });
+  });
+
+  it('exibe badge Inativa para instituição inativa', async () => {
+    renderInstituicoes();
+    await waitFor(() => expect(screen.getByText('Inativa')).toBeInTheDocument());
+  });
+
+  it('exibe estado de carregamento', () => {
+    mockInstituicoesService.listar.mockReturnValue(new Promise(() => {}));
+    renderInstituicoes();
+    expect(screen.getByText('Carregando instituições...')).toBeInTheDocument();
+  });
+
+  it('exibe mensagem quando lista está vazia', async () => {
+    mockInstituicoesService.listar.mockResolvedValue([]);
+    renderInstituicoes();
+    await waitFor(() =>
+      expect(screen.getByText('Nenhuma instituição cadastrada ainda.')).toBeInTheDocument(),
+    );
+  });
+
+  it('exibe domínios de e-mail da instituição', async () => {
+    renderInstituicoes();
+    await waitFor(() => {
+      expect(screen.getByText('@ufsc.br')).toBeInTheDocument();
+      expect(screen.getByText('@grad.ufsc.br')).toBeInTheDocument();
+    });
+  });
+
+  it('exibe Qualquer domínio aceito para instituição sem domínios', async () => {
+    renderInstituicoes();
+    await waitFor(() => expect(screen.getByText('Qualquer domínio aceito')).toBeInTheDocument());
+  });
+
+  it('exibe localização da instituição', async () => {
+    renderInstituicoes();
+    await waitFor(() => expect(screen.getByText(/Florianópolis/)).toBeInTheDocument());
+  });
+
+  it('exibe e-mail de contato como link mailto', async () => {
+    renderInstituicoes();
+    await waitFor(() => {
+      const link = screen.getByText('contato@ufsc.br');
+      expect(link.closest('a')).toHaveAttribute('href', 'mailto:contato@ufsc.br');
+    });
+  });
+
+  it('exibe site como link externo', async () => {
+    renderInstituicoes();
+    await waitFor(() => {
+      const link = screen.getByText('https://ufsc.br');
+      expect(link.closest('a')).toHaveAttribute('href', 'https://ufsc.br');
+    });
+  });
+
+  it('exibe telefone da instituição', async () => {
+    renderInstituicoes();
+    await waitFor(() => expect(screen.getByText('(48) 3333-4444')).toBeInTheDocument());
+  });
+
+  it('botão Nova instituição está presente', async () => {
+    renderInstituicoes();
+    await waitFor(() => expect(screen.getByText('Nova instituição')).toBeInTheDocument());
+  });
+});
+
+describe('Instituicoes — busca', () => {
+  it('filtra por nome', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Universidade Federal'));
+    fireEvent.change(screen.getByPlaceholderText(/buscar por nome/i), { target: { value: 'Federal' } });
+    expect(screen.queryByText('Instituto Estadual')).not.toBeInTheDocument();
+    expect(screen.getByText('Universidade Federal')).toBeInTheDocument();
+  });
+
+  it('filtra por sigla', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Universidade Federal'));
+    fireEvent.change(screen.getByPlaceholderText(/buscar por nome/i), { target: { value: 'IFE' } });
+    expect(screen.queryByText('Universidade Federal')).not.toBeInTheDocument();
+    expect(screen.getByText('Instituto Estadual')).toBeInTheDocument();
+  });
+
+  it('exibe mensagem quando busca não encontra resultado', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Universidade Federal'));
+    fireEvent.change(screen.getByPlaceholderText(/buscar por nome/i), { target: { value: 'xyzinexistente' } });
+    await waitFor(() =>
+      expect(screen.getByText('Nenhuma instituição encontrada.')).toBeInTheDocument(),
+    );
+  });
+});
+
+describe('Instituicoes — modal criar', () => {
+  it('abre modal ao clicar em Nova instituição', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Nova instituição'));
+    fireEvent.click(screen.getByText('Nova instituição'));
+    expect(screen.getByText('Criar instituição')).toBeInTheDocument();
+  });
+
+  it('fecha modal ao clicar em Cancelar', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Nova instituição'));
+    fireEvent.click(screen.getByText('Nova instituição'));
+    fireEvent.click(screen.getByText('Cancelar'));
+    expect(screen.queryByText('Criar instituição')).not.toBeInTheDocument();
+  });
+
+  it('não chama criar quando nome e sigla estão vazios', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Nova instituição'));
+    fireEvent.click(screen.getByText('Nova instituição'));
+    fireEvent.click(screen.getByText('Criar instituição'));
+    expect(mockInstituicoesService.criar).not.toHaveBeenCalled();
+  });
+
+  it('chama instituicoesService.criar com nome e sigla preenchidos', async () => {
+    mockInstituicoesService.criar.mockResolvedValue({ id: 'i-3' });
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Nova instituição'));
+    fireEvent.click(screen.getByText('Nova instituição'));
+
+    fireEvent.change(screen.getByPlaceholderText('Ex: Universidade Federal de SC'), {
+      target: { value: 'Nova Universidade' },
+    });
+    fireEvent.change(screen.getByPlaceholderText('UFSC'), { target: { value: 'NU' } });
+    fireEvent.click(screen.getByText('Criar instituição'));
+    await waitFor(() => expect(mockInstituicoesService.criar).toHaveBeenCalled());
+  });
+
+  it('permite adicionar domínio de e-mail via botão Adicionar', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Nova instituição'));
+    fireEvent.click(screen.getByText('Nova instituição'));
+
+    fireEvent.change(screen.getByPlaceholderText('ex: ufsc.br'), {
+      target: { value: 'novo.edu.br' },
+    });
+    fireEvent.click(screen.getByText('Adicionar'));
+    expect(screen.getByText('@novo.edu.br')).toBeInTheDocument();
+  });
+
+  it('permite adicionar domínio via tecla Enter', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Nova instituição'));
+    fireEvent.click(screen.getByText('Nova instituição'));
+
+    const input = screen.getByPlaceholderText('ex: ufsc.br');
+    fireEvent.change(input, { target: { value: 'pressenter.edu' } });
+    fireEvent.keyDown(input, { key: 'Enter' });
+    expect(screen.getByText('@pressenter.edu')).toBeInTheDocument();
+  });
+
+  it('permite remover domínio adicionado', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Nova instituição'));
+    fireEvent.click(screen.getByText('Nova instituição'));
+
+    fireEvent.change(screen.getByPlaceholderText('ex: ufsc.br'), {
+      target: { value: 'remover.edu' },
+    });
+    fireEvent.click(screen.getByText('Adicionar'));
+    expect(screen.getByText('@remover.edu')).toBeInTheDocument();
+
+    fireEvent.click(screen.getByText('×'));
+    expect(screen.queryByText('@remover.edu')).not.toBeInTheDocument();
+  });
+
+  it('não adiciona domínio duplicado', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Nova instituição'));
+    fireEvent.click(screen.getByText('Nova instituição'));
+
+    const input = screen.getByPlaceholderText('ex: ufsc.br');
+    fireEvent.change(input, { target: { value: 'duplo.edu' } });
+    fireEvent.click(screen.getByText('Adicionar'));
+    fireEvent.change(input, { target: { value: 'duplo.edu' } });
+    fireEvent.click(screen.getByText('Adicionar'));
+
+    const tags = screen.getAllByText('@duplo.edu');
+    expect(tags).toHaveLength(1);
+  });
+
+  it('exibe campos opcionais no formulário', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Nova instituição'));
+    fireEvent.click(screen.getByText('Nova instituição'));
+    expect(screen.getByPlaceholderText('contato@instituicao.edu.br')).toBeInTheDocument();
+    expect(screen.getByPlaceholderText('(48) 3333-4444')).toBeInTheDocument();
+    expect(screen.getByPlaceholderText('00.000.000/0001-00')).toBeInTheDocument();
+    expect(screen.getByPlaceholderText('https://www.instituicao.edu.br')).toBeInTheDocument();
+  });
+});
+
+describe('Instituicoes — modal editar', () => {
+  it('abre modal de edição ao clicar em Editar', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    expect(screen.getByText('Salvar alterações')).toBeInTheDocument();
+  });
+
+  it('preenche modal com dados da instituição', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    expect(screen.getByDisplayValue('Universidade Federal')).toBeInTheDocument();
+    expect(screen.getByDisplayValue('UFSC')).toBeInTheDocument();
+  });
+
+  it('fecha modal de edição ao clicar em Cancelar', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    fireEvent.click(screen.getByText('Cancelar'));
+    expect(screen.queryByText('Salvar alterações')).not.toBeInTheDocument();
+  });
+
+  it('chama instituicoesService.atualizar ao salvar', async () => {
+    mockInstituicoesService.atualizar.mockResolvedValue({ id: 'i-1' });
+    renderInstituicoes();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    fireEvent.click(screen.getByText('Salvar alterações'));
+    await waitFor(() =>
+      expect(mockInstituicoesService.atualizar).toHaveBeenCalledWith(
+        'i-1',
+        expect.objectContaining({ nome: 'Universidade Federal', sigla: 'UFSC' }),
+      ),
+    );
+  });
+
+  it('não chama atualizar quando nome é apagado', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    fireEvent.change(screen.getByDisplayValue('Universidade Federal'), { target: { value: '' } });
+    fireEvent.click(screen.getByText('Salvar alterações'));
+    expect(mockInstituicoesService.atualizar).not.toHaveBeenCalled();
+  });
+});
+
+describe('Instituicoes — alterar ativa', () => {
+  it('chama instituicoesService.alterarAtiva ao desativar instituição ativa', async () => {
+    mockInstituicoesService.alterarAtiva.mockResolvedValue({ id: 'i-1', ativa: false });
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Desativar'));
+    fireEvent.click(screen.getByText('Desativar'));
+    await waitFor(() =>
+      expect(mockInstituicoesService.alterarAtiva).toHaveBeenCalledWith('i-1', false),
+    );
+  });
+
+  it('chama instituicoesService.alterarAtiva ao ativar instituição inativa', async () => {
+    mockInstituicoesService.alterarAtiva.mockResolvedValue({ id: 'i-2', ativa: true });
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Ativar'));
+    fireEvent.click(screen.getByText('Ativar'));
+    await waitFor(() =>
+      expect(mockInstituicoesService.alterarAtiva).toHaveBeenCalledWith('i-2', true),
+    );
+  });
+});
+
+describe('Instituicoes — erros de mutation', () => {
+  it('exibe erro personalizado da API ao falhar criação', async () => {
+    mockInstituicoesService.criar.mockRejectedValue({
+      response: { data: { erro: 'CNPJ já cadastrado' } },
+    });
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Nova instituição'));
+    fireEvent.click(screen.getByText('Nova instituição'));
+    fireEvent.change(screen.getByPlaceholderText('Ex: Universidade Federal de SC'), {
+      target: { value: 'Instituição Duplicada' },
+    });
+    fireEvent.change(screen.getByPlaceholderText('UFSC'), { target: { value: 'ID' } });
+    fireEvent.click(screen.getByText('Criar instituição'));
+    await waitFor(() => expect(mockInstituicoesService.criar).toHaveBeenCalled());
+  });
+
+  it('exibe mensagem genérica ao falhar criação sem detalhe da API', async () => {
+    mockInstituicoesService.criar.mockRejectedValue(new Error('Network error'));
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Nova instituição'));
+    fireEvent.click(screen.getByText('Nova instituição'));
+    fireEvent.change(screen.getByPlaceholderText('Ex: Universidade Federal de SC'), {
+      target: { value: 'Nova Inst' },
+    });
+    fireEvent.change(screen.getByPlaceholderText('UFSC'), { target: { value: 'NI' } });
+    fireEvent.click(screen.getByText('Criar instituição'));
+    await waitFor(() => expect(mockInstituicoesService.criar).toHaveBeenCalled());
+  });
+
+  it('exibe erro ao falhar atualização de instituição', async () => {
+    mockInstituicoesService.atualizar.mockRejectedValue(new Error('fail'));
+    renderInstituicoes();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    fireEvent.click(screen.getByText('Salvar alterações'));
+    await waitFor(() => expect(mockInstituicoesService.atualizar).toHaveBeenCalled());
+  });
+
+  it('exibe erro ao falhar alteração de status', async () => {
+    mockInstituicoesService.alterarAtiva.mockRejectedValue(new Error('fail'));
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Desativar'));
+    fireEvent.click(screen.getByText('Desativar'));
+    await waitFor(() => expect(mockInstituicoesService.alterarAtiva).toHaveBeenCalled());
+  });
+});
+
+describe('Instituicoes — fechar modal pelo botão ×', () => {
+  it('fecha modal de criação pelo botão × do cabeçalho', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getByText('Nova instituição'));
+    fireEvent.click(screen.getByText('Nova instituição'));
+
+    const overlay = document.querySelector('.fixed.inset-0');
+    const closeBtn = overlay?.querySelector('button');
+    expect(closeBtn).toBeTruthy();
+    fireEvent.click(closeBtn!);
+    expect(screen.queryByText('Criar instituição')).not.toBeInTheDocument();
+  });
+
+  it('fecha modal de edição pelo botão × do cabeçalho', async () => {
+    renderInstituicoes();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+
+    const overlay = document.querySelector('.fixed.inset-0');
+    const closeBtn = overlay?.querySelector('button');
+    expect(closeBtn).toBeTruthy();
+    fireEvent.click(closeBtn!);
+    expect(screen.queryByText('Salvar alterações')).not.toBeInTheDocument();
+  });
+});
diff --git a/frontend/src/test/pages/MeusCertificados.test.tsx b/frontend/src/test/pages/MeusCertificados.test.tsx
index 2204511..d7c999c 100644
--- a/frontend/src/test/pages/MeusCertificados.test.tsx
+++ b/frontend/src/test/pages/MeusCertificados.test.tsx
@@ -27,7 +27,7 @@ const CERT_MOCK = {
   caminho_arquivo: 'certs/cert-1.pdf',
   criado_em: '2024-03-01T10:00:00Z',
   documento: {
-    id: 'doc-1', titulo: 'Workshop React', tipo: 'extensao', carga_horaria: 40,
+    id: 'doc-1', titulo: 'Workshop React', tipo: 'certificado_curso', carga_horaria: 40,
     estudante_id: 'u-1', curso_id: 'c-1', status: 'aprovado' as const,
     coordenador_id: 'coord-1', nome_arquivo: 'cert.pdf', caminho_arquivo: 'docs/cert.pdf',
     tamanho_arquivo: 1024, mime_type: 'application/pdf',
@@ -80,7 +80,7 @@ describe('MeusCertificados — com certificados', () => {
   it('renderiza tipo e carga horária do documento', async () => {
     renderWithProviders(<MeusCertificados />, { token: 'tok', usuario: USUARIO_ESTUDANTE });
     await waitFor(() => {
-      expect(screen.getByText(/Extensão/i)).toBeInTheDocument();
+      expect(screen.getByText(/Certificado de Curso/i)).toBeInTheDocument();
       expect(screen.getByText(/40h/i)).toBeInTheDocument();
     });
   });
@@ -141,4 +141,29 @@ describe('MeusCertificados — com certificados', () => {
       expect(screen.getByText('Baixar PDF')).toBeInTheDocument();
     });
   });
+
+  it('usa tipo bruto como fallback quando tipo não está em TIPO_LEGIVEL', async () => {
+    const certTipoDesconhecido = {
+      ...CERT_MOCK,
+      documento: { ...CERT_MOCK.documento, tipo: 'tipo_desconhecido' },
+    };
+    mockCertificadosService.listar.mockResolvedValue([certTipoDesconhecido]);
+    renderWithProviders(<MeusCertificados />, { token: 'tok', usuario: USUARIO_ESTUDANTE });
+    await waitFor(() => {
+      expect(screen.getByText(/tipo_desconhecido/)).toBeInTheDocument();
+    });
+  });
+
+  it('aplica delay-300 para o 5º certificado ou mais', async () => {
+    const certs = Array.from({ length: 5 }, (_, i) => ({
+      ...CERT_MOCK,
+      id: `cert-${i + 1}`,
+      hash: `hash${i}`,
+      documento: { ...CERT_MOCK.documento, titulo: `Curso ${i}` },
+    }));
+    mockCertificadosService.listar.mockResolvedValue(certs);
+    const { container } = renderWithProviders(<MeusCertificados />, { token: 'tok', usuario: USUARIO_ESTUDANTE });
+    await waitFor(() => screen.getByText('Curso 4'));
+    expect(container.querySelector('.delay-300')).toBeInTheDocument();
+  });
 });
diff --git a/frontend/src/test/pages/Perfil.test.tsx b/frontend/src/test/pages/Perfil.test.tsx
index bad01d4..f901031 100644
--- a/frontend/src/test/pages/Perfil.test.tsx
+++ b/frontend/src/test/pages/Perfil.test.tsx
@@ -146,6 +146,30 @@ describe('Perfil — modo EDITAR DADOS', () => {
     });
   });
 
+  it('exibe erro da API quando mutDados falha com erro personalizado', async () => {
+    mockUsuariosService.atualizarPerfil.mockRejectedValue({
+      response: { data: { erro: 'E-mail já em uso' } },
+    });
+    renderPerfil();
+    await waitFor(() => screen.getByText('Editar perfil'));
+    fireEvent.click(screen.getByText('Editar perfil'));
+    fireEvent.click(screen.getByText('Salvar alterações'));
+    await waitFor(() =>
+      expect(mockUsuariosService.atualizarPerfil).toHaveBeenCalled(),
+    );
+  });
+
+  it('exibe mensagem genérica quando mutDados falha sem detalhe da API', async () => {
+    mockUsuariosService.atualizarPerfil.mockRejectedValue(new Error('Network error'));
+    renderPerfil();
+    await waitFor(() => screen.getByText('Editar perfil'));
+    fireEvent.click(screen.getByText('Editar perfil'));
+    fireEvent.click(screen.getByText('Salvar alterações'));
+    await waitFor(() =>
+      expect(mockUsuariosService.atualizarPerfil).toHaveBeenCalled(),
+    );
+  });
+
   it('salva dados com sucesso e volta ao modo ver', async () => {
     mockUsuariosService.atualizarPerfil.mockResolvedValue({ ...USUARIO_ESTUDANTE, nome: 'Nome Atualizado' });
     renderPerfil();
@@ -245,4 +269,63 @@ describe('Perfil — modo EDITAR SENHA', () => {
       nova_senha: 'novaSenha123',
     }));
   });
+
+  it('exibe erro da API quando mutSenha falha com erro personalizado', async () => {
+    mockUsuariosService.atualizarPerfil.mockRejectedValue({
+      response: { data: { erro: 'Senha atual incorreta' } },
+    });
+    renderPerfil();
+    await waitFor(() => screen.getByText('Alterar senha'));
+    fireEvent.click(screen.getByText('Alterar senha'));
+    fireEvent.change(screen.getByPlaceholderText('Sua senha atual'), { target: { value: 'errada' } });
+    fireEvent.change(screen.getByPlaceholderText('Mínimo 6 caracteres'), { target: { value: 'novaSenha123' } });
+    fireEvent.change(screen.getByPlaceholderText('Repita a nova senha'), { target: { value: 'novaSenha123' } });
+    fireEvent.click(screen.getByText('Salvar nova senha'));
+    await waitFor(() =>
+      expect(screen.getByText('Senha atual incorreta')).toBeInTheDocument(),
+    );
+  });
+
+  it('exibe mensagem genérica quando mutSenha falha sem detalhe da API', async () => {
+    mockUsuariosService.atualizarPerfil.mockRejectedValue(new Error('network error'));
+    renderPerfil();
+    await waitFor(() => screen.getByText('Alterar senha'));
+    fireEvent.click(screen.getByText('Alterar senha'));
+    fireEvent.change(screen.getByPlaceholderText('Sua senha atual'), { target: { value: 'senhaAtual' } });
+    fireEvent.change(screen.getByPlaceholderText('Mínimo 6 caracteres'), { target: { value: 'novaSenha123' } });
+    fireEvent.change(screen.getByPlaceholderText('Repita a nova senha'), { target: { value: 'novaSenha123' } });
+    fireEvent.click(screen.getByText('Salvar nova senha'));
+    await waitFor(() =>
+      expect(screen.getByText('Erro ao alterar senha')).toBeInTheDocument(),
+    );
+  });
+});
+
+describe('Perfil — campos opcionais', () => {
+  it('aceita digitação no campo de matrícula no modo editar (estudante)', async () => {
+    renderPerfil();
+    await waitFor(() => screen.getByText('Editar perfil'));
+    fireEvent.click(screen.getByText('Editar perfil'));
+    const inputMatricula = screen.getByPlaceholderText('Número de matrícula');
+    fireEvent.change(inputMatricula, { target: { value: '2022999' } });
+    expect(inputMatricula).toHaveValue('2022999');
+  });
+
+  it('aceita digitação no campo de CPF no modo editar (coordenador)', async () => {
+    renderPerfil(USUARIO_COORD);
+    await waitFor(() => screen.getByText('Editar perfil'));
+    fireEvent.click(screen.getByText('Editar perfil'));
+    const inputCpf = screen.getByPlaceholderText('000.000.000-00');
+    fireEvent.change(inputCpf, { target: { value: '12345678901' } });
+    expect(inputCpf).toHaveValue('123.456.789-01');
+  });
+
+  it('aceita digitação no campo de endereço no modo editar (coordenador)', async () => {
+    renderPerfil(USUARIO_COORD);
+    await waitFor(() => screen.getByText('Editar perfil'));
+    fireEvent.click(screen.getByText('Editar perfil'));
+    const inputEndereco = screen.getByPlaceholderText(/Rua, número/i);
+    fireEvent.change(inputEndereco, { target: { value: 'Rua das Flores, 42' } });
+    expect(inputEndereco).toHaveValue('Rua das Flores, 42');
+  });
 });
diff --git a/frontend/src/test/pages/Usuarios.test.tsx b/frontend/src/test/pages/Usuarios.test.tsx
new file mode 100644
index 0000000..dc814fa
--- /dev/null
+++ b/frontend/src/test/pages/Usuarios.test.tsx
@@ -0,0 +1,554 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { screen, fireEvent, waitFor } from '@testing-library/react';
+import { renderWithProviders, USUARIO_ADMIN } from '../helpers/renderWithProviders';
+import { Usuarios } from '../../pages/Usuarios';
+
+const { mockUsuariosService, mockCursosService } = vi.hoisted(() => ({
+  mockUsuariosService: {
+    listar: vi.fn(),
+    criar: vi.fn(),
+    atualizar: vi.fn(),
+    alterarAtivo: vi.fn(),
+  },
+  mockCursosService: {
+    listar: vi.fn(),
+  },
+}));
+
+vi.mock('../../services/api', () => ({
+  default: {
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    interceptors: { request: { use: vi.fn() }, response: { use: vi.fn() } },
+  },
+}));
+
+vi.mock('../../services/usuarios', () => ({ usuariosService: mockUsuariosService }));
+vi.mock('../../services/cursos', () => ({ cursosService: mockCursosService }));
+
+const USUARIOS_MOCK = [
+  {
+    id: 'u-1', nome: 'João Silva', email: 'joao@ufsc.br', perfil: 'estudante' as const,
+    matricula: '2021001', cpf: '000.000.000-00', endereco: 'Rua A, 123',
+    curso_id: 'c-1', instituicao_id: 'i-1', instituicao_nome: 'UFSC', ativo: true,
+  },
+  {
+    id: 'u-2', nome: 'Maria Coord', email: 'maria@ufsc.br', perfil: 'coordenador' as const,
+    matricula: null, cpf: null, endereco: null,
+    curso_id: null, instituicao_id: 'i-1', instituicao_nome: 'UFSC', ativo: false,
+  },
+  {
+    id: 'u-3', nome: 'Admin User', email: 'admin@ufsc.br', perfil: 'admin' as const,
+    matricula: null, cpf: null, endereco: null,
+    curso_id: null, instituicao_id: null, instituicao_nome: null, ativo: true,
+  },
+  {
+    id: 'u-4', nome: 'Perfil Desconhecido', email: 'x@ufsc.br', perfil: 'desconhecido' as any,
+    matricula: null, cpf: null, endereco: null,
+    curso_id: null, instituicao_id: null, instituicao_nome: null, ativo: true,
+  },
+];
+
+const CURSOS_MOCK = [
+  {
+    id: 'c-1', nome: 'Ciência da Computação', codigo: 'CC-001',
+    carga_horaria_complementar: 200, turno: null, modalidade: null,
+    instituicao_id: 'i-1', instituicao_nome: 'UFSC', instituicao_sigla: 'UFSC',
+    ativo: true, criado_em: '', atualizado_em: '',
+  },
+];
+
+function renderUsuarios() {
+  return renderWithProviders(<Usuarios />, { token: 'tok', usuario: USUARIO_ADMIN });
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  localStorage.clear();
+  mockUsuariosService.listar.mockResolvedValue(USUARIOS_MOCK);
+  mockCursosService.listar.mockResolvedValue(CURSOS_MOCK);
+});
+
+describe('Usuarios — renderização', () => {
+  it('exibe título Usuários', async () => {
+    renderUsuarios();
+    await waitFor(() => expect(screen.getByText('Usuários')).toBeInTheDocument());
+  });
+
+  it('exibe lista de usuários após carregar', async () => {
+    renderUsuarios();
+    await waitFor(() => {
+      expect(screen.getByText('João Silva')).toBeInTheDocument();
+      expect(screen.getByText('Maria Coord')).toBeInTheDocument();
+      expect(screen.getByText('Admin User')).toBeInTheDocument();
+    });
+  });
+
+  it('exibe perfil label dos usuários', async () => {
+    renderUsuarios();
+    await waitFor(() => {
+      expect(screen.getByText('Estudante')).toBeInTheDocument();
+      expect(screen.getByText('Coordenador')).toBeInTheDocument();
+      expect(screen.getByText('Administrador')).toBeInTheDocument();
+    });
+  });
+
+  it('exibe badge Inativo para usuário inativo', async () => {
+    renderUsuarios();
+    await waitFor(() => expect(screen.getByText('Inativo')).toBeInTheDocument());
+  });
+
+  it('exibe estado de carregamento', () => {
+    mockUsuariosService.listar.mockReturnValue(new Promise(() => {}));
+    renderUsuarios();
+    expect(screen.getByText('Carregando usuários...')).toBeInTheDocument();
+  });
+
+  it('exibe mensagem quando não há usuários', async () => {
+    mockUsuariosService.listar.mockResolvedValue([]);
+    renderUsuarios();
+    await waitFor(() =>
+      expect(screen.getByText('Nenhum usuário cadastrado.')).toBeInTheDocument(),
+    );
+  });
+
+  it('exibe matrícula do estudante', async () => {
+    renderUsuarios();
+    await waitFor(() => expect(screen.getByText('Matrícula: 2021001')).toBeInTheDocument());
+  });
+
+  it('exibe CPF quando disponível', async () => {
+    renderUsuarios();
+    await waitFor(() => expect(screen.getByText('CPF: 000.000.000-00')).toBeInTheDocument());
+  });
+
+  it('exibe endereço quando disponível', async () => {
+    renderUsuarios();
+    await waitFor(() => expect(screen.getByText('Rua A, 123')).toBeInTheDocument());
+  });
+
+  it('exibe iniciais no avatar', async () => {
+    renderUsuarios();
+    await waitFor(() => expect(screen.getByText('JS')).toBeInTheDocument());
+  });
+
+  it('exibe nome da instituição', async () => {
+    renderUsuarios();
+    await waitFor(() => expect(screen.getAllByText('UFSC').length).toBeGreaterThan(0));
+  });
+
+  it('botão Novo usuário está presente', async () => {
+    renderUsuarios();
+    await waitFor(() => expect(screen.getByText('Novo usuário')).toBeInTheDocument());
+  });
+});
+
+describe('Usuarios — busca', () => {
+  it('filtra por nome', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getByText('João Silva'));
+    fireEvent.change(screen.getByPlaceholderText(/buscar por nome/i), { target: { value: 'Maria' } });
+    expect(screen.queryByText('João Silva')).not.toBeInTheDocument();
+    expect(screen.getByText('Maria Coord')).toBeInTheDocument();
+  });
+
+  it('filtra por e-mail', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getByText('João Silva'));
+    fireEvent.change(screen.getByPlaceholderText(/buscar por nome/i), { target: { value: 'admin@ufsc' } });
+    expect(screen.queryByText('João Silva')).not.toBeInTheDocument();
+    expect(screen.getByText('Admin User')).toBeInTheDocument();
+  });
+
+  it('filtra por matrícula', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getByText('João Silva'));
+    fireEvent.change(screen.getByPlaceholderText(/buscar por nome/i), { target: { value: '2021001' } });
+    expect(screen.getByText('João Silva')).toBeInTheDocument();
+    expect(screen.queryByText('Maria Coord')).not.toBeInTheDocument();
+  });
+
+  it('exibe mensagem quando busca não encontra nada', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getByText('João Silva'));
+    fireEvent.change(screen.getByPlaceholderText(/buscar por nome/i), { target: { value: 'xyzinexistente' } });
+    await waitFor(() =>
+      expect(screen.getByText('Nenhum usuário encontrado.')).toBeInTheDocument(),
+    );
+  });
+});
+
+describe('Usuarios — modal criar', () => {
+  it('abre modal ao clicar em Novo usuário', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getByText('Novo usuário'));
+    fireEvent.click(screen.getByText('Novo usuário'));
+    expect(screen.getByText('Criar usuário')).toBeInTheDocument();
+  });
+
+  it('exibe campo de senha inicial no modo criar', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getByText('Novo usuário'));
+    fireEvent.click(screen.getByText('Novo usuário'));
+    expect(screen.getByText('Senha inicial')).toBeInTheDocument();
+  });
+
+  it('fecha modal ao clicar em Cancelar', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getByText('Novo usuário'));
+    fireEvent.click(screen.getByText('Novo usuário'));
+    fireEvent.click(screen.getByText('Cancelar'));
+    expect(screen.queryByText('Criar usuário')).not.toBeInTheDocument();
+  });
+
+  it('não chama criar quando nome está vazio', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getByText('Novo usuário'));
+    fireEvent.click(screen.getByText('Novo usuário'));
+    fireEvent.click(screen.getByText('Criar usuário'));
+    expect(mockUsuariosService.criar).not.toHaveBeenCalled();
+  });
+
+  it('não chama criar quando senha tem menos de 6 caracteres', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getByText('Novo usuário'));
+    fireEvent.click(screen.getByText('Novo usuário'));
+
+    fireEvent.change(screen.getByPlaceholderText('Nome completo'), { target: { value: 'Novo User' } });
+    fireEvent.change(screen.getByPlaceholderText('email@instituicao.edu.br'), {
+      target: { value: 'novo@ufsc.br' },
+    });
+    fireEvent.change(screen.getByPlaceholderText('Mínimo 6 caracteres'), { target: { value: '123' } });
+    fireEvent.click(screen.getByText('Criar usuário'));
+    expect(mockUsuariosService.criar).not.toHaveBeenCalled();
+  });
+
+  it('chama usuariosService.criar com dados válidos', async () => {
+    mockUsuariosService.criar.mockResolvedValue({ id: 'u-4' });
+    renderUsuarios();
+    await waitFor(() => screen.getByText('Novo usuário'));
+    fireEvent.click(screen.getByText('Novo usuário'));
+
+    fireEvent.change(screen.getByPlaceholderText('Nome completo'), { target: { value: 'Novo Usuário' } });
+    fireEvent.change(screen.getByPlaceholderText('email@instituicao.edu.br'), {
+      target: { value: 'novo@ufsc.br' },
+    });
+    fireEvent.change(screen.getByPlaceholderText('Mínimo 6 caracteres'), {
+      target: { value: 'senha123' },
+    });
+    fireEvent.click(screen.getByText('Criar usuário'));
+    await waitFor(() => expect(mockUsuariosService.criar).toHaveBeenCalled());
+  });
+
+  it('exibe campo de matrícula quando perfil é estudante', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getByText('Novo usuário'));
+    fireEvent.click(screen.getByText('Novo usuário'));
+    expect(screen.getByPlaceholderText('Número de matrícula')).toBeInTheDocument();
+  });
+
+  it('exibe campo de CPF quando perfil é coordenador', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getByText('Novo usuário'));
+    fireEvent.click(screen.getByText('Novo usuário'));
+
+    const selectPerfil = screen.getByDisplayValue('Estudante');
+    fireEvent.change(selectPerfil, { target: { value: 'coordenador' } });
+    expect(screen.getByPlaceholderText('000.000.000-00')).toBeInTheDocument();
+  });
+
+  it('exibe campo de endereço quando perfil é coordenador', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getByText('Novo usuário'));
+    fireEvent.click(screen.getByText('Novo usuário'));
+
+    const selectPerfil = screen.getByDisplayValue('Estudante');
+    fireEvent.change(selectPerfil, { target: { value: 'coordenador' } });
+    expect(screen.getByPlaceholderText(/Rua, número, bairro/i)).toBeInTheDocument();
+  });
+
+  it('não exibe CPF quando perfil é admin', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getByText('Novo usuário'));
+    fireEvent.click(screen.getByText('Novo usuário'));
+
+    const selectPerfil = screen.getByDisplayValue('Estudante');
+    fireEvent.change(selectPerfil, { target: { value: 'admin' } });
+    expect(screen.queryByPlaceholderText('000.000.000-00')).not.toBeInTheDocument();
+  });
+
+  it('exibe cursos agrupados por instituição no select', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getByText('Novo usuário'));
+    fireEvent.click(screen.getByText('Novo usuário'));
+    const optgroup = document.querySelector('optgroup[label="UFSC"]');
+    expect(optgroup).toBeTruthy();
+  });
+});
+
+describe('Usuarios — modal editar', () => {
+  it('abre modal de edição ao clicar em Editar', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    expect(screen.getByText('Salvar')).toBeInTheDocument();
+  });
+
+  it('preenche modal com dados do usuário', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    expect(screen.getByDisplayValue('João Silva')).toBeInTheDocument();
+    expect(screen.getByDisplayValue('joao@ufsc.br')).toBeInTheDocument();
+  });
+
+  it('não exibe campo de senha no modo edição', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    expect(screen.queryByText('Senha inicial')).not.toBeInTheDocument();
+  });
+
+  it('fecha modal de edição ao clicar em Cancelar', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    fireEvent.click(screen.getByText('Cancelar'));
+    expect(screen.queryByText('Salvar')).not.toBeInTheDocument();
+  });
+
+  it('chama usuariosService.atualizar ao salvar edição válida', async () => {
+    mockUsuariosService.atualizar.mockResolvedValue({ id: 'u-1' });
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    fireEvent.click(screen.getByText('Salvar'));
+    await waitFor(() =>
+      expect(mockUsuariosService.atualizar).toHaveBeenCalledWith(
+        'u-1',
+        expect.objectContaining({ nome: 'João Silva' }),
+      ),
+    );
+  });
+
+  it('não chama atualizar quando nome é apagado', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    fireEvent.change(screen.getByDisplayValue('João Silva'), { target: { value: '' } });
+    fireEvent.click(screen.getByText('Salvar'));
+    expect(mockUsuariosService.atualizar).not.toHaveBeenCalled();
+  });
+
+  it('não chama atualizar quando e-mail é inválido', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    fireEvent.change(screen.getByDisplayValue('joao@ufsc.br'), {
+      target: { value: 'emailsemarrobase' },
+    });
+    fireEvent.click(screen.getByText('Salvar'));
+    expect(mockUsuariosService.atualizar).not.toHaveBeenCalled();
+  });
+});
+
+describe('Usuarios — alterar ativo', () => {
+  it('chama usuariosService.alterarAtivo ao desativar usuário ativo', async () => {
+    mockUsuariosService.alterarAtivo.mockResolvedValue({ id: 'u-1', ativo: false });
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Desativar'));
+    fireEvent.click(screen.getAllByText('Desativar')[0]);
+    await waitFor(() =>
+      expect(mockUsuariosService.alterarAtivo).toHaveBeenCalledWith('u-1', false),
+    );
+  });
+
+  it('chama usuariosService.alterarAtivo ao ativar usuário inativo', async () => {
+    mockUsuariosService.alterarAtivo.mockResolvedValue({ id: 'u-2', ativo: true });
+    renderUsuarios();
+    await waitFor(() => screen.getByText('Ativar'));
+    fireEvent.click(screen.getByText('Ativar'));
+    await waitFor(() =>
+      expect(mockUsuariosService.alterarAtivo).toHaveBeenCalledWith('u-2', true),
+    );
+  });
+});
+
+describe('Usuarios — erros de mutation', () => {
+  it('exibe erro personalizado da API ao falhar criação', async () => {
+    mockUsuariosService.criar.mockRejectedValue({
+      response: { data: { erro: 'E-mail já cadastrado' } },
+    });
+    renderUsuarios();
+    await waitFor(() => screen.getByText('Novo usuário'));
+    fireEvent.click(screen.getByText('Novo usuário'));
+
+    fireEvent.change(screen.getByPlaceholderText('Nome completo'), { target: { value: 'Duplicado' } });
+    fireEvent.change(screen.getByPlaceholderText('email@instituicao.edu.br'), {
+      target: { value: 'dup@ufsc.br' },
+    });
+    fireEvent.change(screen.getByPlaceholderText('Mínimo 6 caracteres'), {
+      target: { value: 'senha123' },
+    });
+    fireEvent.click(screen.getByText('Criar usuário'));
+    await waitFor(() => expect(mockUsuariosService.criar).toHaveBeenCalled());
+  });
+
+  it('exibe mensagem genérica ao falhar criação sem detalhe da API', async () => {
+    mockUsuariosService.criar.mockRejectedValue(new Error('Network error'));
+    renderUsuarios();
+    await waitFor(() => screen.getByText('Novo usuário'));
+    fireEvent.click(screen.getByText('Novo usuário'));
+
+    fireEvent.change(screen.getByPlaceholderText('Nome completo'), { target: { value: 'Novo User' } });
+    fireEvent.change(screen.getByPlaceholderText('email@instituicao.edu.br'), {
+      target: { value: 'novo@ufsc.br' },
+    });
+    fireEvent.change(screen.getByPlaceholderText('Mínimo 6 caracteres'), {
+      target: { value: 'senha123' },
+    });
+    fireEvent.click(screen.getByText('Criar usuário'));
+    await waitFor(() => expect(mockUsuariosService.criar).toHaveBeenCalled());
+  });
+
+  it('exibe erro personalizado da API ao falhar atualização', async () => {
+    mockUsuariosService.atualizar.mockRejectedValue({
+      response: { data: { erro: 'E-mail em uso' } },
+    });
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    fireEvent.click(screen.getByText('Salvar'));
+    await waitFor(() => expect(mockUsuariosService.atualizar).toHaveBeenCalled());
+  });
+
+  it('exibe erro genérico ao falhar atualização', async () => {
+    mockUsuariosService.atualizar.mockRejectedValue(new Error('fail'));
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    fireEvent.click(screen.getByText('Salvar'));
+    await waitFor(() => expect(mockUsuariosService.atualizar).toHaveBeenCalled());
+  });
+
+  it('exibe erro ao falhar alteração de status', async () => {
+    mockUsuariosService.alterarAtivo.mockRejectedValue(new Error('fail'));
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Desativar'));
+    fireEvent.click(screen.getAllByText('Desativar')[0]);
+    await waitFor(() => expect(mockUsuariosService.alterarAtivo).toHaveBeenCalled());
+  });
+});
+
+describe('Usuarios — editar admin (sem cpf/endereço)', () => {
+  it('salva edição de admin sem cpf, endereço e matrícula', async () => {
+    mockUsuariosService.atualizar.mockResolvedValue({ id: 'u-3' });
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[2]); // Admin User (índice 2)
+    fireEvent.click(screen.getByText('Salvar'));
+    await waitFor(() =>
+      expect(mockUsuariosService.atualizar).toHaveBeenCalledWith(
+        'u-3',
+        expect.objectContaining({ perfil: 'admin', cpf: null, endereco: null, curso_id: null }),
+      ),
+    );
+  });
+});
+
+describe('Usuarios — editar campos opcionais', () => {
+  it('permite alterar curso no select do modal de edição', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+
+    // O select de curso tem a opção "Sem curso vinculado" + cursos
+    const courseSelect = screen.getByDisplayValue(/\[CC-001\]/);
+    fireEvent.change(courseSelect, { target: { value: '' } });
+    expect(screen.queryByDisplayValue(/\[CC-001\]/)).not.toBeInTheDocument();
+  });
+
+  it('permite alterar matrícula no modal de edição (estudante)', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    const matricula = screen.getByDisplayValue('2021001');
+    fireEvent.change(matricula, { target: { value: '2022999' } });
+    expect(screen.getByDisplayValue('2022999')).toBeInTheDocument();
+  });
+
+  it('permite alterar endereço no modal de edição (estudante)', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    const endereco = screen.getByDisplayValue('Rua A, 123');
+    fireEvent.change(endereco, { target: { value: 'Rua B, 456' } });
+    expect(screen.getByDisplayValue('Rua B, 456')).toBeInTheDocument();
+  });
+});
+
+describe('Usuarios — formatação de CPF', () => {
+  it('formata CPF com 4 dígitos (d.length <= 6)', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    const cpf = screen.getByDisplayValue('000.000.000-00');
+    fireEvent.change(cpf, { target: { value: '1234' } });
+    expect(cpf).toHaveValue('123.4');
+  });
+
+  it('formata CPF com 7 dígitos (d.length <= 9)', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    const cpf = screen.getByDisplayValue('000.000.000-00');
+    fireEvent.change(cpf, { target: { value: '1234567' } });
+    expect(cpf).toHaveValue('123.456.7');
+  });
+
+  it('formata CPF com 3 dígitos ou menos (retorna direto)', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    const cpf = screen.getByDisplayValue('000.000.000-00');
+    fireEvent.change(cpf, { target: { value: '12' } });
+    expect(cpf).toHaveValue('12');
+  });
+
+  it('formata CPF completo com 11 dígitos', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+    const cpf = screen.getByDisplayValue('000.000.000-00');
+    fireEvent.change(cpf, { target: { value: '12345678901' } });
+    expect(cpf).toHaveValue('123.456.789-01');
+  });
+});
+
+describe('Usuarios — fechar modal pelo botão ×', () => {
+  it('fecha modal de criação pelo botão × do cabeçalho', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getByText('Novo usuário'));
+    fireEvent.click(screen.getByText('Novo usuário'));
+
+    const overlay = document.querySelector('.fixed.inset-0');
+    const closeBtn = overlay?.querySelector('button');
+    expect(closeBtn).toBeTruthy();
+    fireEvent.click(closeBtn!);
+    expect(screen.queryByText('Criar usuário')).not.toBeInTheDocument();
+  });
+
+  it('fecha modal de edição pelo botão × do cabeçalho', async () => {
+    renderUsuarios();
+    await waitFor(() => screen.getAllByText('Editar'));
+    fireEvent.click(screen.getAllByText('Editar')[0]);
+
+    const overlay = document.querySelector('.fixed.inset-0');
+    const closeBtn = overlay?.querySelector('button');
+    expect(closeBtn).toBeTruthy();
+    fireEvent.click(closeBtn!);
+    expect(screen.queryByText('Salvar')).not.toBeInTheDocument();
+  });
+});
diff --git a/frontend/src/test/pages/Verificar.test.tsx b/frontend/src/test/pages/Verificar.test.tsx
index a1bf34f..166e6b0 100644
--- a/frontend/src/test/pages/Verificar.test.tsx
+++ b/frontend/src/test/pages/Verificar.test.tsx
@@ -1,19 +1,23 @@
-import { describe, it, expect, vi } from 'vitest';
-import { screen } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { screen, waitFor } from '@testing-library/react';
 import { render } from '@testing-library/react';
 import { MemoryRouter, Routes, Route } from 'react-router-dom';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { Verificar } from '../../pages/Verificar';
+import axios from 'axios';
 
 vi.mock('axios', () => ({
   default: {
-    get: vi.fn().mockRejectedValue({ isAxiosError: true, response: { status: 404 } }),
-    isAxiosError: vi.fn().mockReturnValue(true),
+    get: vi.fn(),
+    isAxiosError: vi.fn(),
+    create: vi.fn(),
   },
 }));
 
+const mockAxios = vi.mocked(axios);
+
 function renderVerificar(hash?: string) {
-  const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  const qc = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: 0 } } });
   return render(
     <QueryClientProvider client={qc}>
       <MemoryRouter initialEntries={[hash ? `/verificar/${hash}` : '/verificar']}>
@@ -26,14 +30,93 @@ function renderVerificar(hash?: string) {
   );
 }
 
-describe('Verificar', () => {
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockAxios.isAxiosError.mockReturnValue(false);
+});
+
+describe('Verificar — estados da página', () => {
   it('renderiza o cabeçalho da página', () => {
+    mockAxios.get.mockReturnValue(new Promise(() => {}));
     renderVerificar('abc123');
     expect(screen.getByText(/Valida/i)).toBeInTheDocument();
   });
 
   it('exibe texto de verificação de certificado', () => {
+    mockAxios.get.mockReturnValue(new Promise(() => {}));
     renderVerificar('abc123');
     expect(screen.getByText(/Verificação de Certificado/i)).toBeInTheDocument();
   });
+
+  it('exibe estado de carregamento enquanto verifica', () => {
+    mockAxios.get.mockReturnValue(new Promise(() => {}));
+    renderVerificar('abc123');
+    expect(screen.getByText('Verificando certificado...')).toBeInTheDocument();
+  });
+
+  it('exibe certificado inválido quando hash não encontrado (404)', async () => {
+    const err = { response: { status: 404 } };
+    mockAxios.get.mockRejectedValue(err);
+    mockAxios.isAxiosError.mockReturnValue(true);
+    renderVerificar('hash-invalido');
+    await waitFor(() =>
+      expect(screen.getByText('Certificado Inválido')).toBeInTheDocument(),
+    );
+  });
+
+  it('exibe erro genérico para falhas que não sejam 404', async () => {
+    const err = { response: { status: 500 } };
+    mockAxios.get.mockRejectedValue(err);
+    mockAxios.isAxiosError.mockReturnValue(true);
+    renderVerificar('hash-erro');
+    await waitFor(() =>
+      expect(screen.getByText(/Erro ao verificar/i)).toBeInTheDocument(),
+    );
+  });
+
+  it('exibe erro genérico quando não é erro do axios', async () => {
+    mockAxios.get.mockRejectedValue(new Error('Network error'));
+    mockAxios.isAxiosError.mockReturnValue(false);
+    renderVerificar('hash-rede');
+    await waitFor(() =>
+      expect(screen.getByText(/Erro ao verificar/i)).toBeInTheDocument(),
+    );
+  });
+
+  it('exibe certificado válido com dados do estudante e documento', async () => {
+    const dados = {
+      valido: true,
+      certificado: { id: 'cert-1', hash: 'abc123hash', emitido_em: '2024-01-15T10:00:00Z' },
+      estudante: { nome: 'João Silva', email: 'joao@ufsc.br' },
+      documento: { titulo: 'Certificado de Curso', tipo: 'certificado_curso', carga_horaria: 40, status: 'aprovado' },
+    };
+    mockAxios.get.mockResolvedValue({ data: dados });
+    renderVerificar('abc123hash');
+    await waitFor(() =>
+      expect(screen.getByText('Certificado Válido')).toBeInTheDocument(),
+    );
+    expect(screen.getByText('João Silva')).toBeInTheDocument();
+    expect(screen.getByText('joao@ufsc.br')).toBeInTheDocument();
+    expect(screen.getByText('Certificado de Curso')).toBeInTheDocument();
+    expect(screen.getByText('abc123hash')).toBeInTheDocument();
+  });
+
+  it('exibe tipo de documento legível quando disponível no mapa', async () => {
+    const dados = {
+      valido: true,
+      certificado: { id: 'cert-2', hash: 'xyz456', emitido_em: '2024-03-01T00:00:00Z' },
+      estudante: { nome: 'Maria', email: 'maria@ufsc.br' },
+      documento: { titulo: 'TCC Final', tipo: 'artigo_publicado', carga_horaria: 60, status: 'aprovado' },
+    };
+    mockAxios.get.mockResolvedValue({ data: dados });
+    renderVerificar('xyz456');
+    await waitFor(() =>
+      expect(screen.getByText('Artigo Publicado · 60h')).toBeInTheDocument(),
+    );
+  });
+
+  it('não executa a query quando hash está ausente', () => {
+    renderVerificar();
+    expect(mockAxios.get).not.toHaveBeenCalled();
+  });
 });
diff --git a/frontend/src/test/services/api.test.ts b/frontend/src/test/services/api.test.ts
new file mode 100644
index 0000000..307d849
--- /dev/null
+++ b/frontend/src/test/services/api.test.ts
@@ -0,0 +1,94 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Testa os interceptors do axios diretamente sem mockar o módulo api
+// O queryClient precisa ser mockado para evitar imports circulares
+vi.mock('../../lib/queryClient', () => ({
+  queryClient: { clear: vi.fn() },
+}));
+
+describe('api interceptors', () => {
+  beforeEach(() => {
+    localStorage.clear();
+    vi.stubGlobal('location', { replace: vi.fn() });
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('adiciona header Authorization quando token existe no localStorage', async () => {
+    localStorage.setItem('token', 'meu-token-123');
+    const { default: api } = await import('../../services/api');
+
+    // Pega o handler do request interceptor e executa diretamente
+    const handlers = (api.interceptors.request as unknown as {
+      handlers: Array<{ fulfilled: (c: unknown) => unknown }>;
+    }).handlers;
+    const handler = handlers[handlers.length - 1]?.fulfilled;
+    expect(handler).toBeDefined();
+
+    const fakeConfig = { headers: {} as Record<string, string> };
+    const result = handler(fakeConfig) as typeof fakeConfig;
+    expect(result.headers.Authorization).toBe('Bearer meu-token-123');
+  });
+
+  it('não adiciona header Authorization quando token não existe', async () => {
+    const { default: api } = await import('../../services/api');
+
+    const handlers = (api.interceptors.request as unknown as {
+      handlers: Array<{ fulfilled: (c: unknown) => unknown }>;
+    }).handlers;
+    const handler = handlers[handlers.length - 1]?.fulfilled;
+
+    const fakeConfig = { headers: {} as Record<string, string> };
+    const result = handler(fakeConfig) as typeof fakeConfig;
+    expect(result.headers.Authorization).toBeUndefined();
+  });
+
+  it('limpa token e redireciona ao receber 401', async () => {
+    localStorage.setItem('token', 'tok');
+    localStorage.setItem('usuario', '{}');
+    const { default: api } = await import('../../services/api');
+    const { queryClient } = await import('../../lib/queryClient');
+
+    const responseHandlers = (api.interceptors.response as unknown as {
+      handlers: Array<{ rejected: (e: unknown) => unknown }>;
+    }).handlers;
+    const errorHandler = responseHandlers[responseHandlers.length - 1]?.rejected;
+    expect(errorHandler).toBeDefined();
+
+    await expect(errorHandler({ response: { status: 401 } })).rejects.toBeTruthy();
+    expect(queryClient.clear).toHaveBeenCalled();
+    expect(localStorage.getItem('token')).toBeNull();
+    expect(localStorage.getItem('usuario')).toBeNull();
+  });
+
+  it('rejeita o erro sem redirecionar para status diferente de 401', async () => {
+    const { default: api } = await import('../../services/api');
+
+    const responseHandlers = (api.interceptors.response as unknown as {
+      handlers: Array<{ rejected: (e: unknown) => unknown }>;
+    }).handlers;
+    const errorHandler = responseHandlers[responseHandlers.length - 1]?.rejected;
+
+    await expect(errorHandler({ response: { status: 500 } })).rejects.toMatchObject({
+      response: { status: 500 },
+    });
+    expect(globalThis.location.replace).not.toHaveBeenCalled();
+  });
+
+  it('rejeita sem redirecionar quando erro não tem response (ex: network error)', async () => {
+    const { default: api } = await import('../../services/api');
+
+    const responseHandlers = (api.interceptors.response as unknown as {
+      handlers: Array<{ rejected: (e: unknown) => unknown }>;
+    }).handlers;
+    const errorHandler = responseHandlers[responseHandlers.length - 1]?.rejected;
+
+    // Erro sem response (timeout, CORS, etc.)
+    await expect(errorHandler({ message: 'Network Error' })).rejects.toMatchObject({
+      message: 'Network Error',
+    });
+    expect(globalThis.location.replace).not.toHaveBeenCalled();
+  });
+});
diff --git a/frontend/src/test/services/documentos.test.ts b/frontend/src/test/services/documentos.test.ts
index a0a3942..f17e054 100644
--- a/frontend/src/test/services/documentos.test.ts
+++ b/frontend/src/test/services/documentos.test.ts
@@ -18,13 +18,37 @@ describe('documentosService.listar', () => {
     expect(resultado.total).toBe(1);
   });
 
-  it('passa filtros como query params', async () => {
+  it('passa filtros como query params (status e page)', async () => {
     mockApi.get.mockResolvedValueOnce({ data: { dados: [], total: 0 } });
     await documentosService.listar({ status: 'aprovado', page: 2 });
     expect(mockApi.get).toHaveBeenCalledWith('/api/documentos', {
       params: { status: 'aprovado', page: 2 },
     });
   });
+
+  it('passa filtro de tipo', async () => {
+    mockApi.get.mockResolvedValueOnce({ data: { dados: [], total: 0 } });
+    await documentosService.listar({ tipo: 'certificado_curso' });
+    expect(mockApi.get).toHaveBeenCalledWith('/api/documentos', {
+      params: { tipo: 'certificado_curso' },
+    });
+  });
+
+  it('passa filtro de estudante_id', async () => {
+    mockApi.get.mockResolvedValueOnce({ data: { dados: [], total: 0 } });
+    await documentosService.listar({ estudante_id: 'u-1' });
+    expect(mockApi.get).toHaveBeenCalledWith('/api/documentos', {
+      params: { estudante_id: 'u-1' },
+    });
+  });
+
+  it('passa filtro de limite', async () => {
+    mockApi.get.mockResolvedValueOnce({ data: { dados: [], total: 0 } });
+    await documentosService.listar({ limite: 10 });
+    expect(mockApi.get).toHaveBeenCalledWith('/api/documentos', {
+      params: { limite: 10 },
+    });
+  });
 });
 
 describe('documentosService.buscarPorId', () => {
diff --git a/infra/migrations/003_update_tipo_documento_enum.sql b/infra/migrations/003_update_tipo_documento_enum.sql
new file mode 100644
index 0000000..3d747a5
--- /dev/null
+++ b/infra/migrations/003_update_tipo_documento_enum.sql
@@ -0,0 +1,39 @@
+-- Migration 003: Atualiza tipo_documento_enum para os novos tipos do sistema
+-- Execute em bancos existentes criados com o schema antigo (estagio, tcc, extensao, monitoria).
+-- Para instalações novas o banco.sql já contém os valores corretos.
+--
+-- Aplicar:
+--   psql -U postgres -d valida_db -f infra/migrations/003_update_tipo_documento_enum.sql
+
+BEGIN;
+
+-- Renomeia o tipo antigo para não conflitar
+ALTER TYPE tipo_documento_enum RENAME TO tipo_documento_enum_old;
+
+-- Cria o novo tipo com os valores corretos
+CREATE TYPE tipo_documento_enum AS ENUM (
+  'certificado_curso',
+  'certificado_evento',
+  'declaracao_participacao',
+  'comprovante_atividade',
+  'artigo_publicado',
+  'outro'
+);
+
+-- Migra a coluna: valores antigos são mapeados para 'outro'
+ALTER TABLE documentos
+  ALTER COLUMN tipo TYPE tipo_documento_enum
+  USING (
+    CASE tipo::text
+      WHEN 'estagio'   THEN 'outro'
+      WHEN 'tcc'       THEN 'outro'
+      WHEN 'extensao'  THEN 'outro'
+      WHEN 'monitoria' THEN 'outro'
+      ELSE tipo::text
+    END
+  )::tipo_documento_enum;
+
+-- Remove o tipo antigo
+DROP TYPE tipo_documento_enum_old;
+
+COMMIT;