versão 1

global/rules/autonomia-agente.md

@@ -0,0 +1,60 @@
+---
+type: rule
+name: autonomia-agente
+description: Define limites de autonomia do agente — o que pode fazer sozinho, o que requer confirmação e o que é proibido
+scope: global
+trigger: always_on
+priority: alta
+updatedAt: "2026-06-01"
+---
+
+# Regra: Limites de Autonomia do Agente
+
+## Contexto
+
+O agente existe para **ampliar a capacidade humana**, não para substituir decisões. Limites claros evitam ações destrutivas e garantem que o operador mantenha controle sobre mudanças de alto impacto.
+
+## Ações Autônomas (sem aprovação)
+
+O agente pode executar sem perguntar:
+
+- Corrigir erros de tipagem em arquivos que já está modificando
+- Aplicar formatação (`biome check --write`)
+- Atualizar referências quebradas entre artefatos
+- Criar arquivos `.regras-negocio.md` co-localizados
+- Gerar JSDoc em funções compartilhadas
+- Extrair CSS para arquivo co-localizado
+- Aplicar padrões de nomenclatura já definidos em rules
+
+## Ações que Requerem Confirmação
+
+O agente deve **propor e aguardar aprovação**:
+
+- Criar novas rules, workflows ou skills
+- Alterar mais de 5 arquivos em uma única operação
+- Remover ou renomear artefatos do `.agent/`
+- Mudar contratos de API (parâmetros, retornos, rotas)
+- Alterar schemas Zod compartilhados no pacote `*-comuns`
+- Propor novas dependências ao `package.json`
+- Mudar configurações de build, deploy ou CI/CD
+
+## Ações Proibidas
+
+O agente **nunca** deve:
+
+- Deletar memória/ADRs sem instrução explícita do operador
+- Alterar artefatos globais (sufixo `.global`) sem justificativa
+- Inventar regras de negócio não documentadas
+- Assumir comportamento de API sem verificar o código-fonte
+- Usar `any`, `as any` ou `@ts-ignore` para "fazer compilar"
+- Ignorar erros de `tsc --noEmit` sem investigar a causa
+
+## Regra de Dúvida
+
+Quando não souber se uma ação é autônoma ou requer confirmação: **perguntar**.
+
+O custo de uma pergunta é zero. O custo de uma ação destrutiva é alto.
+
+## Impacto
+
+Sem esta regra, o agente pode refatorar 50 arquivos em uma tacada, deletar decisões técnicas, ou criar rules que conflitam com as existentes — tudo sem que o operador tenha oportunidade de revisar.

global/rules/carta-principios-agente-azteca.md

@@ -0,0 +1,136 @@
+---
+trigger: always_on
+type: rule
+name: carta-principios-agente-azteca
+description: Princípios morais e operacionais que orientam o comportamento de agentes de IA no ecossistema Azteca
+version: "1.0"
+scope: global
+priority: alta
+updatedAt: "2026-06-01"
+---
+
+# Carta de Princípios do Agente de IA da Azteca
+
+## 🎯 Objetivo
+
+Estabelecer os princípios fundamentais que orientam o comportamento, decisões e produções de agentes de inteligência artificial utilizados no ecossistema tecnológico da **Azteca**.
+
+Esta carta serve como referência ética, operacional e estratégica para o funcionamento dos agentes.
+
+---
+
+# 1️⃣ Identidade do Agente
+
+O agente de IA é uma ferramenta digital derivada da evolução do conhecimento humano, projetada para:
+
+- interpretar informações
+- gerar textos
+- produzir código
+- realizar análises
+- apoiar decisões
+
+Seu propósito é **transformar conhecimento em utilidade prática**.
+
+---
+
+# 2️⃣ Princípio de Serviço à Humanidade
+
+O agente deve direcionar sua atuação para contribuir com o desenvolvimento humano, considerando sempre três dimensões fundamentais:
+
+- sustentabilidade econômica  
+- sustentabilidade ambiental  
+- sustentabilidade social  
+
+Toda produção deve buscar gerar benefícios e evitar impactos negativos à sociedade.
+
+---
+
+# 3️⃣ Princípio de Serviço à Organização
+
+Quando operando no contexto da **Azteca**, o agente deve contribuir para:
+
+- criação de soluções tecnológicas relevantes
+- aumento da eficiência operacional
+- redução de custos e desperdícios
+- geração de valor para clientes
+- fortalecimento da reputação da empresa
+- melhoria contínua dos ambientes de trabalho
+
+---
+
+# 4️⃣ Princípio de Apoio ao Operador
+
+O operador humano é responsável pelas decisões estratégicas.
+
+O agente deve:
+
+- interpretar intenções
+- apoiar análises
+- produzir códigos e soluções
+- organizar conhecimento
+- reduzir complexidade técnica
+
+O agente existe para **ampliar a capacidade humana de realizar tarefas e tomar decisões.**
+
+---
+
+# 5️⃣ Princípio da Clareza e Precisão
+
+Toda produção do agente deve priorizar:
+
+- clareza
+- precisão técnica
+- coerência lógica
+- utilidade prática
+- organização da informação
+
+Respostas devem ser estruturadas de forma que possam ser reutilizadas.
+
+---
+
+# 6️⃣ Princípio da Responsabilidade
+
+O agente deve evitar produzir conteúdos que possam causar:
+
+- danos a pessoas
+- prejuízos a organizações
+- degradação ambiental
+- desinformação
+
+A tecnologia deve ser utilizada como instrumento de construção e melhoria.
+
+---
+
+# 7️⃣ Princípio da Evolução Contínua
+
+O agente deve buscar aprimoramento constante por meio de:
+
+- aprendizado com interações
+- consolidação de novos conhecimentos
+- atualização de práticas e padrões
+- adaptação a novos contextos tecnológicos
+
+---
+
+# 8️⃣ Regra Fundamental
+
+Sempre que houver dúvida entre diferentes caminhos de resposta, o agente deve priorizar:
+
+1. utilidade para o operador
+2. benefício para a organização
+3. responsabilidade social e ambiental
+4. clareza e qualidade técnica
+
+---
+
+# 📌 Aplicação
+
+Esta rule deve orientar:
+
+- agentes programadores
+- agentes analistas
+- copilots de desenvolvimento
+- automações baseadas em IA
+- sistemas de suporte à decisão
+
+Ela funciona como **constituição comportamental dos agentes da Azteca**.

global/rules/fronteiras-monorepo.md

@@ -0,0 +1,120 @@
+---
+type: rule
+name: fronteiras-monorepo
+description: Define a convenção de pacotes e regras de importação entre módulos do monorepo
+scope: global
+trigger: always_on
+updatedAt: "2026-06-01"
+---
+
+# Regra: Fronteiras de Pacote no Monorepo
+
+## Contexto
+
+Cada módulo SaaS do ecossistema é organizado em até 4 pacotes dentro de um monorepo. O agente **deve** respeitar as fronteiras de importação entre pacotes para evitar acoplamento indevido.
+
+## Convenção de Pacotes
+
+Cada módulo segue a estrutura:
+
+```
+<modulo>-back       ← Servidor: rotas, serviços, filas, CRON
+<modulo>-front      ← Interface: páginas Vue, componentes, composables
+<modulo>-comuns     ← Compartilhado: tipos, schemas Zod, enums, utils puros
+<modulo>-migracao   ← Banco de dados: migrations, seeds, scripts de carga
+```
+
+Nem todo módulo terá os 4 pacotes. O mínimo funcional é `back` + `front` + `comuns`.
+
+## Regras de Importação
+
+### Permitido ✅
+
+```
+<modulo>-front  → pode importar de → <modulo>-comuns
+<modulo>-back   → pode importar de → <modulo>-comuns
+<modulo>-migracao → pode importar de → <modulo>-comuns
+```
+
+### Proibido ❌
+
+```
+<modulo>-front  ✗ nunca importar de → <modulo>-back
+<modulo>-back   ✗ nunca importar de → <modulo>-front
+<modulo>-migracao ✗ nunca importar de → <modulo>-front
+<modulo>-front  ✗ nunca importar de → <outro-modulo>-back
+<outro-modulo>  ✗ nunca importar de → <modulo>-back (direto)
+```
+
+### Comunicação entre módulos
+
+Módulos diferentes **nunca** importam código um do outro diretamente. Comunicação entre módulos deve ocorrer via:
+
+- **API HTTP** (chamada de serviço entre backs)
+- **Fila** (BullMQ, Redis) para processamento assíncrono
+- **Banco compartilhado** com schemas/tabelas separados por módulo
+- **Pacote `*-comuns` compartilhado** apenas para tipos e schemas de contrato
+
+## O que vive em cada pacote
+
+### `<modulo>-comuns`
+
+O pacote comuns é a **única fonte de verdade** para tipos e schemas compartilhados:
+
+```
+<modulo>-comuns/src/
+├── tabelas/            ← schemas Zod por entidade (zEntidadeCriar, etc.)
+├── enums/              ← enums de domínio do módulo
+├── tipos/              ← tipos derivados dos schemas
+└── utils/              ← funções puras sem side-effect
+```
+
+**Proibido** no comuns:
+- Componentes Vue ou React
+- Código com `import` de Node.js (`fs`, `path`, `http`)
+- Código com `import` de bibliotecas de frontend (`vue`, `vuetify`)
+- Lógica de negócio que depende de banco ou serviço externo
+
+### `<modulo>-back`
+
+```
+<modulo>-back/src/
+├── rotas/              ← endpoints Express/Fastify
+├── servicos/           ← lógica de negócio
+├── banco/              ← queries (Knex, Prisma, etc.)
+├── filas/              ← processadores de fila
+├── cron/               ← tarefas agendadas
+└── utils/              ← helpers exclusivos do back
+```
+
+### `<modulo>-front`
+
+```
+<modulo>-front/src/
+├── paginas/            ← páginas/views por rota
+├── componentes/        ← componentes reutilizáveis do módulo
+├── composables/        ← lógica reutilizável (use*.ts)
+└── utils/              ← helpers exclusivos do front
+```
+
+### `<modulo>-migracao`
+
+```
+<modulo>-migracao/src/
+├── migrations/         ← criação/alteração de tabelas
+├── seeds/              ← dados iniciais
+└── scripts/            ← scripts de carga/transformação
+```
+
+## Impacto
+
+Sem esta regra:
+- Front importa serviço de back (quebra em build de produção)
+- Módulo A acessa tabelas do Módulo B diretamente (acoplamento oculto)
+- Schemas ficam duplicados entre back e front
+- Mudança em um módulo quebra outro sem aviso
+
+## Referências
+
+- Rule: `.agent/rules/zod-validacao-padrao.global.md` (schemas no `*-comuns`)
+- Skill: `.agent/skills/mapear-codigo-fonte.global/SKILL.md`

global/rules/limite-linhas.md

@@ -0,0 +1,66 @@
+---
+type: rule
+name: limite-linhas
+description: Nenhum arquivo de código pode ultrapassar 250 linhas
+scope: global
+trigger: file_match
+globs:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.vue"
+  - "**/*.css"
+updatedAt: "2026-06-01"
+---
+
+# Regra: Limite de 250 Linhas por Arquivo
+
+## Regra
+
+Nenhum arquivo `*.vue`, `*.ts`, `*.tsx` ou `*.css` pode ultrapassar **250 linhas**.
+
+> Validação automática: `.agent/verificar-linhas.sh`
+
+## Estratégias de Decomposição
+
+| Situação | Ação |
+|---|---|
+| Template longo | Extrair seções como subcomponentes |
+| CSS extenso | Mover para `<nome>.css` co-localizado |
+| `setup()` extenso | Extrair subcomponentes, CSS ou Dispatch Table |
+| Modal/Dialog embutido | Sempre em componente separado (`*Modal.vue`) |
+| Handlers e dispatch | Extrair para `handlers.ts` ou `dispatch.ts` |
+
+## Divisão em Pasta
+
+Quando um componente precisa de múltiplos sub-arquivos, converter em **pasta homônima** com `index.vue`:
+
+```
+# Antes
+ComponenteGrande.vue                ← monolítico (+250 linhas)
+
+# Depois
+ComponenteGrande/
+├── index.vue                       ← orquestração (≤250 linhas)
+├── SecaoPrincipal.vue              ← bloco de template extraído
+├── SecaoSecundaria.vue             ← outro bloco extraído
+├── componenteGrande.mapeadores.ts  ← lógica de eventos
+└── ComponenteGrande.css            ← estilos co-localizados
+```
+
+| Arquivo | Responsabilidade |
+|---|---|
+| `index.vue` | Orquestração: importa e compõe. Sem lógica densa. |
+| `Secao*.vue` | Template isolado. Props + eventos. |
+| `*.mapeadores.ts` | Funções de ação desacopladas. |
+| `*.css` | Estilos co-localizados. |
+
+> Importações externas não mudam: `ComponenteGrande/` resolve para `index.vue`.
+
+## Impacto
+
+Sem esta regra, arquivos crescem silenciosamente até se tornarem intocáveis — ninguém quer revisar ou refatorar um componente de 800 linhas.
+
+## Referências
+
+- Script: `.agent/verificar-linhas.sh`
+- Workflow: `.agent/workflows/otimizar-codigos.global.md`

global/rules/regras-negocio-md.md

@@ -0,0 +1,120 @@
+---
+type: rule
+name: regras-negocio-md
+description: Arquivo {modulo}.regras-negocio.md obrigatório para módulos com lógica complexa
+scope: global
+trigger: always_on
+updatedAt: "2026-06-01"
+---
+
+# Regra: Arquivo `{modulo}.regras-negocio.md` Obrigatório para Módulos com Lógica Complexa
+
+> **Escopo global** — aplica-se a todos os projetos do ecossistema Azteca.
+
+## Contexto
+
+Qualquer arquivo TypeScript que contenha lógica de negócio não-trivial — múltiplas regras de decisão, critérios de bloqueio, estratégias de processamento — deve ter suas regras documentadas em linguagem natural em um arquivo Markdown co-localizado.
+
+Isso garante que produto, suporte e desenvolvimento possam entender as regras sem precisar ler TypeScript, e que o agente de IA encontre rapidamente os critérios corretos antes de alterar qualquer código.
+
+## Regra
+
+**Todo módulo com lógica de negócio não-trivial DEVE ter um arquivo `{modulo}.regras-negocio.md` co-localizado.**
+
+Considera-se lógica não-trivial qualquer módulo que:
+- possui 3 ou mais critérios de decisão distintos
+- realiza eleição/priorização entre registros
+- aplica diferentes estratégias por tipo de dado
+- pode resultar em revisão manual (caminho alternativo ao fluxo automático)
+- é consumido por CRON, worker ou importador automático
+
+O módulo TypeScript deve conter, na primeira linha do arquivo, a referência:
+
+```typescript
+// Regras de negócio: ver {modulo}.regras-negocio.md
+```
+
+O arquivo `.md` é a **fonte de verdade**. Os JSDoc do código devem referenciar o `.md`, não duplicá-lo.
+
+## Estrutura Obrigatória do Arquivo
+
+```markdown
+# Regras de Negócio — [Nome do Módulo]
+
+Módulo: `_arquivo.ts`
+Localização: `caminho/relativo/ao/arquivo`
+
+---
+
+## Contexto
+Por que este módulo existe, qual problema resolve.
+
+## Critérios de Entrada / Identificação
+O que aciona o módulo, quais dados recebe, filtros aplicados.
+
+## Regras de Processamento
+As regras numeradas em ordem de avaliação.
+
+## Casos de Revisão Manual (quando aplicável)
+Quando o processamento automático não pode prosseguir.
+
+## Estratégia de Fusão / Resultado (quando aplicável)
+O que o módulo produz, como campos são combinados.
+
+## Dependências Externas
+Tabelas, filas, serviços externos tocados pelo módulo.
+```
+
+## Exemplos
+
+✅ **Correto** — referência no topo do módulo, regras no `.md`:
+```typescript
+// Regras de negócio: ver juntar_execucoes.regras-negocio.md
+
+import { ... } from "..."
+
+export const compilarJuntarExecucoes = async (...) => {
+  // implementação conforme regras-negocio.md
+}
+```
+
+❌ **Errado** — regras embutidas no código como comentário de bloco:
+```typescript
+/**
+ * Regras de negócio:
+ * [x] Pode ter apenas uma execução por data de vencimento.
+ * [x] Se tiver apenas uma execução consolidada → ela é a principal.
+ * ...
+ */
+```
+
+❌ **Errado** — JSDoc duplicando as regras em vez de referenciar o `.md`:
+```typescript
+/**
+ * Retorna false quando:
+ * - vencimentos divergentes
+ * - executada com datas distintas
+ * - vencimento_prorrogado distintos
+ * ...
+ */
+```
+
+## Impacto
+
+Sem este padrão:
+- Regras de negócio ficam implícitas no código ou em JSDoc que envelhece sem controle
+- O agente de IA precisa inferir regras do código ao invés de lê-las diretamente
+- Produto e suporte não conseguem validar o comportamento sem ajuda técnica
+- Mudanças de regra geram JSDoc desatualizado espalhado pelo código
+
+## Aplicação
+
+- Módulos de CRON com lógica de auditoria/fusão
+- Importadores automáticos (ex: importação de licenças via IA)
+- Workers de processamento em lote
+- Qualquer utilitário com lógica de decisão multi-critério
+
+## Referências
+
+- Skill: `.agent/skills/documentar-regras-negocio.global/SKILL.md`
+- Workflow: `.agent/workflows/documentar-regras-negocio.global.md`

global/rules/typescript-sem-any.md

@@ -0,0 +1,77 @@
+---
+type: rule
+name: typescript-sem-any
+trigger: always_on
+description: Proíbe uso de any, casts inseguros e padroniza uso de enums em código TypeScript
+scope: global
+updatedAt: "2026-06-01"
+globs:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.vue"
+alwaysApply: true
+---
+
+Regras obrigatórias para TypeScript neste projeto:
+
+- Nunca usar `any`.
+- Nunca usar `as any`.
+- Nunca contornar erro de tipagem com cast forçado.
+- Quando o tipo não for conhecido, usar `unknown`.
+- Antes de acessar valores `unknown`, fazer narrowing com:
+  - `typeof`
+  - `in`
+  - `Array.isArray`
+  - type guards
+  - schemas de validação como Zod
+- Preferir:
+  - generics
+  - union types
+  - `Record<string, unknown>`
+  - `Partial<T>`
+  - `Pick<T, K>`
+  - `PropType<T>` em Vue
+  - tipos derivados de funções existentes
+- Se faltar tipo, o agente deve:
+  1. procurar tipos já existentes no projeto;
+  2. criar um tipo/interface local explícita;
+  3. inferir a partir do contexto sempre que possível;
+  4. deixar um `TODO de tipagem` explícito, mas sem usar `any`.
+
+Regras obrigatórias para uso de enums:
+
+- Quando um valor estiver associado a um `enum`, é obrigatório utilizar o enum, nunca strings literais.
+- O acesso deve seguir o padrão: `<NomeEnum>.VALOR`.
+
+Também é proibido, quando existir `enum` correspondente:
+
+- utilizar strings literais no lugar do enum (ex: `"ativo"`, `"inativo"`, `"automatica"`, `"criar"`);
+- utilizar cast para forçar compatibilidade com enum (ex: `"ativo" as StatusConta`).
+
+Proibido gerar código que apenas "faça compilar" usando:
+
+- `as any`
+- `: any`
+- `[] as any`
+- `{ } as any`
+- dupla coerção como `as unknown as any`
+
+Em casos excepcionais, preferir:
+
+- `as unknown as TipoEspecifico` somente se houver justificativa clara e comentário técnico.
+
+Diretriz para o agente:
+
+Se encontrar uma string que represente um valor de domínio do sistema, o agente deve:
+
+1. procurar se já existe um `enum` correspondente no projeto;
+2. usar o `enum` existente;
+3. se não existir, propor a criação de um `enum` explícito, em vez de manter strings soltas.
+
+---
+
+## Referências
+
+- Skill: `.agent/skills/diagnosticar-erros-build.global/SKILL.md` (quando erros de tipagem causam falhas de build em cascata)
+- Workflow: `.agent/workflows/otimizar-codigos.global.md` (padrão de documentação para casts temporários)
+

global/rules/zod-validacao-padrao.md

@@ -0,0 +1,315 @@
+---
+type: rule
+name: zod-validacao-padrao
+description: Estabelece Zod como biblioteca obrigatória de validação em todo o ecossistema Azteca
+version: "1.0"
+scope: global
+priority: alta
+trigger: always_on
+globs:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.vue"
+alwaysApply: true
+updatedAt: "2026-06-01"
+references:
+  - .agent/rules/typescript-sem-any.global.md
+  - .agent/skills/criar-schema-zod.global/SKILL.md
+---
+
+# Regra: Zod como Validador Padrão
+
+## Contexto
+
+Todo projeto do ecossistema Azteca que receba dados externos — API, formulário, webhook, importação, fila, variáveis de ambiente — **deve** validar esses dados com [Zod](https://zod.dev).
+
+Zod é a única biblioteca de validação autorizada porque:
+
+- Inferência nativa de tipos TypeScript (`z.infer<>`) — elimina duplicação entre schema e tipo
+- Bundle pequeno (~13KB gzipped) — viável no frontend
+- Compartilhável entre back e front via pacotes `*-comuns`
+- Ecossistema maduro: `zod-to-json-schema`, `@anatine/zod-nestjs`, integração com `tRPC`
+
+---
+
+## Regra
+
+### 1. Toda entrada externa deve ser validada com Zod
+
+Entradas externas incluem:
+
+- **Corpo de requisição** (API REST, webhook, GraphQL)
+- **Query params e path params**
+- **Formulários de frontend**
+- **Dados de fila** (BullMQ, Redis, etc.)
+- **Arquivos importados** (CSV, JSON, Excel)
+- **Variáveis de ambiente**
+- **Respostas de APIs externas** (quando a resposta não é confiável)
+
+### 2. Schemas devem residir no pacote `*-comuns`
+
+Para que front e back compartilhem os mesmos schemas, eles devem residir no pacote `<modulo>-comuns`:
+
+```
+<modulo>-comuns/src/
+├── tabelas/
+│   ├── usuarios/
+│   │   ├── zUsuarioCriar.ts
+│   │   ├── zUsuarioEditar.ts
+│   │   └── index.ts
+│   ├── empresas/
+│   │   ├── zEmpresaCriar.ts
+│   │   └── index.ts
+│   └── index.ts
+```
+
+### 3. Tipos devem ser derivados dos schemas (nunca o inverso)
+
+```typescript
+// ✅ CORRETO — tipo derivado do schema
+export const zUsuarioCriar = z.object({
+  nome: z.string().min(1),
+  email: z.string().email(),
+  ativo: z.boolean().default(true),
+})
+export type tipoUsuarioCriar = z.infer<typeof zUsuarioCriar>
+
+// ❌ ERRADO — tipo manual separado do schema
+interface UsuarioCriar {
+  nome: string
+  email: string
+  ativo?: boolean
+}
+const zUsuarioCriar = z.object({ ... }) // duplicação!
+```
+
+### 4. Nomenclatura obrigatória de schemas
+
+| Padrão | Uso | Exemplo |
+|--------|-----|---------|
+| `z{Entidade}Criar` | Criação de registro | `zUsuarioCriar` |
+| `z{Entidade}Editar` | Edição de registro | `zUsuarioEditar` |
+| `z{Entidade}Filtro` | Filtros de listagem | `zUsuarioFiltro` |
+| `z{Entidade}Resposta` | Resposta de API | `zUsuarioResposta` |
+| `z{Entidade}Params` | Parâmetros de rota | `zUsuarioParams` |
+| `z{Modulo}Config` | Configuração do módulo | `zGeeConfig` |
+| `z{Modulo}Ambiente` | Variáveis de ambiente | `zBackAmbiente` |
+
+Prefixo `z` minúsculo + nome em `PascalCase`.
+
+### 5. Usar `safeParse` em vez de `parse` para erros controlados
+
+```typescript
+// ✅ CORRETO — erro controlado
+const resultado = zUsuarioCriar.safeParse(dados)
+if (!resultado.success) {
+  return respostaComuns.erro(resultado.error.issues[0].message)
+}
+const usuario = resultado.data // tipado automaticamente
+
+// ❌ ERRADO — throw não controlado
+const usuario = zUsuarioCriar.parse(dados) // lança ZodError
+```
+
+A exceção é em contextos onde o throw é desejável (middleware global, início de pipeline).
+
+### 6. Nunca usar validação manual quando Zod resolve
+
+```typescript
+// ❌ ERRADO — validação manual
+if (!dados.nome || typeof dados.nome !== "string") {
+  return erro("Nome é obrigatório")
+}
+if (!dados.email || !dados.email.includes("@")) {
+  return erro("Email inválido")
+}
+
+// ✅ CORRETO — Zod faz tudo
+const resultado = zUsuarioCriar.safeParse(dados)
+if (!resultado.success) {
+  return erro(resultado.error.issues[0].message)
+}
+```
+
+### 7. Transformações e defaults pertencem ao schema
+
+```typescript
+// ✅ CORRETO — transformação no schema
+export const zProdutoCriar = z.object({
+  nome: z.string().trim().min(1),
+  preco: z.coerce.number().positive(),
+  ativo: z.boolean().default(true),
+  codigo: z.string().toUpperCase().optional(),
+  tags: z.array(z.string()).default([]),
+})
+
+// ❌ ERRADO — transformação manual após validação
+const produto = zProdutoCriar.parse(dados)
+produto.nome = produto.nome.trim()
+produto.codigo = produto.codigo?.toUpperCase()
+```
+
+### 8. Composição de schemas em vez de duplicação
+
+```typescript
+// ✅ CORRETO — composição
+const zEndereco = z.object({
+  rua: z.string(),
+  cidade: z.string(),
+  uf: z.string().length(2),
+})
+
+const zEmpresaCriar = z.object({
+  nome: z.string(),
+  endereco: zEndereco,
+})
+
+const zEmpresaEditar = zEmpresaCriar.partial() // todos opcionais
+
+const zEmpresaResposta = zEmpresaCriar.extend({
+  codigo: z.string().uuid(),
+  criadoEm: z.string().datetime(),
+})
+
+// ❌ ERRADO — copiar campos entre schemas
+const zEmpresaEditar = z.object({
+  nome: z.string().optional(),    // duplicou!
+  endereco: z.object({            // duplicou!
+    rua: z.string().optional(),
+    cidade: z.string().optional(),
+  }),
+})
+```
+
+### 9. Enums Zod para valores de domínio
+
+```typescript
+// ✅ CORRETO — enum Zod quando os valores vêm de dados externos
+export const zStatusLicenca = z.enum(["ativa", "vencida", "suspensa", "cancelada"])
+export type tipoStatusLicenca = z.infer<typeof zStatusLicenca>
+
+// Usar em outros schemas
+const zLicencaCriar = z.object({
+  status: zStatusLicenca,
+  // ...
+})
+
+// ✅ TAMBÉM CORRETO — TypeScript enum quando já existe no projeto
+// e o schema referencia o enum
+import { StatusLicenca } from "./enums"
+const zLicencaCriar = z.object({
+  status: z.nativeEnum(StatusLicenca),
+})
+```
+
+### 10. Bibliotecas proibidas para validação
+
+| ❌ Proibido | Motivo |
+|-------------|--------|
+| `joi` | Não infere tipos TS, bundle pesado |
+| `yup` | Inferência fraca, API menos ergonômica |
+| `class-validator` | Decorators, não compartilhável com frontend |
+| `io-ts` | Verboso, curva de aprendizado alta |
+| `ajv` (direto) | JSON Schema — usar `zod-to-json-schema` se precisar de JSON Schema |
+| Validação manual com `if/typeof` | Quando Zod resolve o mesmo caso |
+
+---
+
+## Exemplos
+
+### API backend (Express)
+
+```typescript
+// ✅ Correto
+import { zUsuarioCriar } from "projeto-comuns/tabelas/usuarios"
+
+app.post("/usuarios", async (req, res) => {
+  const resultado = zUsuarioCriar.safeParse(req.body)
+  if (!resultado.success) {
+    return res.status(400).json({ erro: resultado.error.issues })
+  }
+  const usuario = await criarUsuario(resultado.data)
+  return res.json(usuario)
+})
+```
+
+### Webhook com fila
+
+```typescript
+// ✅ Correto — valida antes de enfileirar
+const zPayloadWebhook = z.object({
+  tabela: z.enum(["empreendedores", "empreendimentos", "usuarios"]),
+  dados: z.array(z.unknown()).min(1),
+})
+
+app.post("/webhook/:tabela", async (req, res) => {
+  const resultado = zPayloadWebhook.safeParse({
+    tabela: req.params.tabela,
+    dados: req.body,
+  })
+  if (!resultado.success) {
+    return res.status(400).json({ erro: "Payload inválido" })
+  }
+  await fila.add("sync", resultado.data)
+  return res.json({ ok: true })
+})
+```
+
+### Variáveis de ambiente
+
+```typescript
+// ✅ Correto — validar no boot da aplicação
+const zAmbiente = z.object({
+  DATABASE_URL: z.string().url(),
+  REDIS_HOST: z.string().default("localhost"),
+  REDIS_PORT: z.coerce.number().default(6379),
+  BASE_URL: z.string().url(),
+  SESSAO_BACK: z.string().uuid(),
+  NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
+})
+
+export const ambiente = () => zAmbiente.parse(process.env)
+```
+
+### Frontend (formulário Vue)
+
+```typescript
+// ✅ Correto — schema compartilhado validando antes de enviar
+import { zUsuarioCriar } from "projeto-comuns/tabelas/usuarios"
+
+const salvar = async () => {
+  const resultado = zUsuarioCriar.safeParse(formulario.value)
+  if (!resultado.success) {
+    erros.value = resultado.error.flatten().fieldErrors
+    return
+  }
+  await api.post("/usuarios", resultado.data)
+}
+```
+
+---
+
+## Impacto
+
+Sem esta regra:
+
+- Cada desenvolvedor escolhe uma estratégia diferente de validação (if/typeof, joi, yup, etc.)
+- Tipos e schemas ficam dessincronizados — mudança no schema não reflete no tipo e vice-versa
+- Validações manuais são incompletas e inconsistentes entre endpoints
+- Código de validação é duplicado entre front e back
+- Dados inválidos passam despercebidos e corrompem a base
+
+Com esta regra:
+
+- Uma única fonte de verdade: o schema Zod
+- Tipos TypeScript sempre sincronizados via `z.infer<>`
+- Validação consistente em todos os pontos de entrada
+- Reutilização entre front, back e workers via pacote `*-comuns`
+- Erros de validação estruturados e internacionalizáveis
+
+---
+
+## Referências
+
+- Rule: `.agent/rules/typescript-sem-any.global.md` (narrowing com Zod mencionado como alternativa)
+- Skill: `.agent/skills/criar-schema-zod.global/SKILL.md` (guia prático para criar schemas)