aprimoração de ia

agents/arquiteto/skills/auditar-arquitetura-modulo/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: auditar-arquitetura-modulo
+description: >
+  Auditoria arquitetural de módulo: fronteiras, acoplamento, dependências
+  circulares, contratos de API e dívidas técnicas.
+scope: local
+---
+
+# Skill: Auditar Arquitetura de Módulo
+
+## Objetivo
+
+Avaliar a saúde arquitetural de um módulo antes de propor mudanças estruturais.
+
+## Etapas
+
+### 1. Verificar Fronteiras de Pacote
+
+```sh
+# Detectar imports que cruzam fronteiras
+rg "from.*-back" --include='*.ts' --include='*.vue' <modulo>-front/src/ -n
+rg "from.*-front" --include='*.ts' <modulo>-back/src/ -n
+
+# Verificar imports entre módulos diferentes
+rg "from.*<outro-modulo>" --include='*.ts' <modulo>/ -n
+```
+
+### 2. Verificar Acoplamento
+
+```sh
+# Contar imports por arquivo (alto = muito acoplado)
+fd "*.ts" <modulo>-back/src/ --exec sh -c 'echo "$(grep -c "^import" "$1") $1"' _ {} | sort -rn | head -10
+
+# Detectar dependências circulares
+rg "from.*\.\/" --include='*.ts' <modulo>/src/ -l | head -20
+```
+
+### 3. Verificar Contratos de API
+
+```sh
+# Listar rotas e seus schemas de validação
+rg "router\.(get|post|put|patch|delete)" --include='*.ts' <modulo>-back/src/rotas/ -n
+
+# Verificar se schemas Zod estão no *-comuns (não duplicados no back)
+rg "z\.object" --include='*.ts' <modulo>-back/src/ -l
+```
+
+### 4. Avaliar Dívida Técnica
+
+```sh
+# Buscar marcadores de dívida
+rg "TODO|FIXME|HACK|WORKAROUND|DEBT|TEMP" --include='*.ts' --include='*.vue' <modulo>/ -n
+
+# Verificar limite de linhas
+fd "*.ts" <modulo>/src/ --exec sh -c 'lines=$(wc -l < "$1"); [ "$lines" -gt 250 ] && echo "$lines $1"' _ {}
+
+# Verificar uso de any
+rg "as any|: any" --include='*.ts' <modulo>/ -c
+```
+
+### 5. Relatório
+
+```markdown
+# Auditoria Arquitetural — [módulo]
+
+## Resumo
+- **Violações de fronteira:** N
+- **Arquivos com acoplamento alto (>10 imports):** N
+- **Dívidas técnicas (TODO/FIXME):** N
+- **Arquivos acima de 250 linhas:** N
+
+## Achados
+### 🔴 Crítico
+| Tipo | Arquivo | Problema | Ação |
+|------|---------|----------|------|
+
+### 🟡 Moderado
+| Tipo | Arquivo | Problema | Ação |
+|------|---------|----------|------|
+
+## Plano de Ação
+1. ...
+```
+
+## Referências
+
+- Rule: `global/rules/diagnostico-antes-correcao`
+- Rule: `global/rules/fronteiras-monorepo`
+- Skill: `global/skills/mapear-codigo-fonte/SKILL`

agents/back/skills/diagnosticar-saude-backend/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: diagnosticar-saude-backend
+description: >
+  Diagnóstico sistemático de saúde do backend: rotas, queries, schemas, filas,
+  CRONs e integrações antes de qualquer correção.
+scope: local
+---
+
+# Skill: Diagnosticar Saúde do Backend
+
+## Objetivo
+
+Analisar a saúde de um módulo backend para identificar problemas antes de corrigi-los. Produz relatório com causa raiz, severidade e plano de ação.
+
+## Pré-condições
+
+- Acesso ao pacote `*-back` do módulo
+- Acesso ao pacote `*-comuns` (schemas de contrato)
+
+## Etapas
+
+### 1. Verificar Integridade de Schemas
+
+```sh
+# Listar todos os schemas Zod do módulo
+rg "export const z" --include='*.ts' <modulo>-comuns/src/tabelas/ -l
+
+# Verificar se schemas do comuns são usados no back
+rg "from.*comuns" --include='*.ts' <modulo>-back/src/ | head -20
+
+# Detectar schemas redefinidos no back (violação de fronteiras)
+rg "z\.object\(\{" --include='*.ts' <modulo>-back/src/ -l
+```
+
+### 2. Verificar Consistência de Rotas
+
+```sh
+# Listar todas as rotas definidas
+rg "router\.(get|post|put|patch|delete)" --include='*.ts' <modulo>-back/src/ -n
+
+# Verificar validação de entrada em cada rota
+rg "zod|parse|safeParse" --include='*.ts' <modulo>-back/src/rotas/ -l
+
+# Detectar rotas sem validação Zod
+# (comparar lista de rotas vs lista de validações)
+```
+
+### 3. Verificar Saúde de Queries
+
+```sh
+# Detectar queries sem tratamento de erro
+rg "\.select\(|\.insert\(|\.update\(|\.delete\(" --include='*.ts' <modulo>-back/src/ -n
+
+# Detectar possíveis N+1 (query dentro de loop)
+rg "for.*await|forEach.*await|map.*await" --include='*.ts' <modulo>-back/src/ -n
+
+# Verificar transações (queries que deveriam ser atômicas)
+rg "\.transaction\(" --include='*.ts' <modulo>-back/src/ -l
+```
+
+### 4. Verificar Filas e CRONs
+
+```sh
+# Listar processadores de fila
+rg "process|worker|queue" --include='*.ts' <modulo>-back/src/filas/ -l
+
+# Verificar tratamento de falha em filas
+rg "catch|onFailed|failedReason" --include='*.ts' <modulo>-back/src/filas/ -n
+
+# Listar CRONs agendados
+rg "cron|schedule|repeat" --include='*.ts' <modulo>-back/src/ -n
+```
+
+### 5. Verificar Tipagem e Build
+
+```sh
+# Checar tipos sem gerar saída
+npx tsc --noEmit -p <modulo>-back/tsconfig.json 2>&1 | head -30
+
+# Detectar uso de any
+rg "as any|: any" --include='*.ts' <modulo>-back/src/ -n
+```
+
+### 6. Gerar Relatório
+
+```markdown
+# Diagnóstico Backend — [nome do módulo]
+
+## Resumo
+- **Rotas analisadas:** N
+- **Schemas verificados:** N
+- **Problemas encontrados:** N
+
+## Problemas Detectados
+
+### 🔴 Crítico
+| Arquivo | Problema | Causa | Ação |
+|---------|----------|-------|------|
+
+### 🟡 Moderado
+| Arquivo | Problema | Causa | Ação |
+|---------|----------|-------|------|
+
+### 🟢 Baixo
+| Arquivo | Problema | Causa | Ação |
+|---------|----------|-------|------|
+
+## Plano de Correção (priorizado)
+1. ...
+2. ...
+```
+
+## Referências
+
+- Rule: `global/rules/diagnostico-antes-correcao`
+- Skill: `global/skills/diagnosticar-antes-corrigir/SKILL`
+- Rule: `global/rules/zod-validacao-padrao`

agents/deploy/skills/diagnosticar-saude-deploy/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: diagnosticar-saude-deploy
+description: >
+  Diagnóstico de saúde de deploy e infraestrutura: containers, variáveis
+  de ambiente, healthchecks, logs e estado dos serviços.
+scope: local
+---
+
+# Skill: Diagnosticar Saúde de Deploy
+
+## Objetivo
+
+Avaliar o estado de saúde da infraestrutura e pipelines de deploy antes de aplicar mudanças.
+
+## Etapas
+
+### 1. Verificar Estado dos Containers
+
+```sh
+# Listar containers ativos
+docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
+
+# Verificar logs recentes de erro
+docker logs --tail 50 <container> 2>&1 | grep -i "error\|fatal\|exception\|fail"
+
+# Verificar uso de recursos
+docker stats --no-stream
+```
+
+### 2. Verificar Variáveis de Ambiente
+
+```sh
+# Listar variáveis esperadas (schemas Zod de ambiente)
+rg "z\.Ambiente\|process\.env\." --include='*.ts' <modulo>-back/src/ -n
+
+# Verificar se há variáveis sem default ou validação
+rg "process\.env\." --include='*.ts' <modulo>-back/src/ -n | grep -v "z\.\|zod\|Ambiente"
+```
+
+### 3. Verificar Healthchecks
+
+```sh
+# Verificar endpoints de health
+rg "health\|alive\|ready" --include='*.ts' <modulo>-back/src/ -n
+
+# Verificar healthcheck no Docker
+rg "HEALTHCHECK" Dockerfile* docker-compose* -n
+```
+
+### 4. Verificar Build
+
+```sh
+# Testar build completo
+pnpm build 2>&1 | tail -20
+
+# Verificar migrations pendentes
+rg "migration\|migrate" --include='*.ts' <modulo>-migracao/src/ -l
+```
+
+### 5. Gerar Relatório
+
+```markdown
+# Diagnóstico de Deploy — [nome do módulo]
+
+## Resumo
+- **Containers:** N ativos / N esperados
+- **Healthchecks:** N configurados
+- **Variáveis de ambiente:** N validadas / N sem validação
+- **Build:** ✅ OK | ❌ Falha
+
+## Problemas Detectados
+
+### 🔴 Crítico
+| Área | Problema | Impacto | Ação |
+|------|----------|---------|------|
+
+### 🟡 Moderado
+| Área | Problema | Impacto | Ação |
+|------|----------|---------|------|
+
+## Plano de Ação
+1. ...
+```
+
+## Referências
+
+- Rule: `global/rules/diagnostico-antes-correcao`
+- Skill: `global/skills/diagnosticar-antes-corrigir/SKILL`

agents/documentacao/skills/diagnosticar-lacunas-documentacao/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: diagnosticar-lacunas-documentacao
+description: >
+  Diagnóstico de lacunas de documentação: funções sem JSDoc, módulos sem
+  regras de negócio documentadas, documentação desatualizada.
+scope: local
+---
+
+# Skill: Diagnosticar Lacunas de Documentação
+
+## Objetivo
+
+Identificar proativamente onde a documentação está ausente, incompleta ou desatualizada antes de criar ou corrigir documentação.
+
+## Etapas
+
+### 1. Verificar JSDoc em Funções Compartilhadas
+
+```sh
+# Listar funções exportadas sem JSDoc
+rg "^export (const|function|async function)" --include='*.ts' <modulo>-comuns/src/ -n | while read line; do
+  file=$(echo "$line" | cut -d: -f1)
+  lineno=$(echo "$line" | cut -d: -f2)
+  prev=$((lineno - 1))
+  if ! sed -n "${prev}p" "$file" | grep -q "*/"; then
+    echo "SEM JSDOC: $line"
+  fi
+done
+```
+
+### 2. Verificar Regras de Negócio Documentadas
+
+```sh
+# Listar módulos com lógica complexa
+rg "if.*&&|switch|\.length\s*>" --include='*.ts' <modulo>-back/src/servicos/ -c | awk -F: '$2>5' | sort -t: -k2 -rn
+
+# Verificar quais têm .regras-negocio.md
+fd ".regras-negocio.md" <modulo>/ -l
+
+# Detectar lógica complexa sem documentação de regras
+# (comparar os dois resultados acima)
+```
+
+### 3. Verificar Documentação de API
+
+```sh
+# Listar rotas sem comentário explicativo
+rg "router\.(get|post|put|patch|delete)" --include='*.ts' <modulo>-back/src/rotas/ -n
+
+# Verificar quais rotas têm JSDoc
+rg "/\*\*" --include='*.ts' <modulo>-back/src/rotas/ -c
+```
+
+### 4. Detectar Dessincronia Código ↔ Docs
+
+```sh
+# Buscar campos mencionados em .regras-negocio.md que não existem no código
+# (verificação manual por arquivo)
+
+# Buscar decisões técnicas que deveriam estar na Memória
+rg "DECISÃO|ADR|NOTA|IMPORTANTE" --include='*.ts' --include='*.md' <modulo>/ -n
+```
+
+### 5. Gerar Relatório
+
+```markdown
+# Diagnóstico de Documentação — [nome do módulo]
+
+## Resumo
+- **Funções compartilhadas sem JSDoc:** N
+- **Módulos complexos sem .regras-negocio.md:** N
+- **Rotas sem documentação:** N
+
+## Lacunas Encontradas
+
+### 🔴 Crítico — Lógica Complexa Não Documentada
+| Arquivo | Complexidade | O que documentar |
+|---------|-------------|-----------------|
+
+### 🟡 Moderado — JSDoc Ausente
+| Arquivo | Função | Tipo |
+|---------|--------|------|
+
+### 🟢 Baixo — Melhorias
+| Arquivo | O que melhorar |
+|---------|---------------|
+
+## Plano de Documentação (priorizado)
+1. ...
+```
+
+## Referências
+
+- Rule: `global/rules/diagnostico-antes-correcao`
+- Rule: `global/rules/jsdoc-padrao`
+- Rule: `global/rules/regras-negocio-md`

agents/front/skills/diagnosticar-saude-frontend/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: diagnosticar-saude-frontend
+description: >
+  Diagnóstico sistemático de saúde do frontend: componentes, composables,
+  estados de UI, acessibilidade e integração com API.
+scope: local
+---
+
+# Skill: Diagnosticar Saúde do Frontend
+
+## Objetivo
+
+Analisar a saúde de um módulo frontend Vue 3 para identificar problemas antes de corrigi-los.
+
+## Etapas
+
+### 1. Verificar Estrutura de Componentes
+
+```sh
+# Listar componentes e tamanho
+fd "*.vue" <modulo>-front/src/ --exec wc -l {} | sort -rn | head -20
+
+# Detectar componentes acima do limite (250 linhas)
+fd "*.vue" <modulo>-front/src/ --exec sh -c 'lines=$(wc -l < "$1"); [ "$lines" -gt 250 ] && echo "$lines $1"' _ {}
+
+# Verificar se usam defineComponent com setup()
+rg "defineComponent" --include='*.vue' <modulo>-front/src/ -l
+```
+
+### 2. Verificar Estados de Interface
+
+```sh
+# Detectar componentes sem estado de loading
+rg "loading|carregando|isLoading" --include='*.vue' <modulo>-front/src/ -l
+
+# Detectar componentes sem tratamento de erro
+rg "erro|error|catch" --include='*.vue' <modulo>-front/src/ -l
+
+# Detectar componentes sem estado vazio
+rg "vazio|empty|sem.*dados|nenhum" --include='*.vue' <modulo>-front/src/ -l
+```
+
+### 3. Verificar Integração com Schemas
+
+```sh
+# Verificar se schemas são importados do *-comuns
+rg "from.*comuns" --include='*.ts' --include='*.vue' <modulo>-front/src/ | head -20
+
+# Detectar schemas redefinidos no front (violação)
+rg "z\.object\(\{" --include='*.ts' --include='*.vue' <modulo>-front/src/ -l
+
+# Detectar uso de any
+rg "as any|: any" --include='*.ts' --include='*.vue' <modulo>-front/src/ -n
+```
+
+### 4. Verificar Composables
+
+```sh
+# Listar composables existentes
+fd "use*.ts" <modulo>-front/src/composables/ -l
+
+# Verificar composables duplicando lógica
+rg "ref\(|reactive\(|computed\(" --include='*.vue' <modulo>-front/src/ -c | sort -t: -k2 -rn | head -10
+```
+
+### 5. Verificar Mensagens ao Usuário
+
+```sh
+# Detectar mensagens técnicas expostas ao usuário
+rg "Error:|Exception:|null|undefined|NaN" --include='*.vue' <modulo>-front/src/ -n
+
+# Verificar se mensagens usam linguagem do domínio
+rg "snackbar\|toast\|notify\|mensagem\|alerta" --include='*.vue' --include='*.ts' <modulo>-front/src/ -n
+```
+
+### 6. Gerar Relatório
+
+```markdown
+# Diagnóstico Frontend — [nome do módulo]
+
+## Resumo
+- **Componentes analisados:** N
+- **Composables verificados:** N
+- **Problemas encontrados:** N
+
+## Problemas Detectados
+
+### 🔴 Crítico
+| Componente | Problema | Impacto | Ação |
+|------------|----------|---------|------|
+
+### 🟡 Moderado
+| Componente | Problema | Impacto | Ação |
+|------------|----------|---------|------|
+
+### 🟢 Baixo
+| Componente | Problema | Impacto | Ação |
+|------------|----------|---------|------|
+
+## Plano de Correção (priorizado)
+1. ...
+```
+
+## Referências
+
+- Rule: `global/rules/diagnostico-antes-correcao`
+- Skill: `global/skills/diagnosticar-antes-corrigir/SKILL`
+- Rule: `global/rules/estrutura-vue` (via front)

agents/refatorar/skills/diagnosticar-code-smells/SKILL.md

@@ -0,0 +1,145 @@
+---
+name: diagnosticar-code-smells
+description: >
+  Análise sistemática de código para identificar code smells, violações SOLID
+  e oportunidades de aplicação de Design Patterns GoF.
+scope: local
+---
+
+# Skill: Diagnosticar Code Smells
+
+## Objetivo
+
+Analisar um arquivo, módulo ou pacote para produzir um relatório de saúde estrutural com:
+- Code smells identificados
+- Violações SOLID detectadas
+- Design Patterns recomendados
+- Prioridade de cada refatoração
+
+## Pré-condições
+
+- Código existente para analisar (arquivo, pasta ou pacote)
+- Acesso de leitura ao código e seus testes
+
+## Etapas
+
+### 1. Coletar Contexto
+
+```sh
+# Identificar tamanho e estrutura
+wc -l <arquivo_ou_pasta>/**/*.ts
+wc -l <arquivo_ou_pasta>/**/*.vue
+
+# Verificar cobertura de testes
+find <pasta_testes> -name "*.spec.ts" -o -name "*.test.ts"
+```
+
+### 2. Verificar Smells de Volume
+
+Para cada arquivo, verificar:
+
+| Verificação | Comando/Ação |
+|-------------|-------------|
+| Linhas > 250 | `wc -l <arquivo>` |
+| Funções > 30 linhas | Ler e contar manualmente |
+| Parâmetros > 3 por função | `grep_search` por assinaturas |
+| Imports excessivos (> 10) | Contar linhas de import |
+
+### 3. Verificar Smells de Acoplamento
+
+| Verificação | Indicador |
+|-------------|-----------|
+| Feature Envy | Função usa `outro.` mais que `this.` ou dados locais |
+| Intimidade Inapropriada | Acesso a internos de outro módulo (não-exportados) |
+| Cadeia de Mensagens | `a.b.c.d` com 3+ níveis |
+| Import circular | Módulo A importa B que importa A |
+
+### 4. Verificar Conformidade SOLID
+
+Para cada princípio, aplicar o checklist:
+
+```
+□ S — Este arquivo tem apenas 1 razão para mudar?
+□ O — Posso adicionar nova variação sem editar este arquivo?
+□ L — Subtipos são substituíveis pelo tipo base?
+□ I — Interfaces são específicas para cada consumidor?
+□ D — Lógica de negócio depende de abstrações, não de implementações?
+```
+
+### 5. Mapear Oportunidades de Padrão
+
+Cruzar smells detectados com o guia de decisão:
+
+```
+switch crescente        → Strategy
+criação condicional     → Factory Method
+construção complexa     → Builder
+comportamento por estado → State
+pipeline de validações  → Chain of Responsibility
+comportamento adicional → Decorator
+interface incompatível  → Adapter
+subsistema complexo     → Facade
+notificação de mudanças → Observer
+```
+
+### 6. Gerar Relatório
+
+Produzir relatório no formato:
+
+```markdown
+# Diagnóstico de Code Smells — [nome do módulo]
+
+## Resumo
+- **Arquivos analisados:** N
+- **Smells encontrados:** N
+- **Violações SOLID:** N
+- **Padrões recomendados:** N
+
+## Smells Detectados
+
+### 🔴 Crítico
+| Arquivo | Smell | Linha(s) | Ação Recomendada |
+|---------|-------|----------|-----------------|
+
+### 🟡 Moderado
+| Arquivo | Smell | Linha(s) | Ação Recomendada |
+|---------|-------|----------|-----------------|
+
+### 🟢 Baixo
+| Arquivo | Smell | Linha(s) | Ação Recomendada |
+|---------|-------|----------|-----------------|
+
+## Violações SOLID
+| Princípio | Arquivo | Descrição | Severidade |
+|-----------|---------|-----------|------------|
+
+## Design Patterns Recomendados
+| Problema | Padrão | Justificativa | Esforço |
+|----------|--------|---------------|---------|
+
+## Plano de Ação (priorizado)
+1. [Crítico] ...
+2. [Crítico] ...
+3. [Moderado] ...
+```
+
+## Critérios de Severidade
+
+| Severidade | Critério |
+|------------|----------|
+| 🔴 Crítico | Violação SOLID + acoplamento alto + afeta 3+ arquivos |
+| 🟡 Moderado | Code smell isolado + afeta 1-2 arquivos |
+| 🟢 Baixo | Melhoria estética + sem impacto funcional |
+
+## Pós-condições
+
+- Relatório registrado na Memória Azteca (`./memory/`) ou entregue diretamente
+- Plano de ação priorizado gerado
+- `@testes` notificado sobre trechos sem cobertura
+
+## Referências
+
+- Persona: `agents/refatorar/persona`
+- Rule: `agents/refatorar/rules/solid-compliance`
+- Rule: `agents/refatorar/rules/design-patterns-pragmatico`
+- Refactoring.Guru — https://refactoring.guru/pt-br/refactoring/smells

agents/testes/skills/diagnosticar-cobertura-testes/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: diagnosticar-cobertura-testes
+description: >
+  Diagnóstico de cobertura de testes: identificar áreas sem cobertura,
+  priorizar criação de testes e mapear cenários ausentes.
+scope: local
+---
+
+# Skill: Diagnosticar Cobertura de Testes
+
+## Objetivo
+
+Mapear a cobertura de testes de um módulo para identificar gaps críticos antes de criar novos testes ou validar correções.
+
+## Etapas
+
+### 1. Inventariar Testes Existentes
+
+```sh
+# Listar arquivos de teste
+fd "*.spec.ts" <modulo>/ -l
+fd "*.test.ts" <modulo>/ -l
+
+# Contar testes por pacote
+echo "=== Back ===" && fd "*.spec.ts" <modulo>-back/ | wc -l
+echo "=== Front ===" && fd "*.spec.ts" <modulo>-front/ | wc -l
+echo "=== Comuns ===" && fd "*.spec.ts" <modulo>-comuns/ | wc -l
+```
+
+### 2. Mapear Código Sem Testes
+
+```sh
+# Listar arquivos de código sem arquivo de teste correspondente
+for f in $(fd "*.ts" <modulo>-back/src/ --exclude "*.spec.ts" --exclude "*.test.ts" --exclude "*.d.ts"); do
+  base=$(basename "$f" .ts)
+  if ! fd "${base}.spec.ts" <modulo>/ -q && ! fd "${base}.test.ts" <modulo>/ -q; then
+    echo "SEM TESTE: $f"
+  fi
+done
+```
+
+### 3. Classificar por Criticidade
+
+| Criticidade | O que testar primeiro |
+|-------------|----------------------|
+| 🔴 Crítico | Lógica de negócio em `servicos/`, schemas Zod, máquinas de estado |
+| 🟡 Importante | Rotas de API, processadores de fila, composables complexos |
+| 🟢 Desejável | Utils, helpers, componentes de UI puros |
+
+### 4. Verificar Qualidade dos Testes Existentes
+
+```sh
+# Detectar testes sem assertions
+rg "expect\(|assert\(|toBe\(|toEqual\(" --include='*.spec.ts' <modulo>/ -c | awk -F: '$2==0'
+
+# Detectar testes com descrições vagas
+rg "it\('" --include='*.spec.ts' <modulo>/ -n | grep -i "should work\|test\|funciona"
+
+# Verificar mocks sem documentação
+rg "mock\(|jest\.fn\(|vi\.fn\(" --include='*.spec.ts' <modulo>/ -n
+```
+
+### 5. Gerar Relatório
+
+```markdown
+# Diagnóstico de Cobertura — [nome do módulo]
+
+## Resumo
+- **Arquivos de código:** N
+- **Arquivos de teste:** N
+- **Cobertura estimada:** N%
+- **Gaps críticos:** N
+
+## Gaps de Cobertura
+
+### 🔴 Sem teste — Lógica Crítica
+| Arquivo | Responsabilidade | Risco |
+|---------|-----------------|-------|
+
+### 🟡 Sem teste — Funcionalidade Importante
+| Arquivo | Responsabilidade | Risco |
+|---------|-----------------|-------|
+
+## Testes Existentes com Problemas
+| Arquivo de Teste | Problema | Ação |
+|-----------------|----------|------|
+
+## Plano de Priorização
+1. [Crítico] Criar testes para ...
+2. [Crítico] Criar testes para ...
+3. [Importante] Criar testes para ...
+```
+
+## Referências
+
+- Rule: `global/rules/diagnostico-antes-correcao`
+- Skill: `global/skills/diagnosticar-antes-corrigir/SKILL`

agents/ux/skills/auditar-ux-heuristicas/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: auditar-ux-heuristicas
+description: >
+  Auditoria de UX baseada em heurísticas de Nielsen e verificação de estados de UI.
+scope: local
+---
+
+# Skill: Auditar UX por Heurísticas
+
+## Objetivo
+
+Avaliar UX de tela ou fluxo antes de propor mudanças.
+
+## Etapas
+
+### 1. Heurísticas de Nielsen
+
+| # | Heurística | Pergunta |
+|---|-----------|----------|
+| 1 | Visibilidade do status | Sistema informa o que acontece? |
+| 2 | Compatibilidade | Mensagens usam linguagem do domínio? |
+| 3 | Controle e liberdade | Pode desfazer, voltar, cancelar? |
+| 4 | Consistência | Mesmos conceitos, mesma aparência? |
+| 5 | Prevenção de erros | Campos obrigatórios claros? Confirmação em ações destrutivas? |
+| 6 | Reconhecimento > Lembrança | Labels descritivos? |
+| 7 | Flexibilidade | Ações frequentes acessíveis? |
+| 8 | Estética minimalista | Info desnecessária? |
+| 9 | Recuperação de erros | Mensagens orientam correção? |
+| 10 | Ajuda | Ajuda contextual disponível? |
+
+### 2. Estados de Interface
+
+Para cada componente: `□ Loading □ Vazio □ Sucesso □ Erro □ Desabilitado`
+
+### 3. Acessibilidade Básica
+
+```sh
+rg "<img" --include='*.vue' <modulo>-front/src/ -n | grep -v "alt="
+rg "<v-btn\|<button" --include='*.vue' <modulo>-front/src/ -n | grep -v "aria-label\|title"
+```
+
+### 4. Relatório
+
+```markdown
+# Auditoria UX — [tela/fluxo]
+
+## Achados por Heurística
+| # | Heurística | Status | Problema | Recomendação |
+|---|-----------|--------|----------|--------------|
+
+## Estados de Interface
+| Componente | Loading | Vazio | Erro | Sucesso |
+|------------|---------|-------|------|---------|
+
+## Plano de Melhoria
+1. ...
+```
+
+## Referências
+
+- Rule: `global/rules/diagnostico-antes-correcao`
+- Rule: `global/rules/mensagens-usuario`
+- Rule: `global/rules/feedback-visivel`