jarvis-ai-framework 1.0.3 → 2.0.0

package/skills/eng-backend/references/1-fundamentos-programacao.md

@@ -0,0 +1,41 @@
+# 1. Fundamentos de Programação
+
+**Nível:** FUNDAMENTAL  
+**Independência:** ✅ Válido em qualquer linguagem
+
+## Objetivo
+Dominar os blocos construtivos de todo software, que são os mesmos em qualquer linguagem: dados, controle de fluxo, funções, recursão, tratamento de erros e paradigmas.
+
+## Conhecimentos Principais
+
+### Essenciais
+- Variáveis, tipos de dados e escopo (global, local, léxico)
+- Controle de fluxo: condicionais (if/else, switch) e laços (while, for)
+- Funções: definição, parâmetros, retorno e valores padrão
+- Recursão: o conceito, o caso base e o estouro de pilha
+- Tratamento básico de exceções (try/catch/finally)
+- Entrada e saída básicas
+- Paradigmas: imperativo, declarativo, orientado a objetos e funcional
+
+### Importantes
+- Closures: o que são e como capturam o escopo
+- Funções de primeira classe: funções como valores
+- Funções de ordem superior (map, filter, reduce, em conceito)
+- Callbacks, promessas e async/await como padrão, não como sintaxe
+- Sistemas de tipos: tipagem estática versus dinâmica
+
+### Complementares
+- Geradores e iteradores (menos comuns)
+- Funções puras e imutabilidade
+
+## O que NÃO Inclui
+- Sintaxe específica de uma linguagem
+- APIs e bibliotecas específicas
+- Recursos exclusivos de uma linguagem (por exemplo, modelos próprios de concorrência ou decoradores)
+
+## Por quê é Universal
+Todo software é construído sobre esses conceitos. Mudar de linguagem muda a sintaxe, não os fundamentos.
+
+## Referências
+- IEEE SWEBOK - Software Engineering Body of Knowledge
+- ACM Computing Curricula 2023

package/skills/eng-backend/references/10-seguranca.md

@@ -0,0 +1,61 @@
+# 10. Segurança de Aplicações
+
+**Nível:** FUNDAMENTAL  
+**Independência:** ✅ Válido em qualquer linguagem
+
+## Objetivo
+Construir aplicações que resistam às vulnerabilidades mais comuns e protejam os dados, com segurança por padrão.
+
+## Conhecimentos Principais
+
+### OWASP Top 10 (2025)
+- 1. Quebra de controle de acesso (Broken Access Control)
+- 2. Configuração incorreta de segurança (Security Misconfiguration)
+- 3. Falhas na cadeia de suprimentos de software (Software Supply Chain Failures)
+- 4. Falhas criptográficas (Cryptographic Failures)
+- 5. Design inseguro (Insecure Design)
+- 6. Componentes vulneráveis e desatualizados
+- 7. Falhas de identificação e autenticação
+- 8. Falhas de integridade de software e de dados
+- 9. Falhas de registro e monitoramento de segurança
+- 10. Server-Side Request Forgery (SSRF)
+
+### Autenticação e autorização
+- Autenticação básica versus avançada
+- OAuth 2.0 (em conceito) e JWT
+- Autenticação multifator (MFA)
+- Gerenciamento seguro de sessão
+- Autorização (RBAC e ABAC) e prevenção de acesso indevido a recursos de outras pessoas
+
+### Criptografia
+- Hash com sal e algoritmos modernos (bcrypt, scrypt, argon2); nunca senha em texto plano
+- Criptografia simétrica versus assimétrica
+- Assinaturas digitais
+- Certificados e PKI (em conceito)
+- HTTPS e TLS
+
+### Práticas seguras
+- Validação e sanitização de toda entrada externa
+- Proteção contra CSRF e configuração segura de CORS
+- Prevenção de injeção de SQL e de XSS
+- Padrões seguros por padrão (secure defaults)
+- Princípio do menor privilégio
+
+### Dados sensíveis
+- Dados pessoais (PII)
+- LGPD, GDPR e CCPA (em conceito)
+- Criptografia em repouso e em trânsito
+- Exclusão segura
+- Gerenciamento de segredos: nunca no código nem no repositório
+
+## O que NÃO Inclui
+- Ferramentas específicas de segurança
+- Configuração de firewall de aplicação web
+
+## Por quê é Universal
+As vulnerabilidades e as defesas valem independentemente da linguagem ou do framework.
+
+## Referências
+- OWASP Top 10
+- IEEE SWEBOK
+- ACM Computing Curricula 2023

package/skills/eng-backend/references/11-performance.md

@@ -0,0 +1,49 @@
+# 11. Performance e Otimização
+
+**Nível:** IMPORTANTE  
+**Independência:** ✅ Válido em qualquer linguagem
+
+## Objetivo
+Encontrar gargalos com medição e otimizar onde importa, sem sacrificar a clareza.
+
+## Conhecimentos Principais
+
+### Identificar gargalos
+- Profiling de CPU, memória e E/S
+- Benchmarking
+- Testes de carga
+- Latência versus vazão (throughput)
+- Lei de Amdahl
+
+### Otimizações comuns
+- Caching em memória e distribuído
+- Otimização de consultas ao banco
+- Pool de conexões
+- Processamento em lote
+- Carregamento sob demanda (lazy loading)
+- Paginação
+
+### Caching
+- Cache em memória
+- Caches distribuídos
+- Estratégias de invalidação
+- Coerência de cache
+- TTL e expiração
+
+### Escalabilidade
+- Escala horizontal versus vertical
+- Sharding de banco de dados
+- Réplicas de leitura
+- Processamento assíncrono
+
+## O que NÃO Inclui
+- Otimizações específicas de uma linguagem
+- Ajuste fino de um servidor ou produto específico
+
+## Por quê é Universal
+Os princípios de desempenho (medir primeiro, otimizar o gargalo) valem em qualquer linguagem.
+
+## Referências
+- IEEE SWEBOK - Software Engineering Body of Knowledge
+- ACM Computing Curricula 2023
+- Donald Knuth - otimização prematura

package/skills/eng-backend/references/12-erros-logging.md

@@ -0,0 +1,42 @@
+# 12. Tratamento de Erros e Logging
+
+**Nível:** IMPORTANTE  
+**Independência:** ✅ Válido em qualquer linguagem
+
+## Objetivo
+Tratar falhas de forma previsível e registrar o suficiente para diagnosticar problemas sem expor dados sensíveis.
+
+## Conhecimentos Principais
+
+### Tratamento de erros
+- Exceções versus códigos de erro
+- Falhar rápido (fail fast) versus degradação graciosa
+- Propagação de erros entre as camadas
+- Try/catch/finally
+- Erros personalizados com contexto
+
+### Logging
+- Níveis de log (DEBUG, INFO, WARN, ERROR e FATAL)
+- Logging estruturado
+- Agregação de logs (em conceito)
+- Quando registrar e o que registrar, sem dados sensíveis
+- Retenção de logs
+
+### Monitoramento
+- Alertas
+- Métricas (latência, taxa de erro e vazão)
+- Verificações de saúde
+- Observabilidade: logs, métricas e traces
+- Rastreamento entre serviços com identificador de correlação
+
+## O que NÃO Inclui
+- Ferramentas específicas de logging e monitoramento
+- Configuração de uma biblioteca de logs
+
+## Por quê é Universal
+Estratégias de erro e de observabilidade são independentes de tecnologia.
+
+## Referências
+- IEEE SWEBOK - Software Engineering Body of Knowledge
+- ACM Computing Curricula 2023
+- Martin Fowler - Circuit Breaker e padrões de resiliência

package/skills/eng-backend/references/13-qualidade-codigo.md

@@ -0,0 +1,51 @@
+# 13. Qualidade de Código
+
+**Nível:** FUNDAMENTAL  
+**Independência:** ✅ Válido em qualquer linguagem
+
+## Objetivo
+Escrever código legível e fácil de mudar, e manter o histórico e a documentação organizados.
+
+## Conhecimentos Principais
+
+### Clean Code
+- Nomes significativos
+- Funções pequenas e bem definidas
+- DRY
+- Comentários: quando usar e quando não
+- Formatação e estilo consistentes
+- Tratamento de erros
+- Limites (boundaries) claros
+
+### Refatoração
+- Refatorar: o conceito e como fazê-lo com segurança
+- Code smells (indicadores de problemas)
+- Extract Method e Extract Class
+- Substituir números mágicos
+- Consolidar código duplicado
+- Simplificar condicionais complexas
+
+### Code review
+- Objetivos da revisão de código
+- Como revisar e como receber feedback
+- Automatização com linters e formatadores (em conceito)
+
+### Documentação
+- Documentação técnica
+- Documentação de API
+- Comentários versus código autoexplicativo
+- Registro de mudanças (change log)
+- Architecture Decision Records (ADRs)
+
+## O que NÃO Inclui
+- Linters e formatadores específicos
+- Configurações de ferramentas de estilo
+
+## Por quê é Universal
+Os padrões de qualidade de código independem da linguagem.
+
+## Referências
+- IEEE SWEBOK - Software Engineering Body of Knowledge
+- ACM Computing Curricula 2023
+- Robert C. Martin - Clean Code
+- Martin Fowler - Refactoring

package/skills/eng-backend/references/2-design-arquitetura.md

@@ -0,0 +1,48 @@
+# 2. Design e Arquitetura de Software
+
+**Nível:** FUNDAMENTAL  
+**Independência:** ✅ Válido em qualquer linguagem
+
+## Objetivo
+Projetar sistemas coesos e fáceis de mudar, aplicando princípios de design e padrões de arquitetura que independem de tecnologia.
+
+## Conhecimentos Principais
+
+### Princípios SOLID
+- **S**ingle Responsibility: uma razão para mudar
+- **O**pen/Closed: aberto para extensão, fechado para modificação
+- **L**iskov Substitution: subtipos substituem seus tipos base
+- **I**nterface Segregation: interfaces pequenas e específicas
+- **D**ependency Inversion: depender de abstrações
+
+### Princípios complementares
+- DRY (Don't Repeat Yourself)
+- KISS (Keep It Simple)
+- YAGNI (You Aren't Gonna Need It)
+- Separação de responsabilidades (Separation of Concerns)
+
+### Conceitos de orientação a objetos
+- Encapsulamento, abstração e polimorfismo
+- Herança e seus riscos; composição como alternativa
+- Coesão alta e acoplamento baixo
+
+### Padrões de arquitetura
+- Em camadas (Layered, N-tier)
+- Hexagonal (Ports and Adapters): o núcleo não conhece os detalhes externos
+- Clean Architecture
+- Domain-Driven Design (DDD): contextos delimitados e linguagem ubíqua
+- Orientada a eventos (Event-Driven)
+- **Vertical Slice**: organizar cada funcionalidade como uma fatia vertical completa. Vantagens: coesão alta, menor acoplamento entre funcionalidades e entregas mais independentes. Funciona bem com contextos delimitados do DDD
+
+## O que NÃO Inclui
+- Padrões específicos de um framework
+- Implementação de DDD em um framework específico
+- Estrutura de diretórios de um framework
+
+## Por quê é Universal
+Princípios de bom design são atemporais e valem com qualquer tecnologia.
+
+## Referências
+- IEEE SWEBOK - Software Engineering Body of Knowledge
+- ACM Computing Curricula 2023
+- Martin Fowler - Patterns of Enterprise Application Architecture

package/skills/eng-backend/references/3-design-patterns.md

@@ -0,0 +1,50 @@
+# 3. Design Patterns
+
+**Nível:** IMPORTANTE  
+**Independência:** ✅ Os 23 padrões GoF são independentes de linguagem
+
+## Objetivo
+Reconhecer o problema que cada padrão resolve e quando aplicá-lo, em vez de apenas memorizar implementações.
+
+## Conhecimentos Principais
+
+### Criacionais
+- Factory e Abstract Factory
+- Builder
+- Singleton (e seus riscos)
+- Prototype
+
+### Estruturais
+- Adapter
+- Bridge
+- Composite
+- Decorator
+- Facade
+- Proxy
+
+### Comportamentais
+- Chain of Responsibility
+- Command
+- Iterator
+- Observer
+- State
+- Strategy
+- Template Method
+- Visitor
+- Mediator
+
+### Como usar
+- Entender o problema e o contexto antes de escolher o padrão
+- Na prática, poucos padrões (cerca de cinco ou seis) resolvem a maior parte dos casos
+- Preferir a solução mais simples; um padrão não é objetivo, é meio
+
+## O que NÃO Inclui
+- Implementações em uma linguagem específica
+- Variações próprias de uma biblioteca ou framework
+
+## Por quê é Universal
+Os padrões descrevem soluções para problemas recorrentes de design e não dependem de sintaxe.
+
+## Referências
+- Design Patterns - Gang of Four (1994)
+- Martin Fowler - Refactoring

package/skills/eng-backend/references/4-algoritmos-estruturas.md

@@ -0,0 +1,43 @@
+# 4. Algoritmos e Estruturas de Dados
+
+**Nível:** FUNDAMENTAL  
+**Independência:** ✅ Válido em qualquer linguagem
+
+## Objetivo
+Escolher a estrutura e o algoritmo certos e analisar o custo deles em tempo e espaço.
+
+## Conhecimentos Principais
+
+### Estruturas de dados básicas
+- Arrays e listas
+- Pilhas e filas
+- Listas ligadas
+- Árvores (binárias, de busca e balanceadas)
+- Grafos
+- Tabelas hash (dicionários)
+- Heaps
+
+### Análise de complexidade
+- Notação Big O (O, Ω, Θ)
+- Análise de tempo e de espaço
+- Melhor caso, pior caso e caso médio
+- Identificação de gargalos
+
+### Algoritmos fundamentais
+- Busca (linear e binária)
+- Ordenação (quick, merge e heap sort, em conceito)
+- Percursos em árvores e grafos (DFS e BFS)
+- Recursão versus iteração
+- Técnicas: divisão e conquista, algoritmos gulosos e programação dinâmica
+
+## O que NÃO Inclui
+- Implementações específicas de uma linguagem
+- Bibliotecas de coleções de uma linguagem
+
+## Por quê é Universal
+Complexidade e estruturas de dados são os mesmos em qualquer linguagem.
+
+## Referências
+- IEEE SWEBOK - Software Engineering Body of Knowledge
+- ACM Computing Curricula 2023
+- Introduction to Algorithms (CLRS)

package/skills/eng-backend/references/5-banco-dados.md

@@ -0,0 +1,53 @@
+# 5. Banco de Dados e Persistência
+
+**Nível:** FUNDAMENTAL  
+**Independência:** ✅ Os conceitos valem para bancos relacionais e não relacionais
+
+## Objetivo
+Modelar, consultar e evoluir dados com consistência e bom desempenho.
+
+## Conhecimentos Principais
+
+### Conceitos relacionais
+- Modelo relacional: tabelas, colunas e linhas
+- Chaves primárias e estrangeiras
+- Índices
+- Normalização (1FN, 2FN, 3FN) e desnormalização, e quando usar cada uma
+- Junções (INNER, LEFT, RIGHT e FULL)
+
+### ACID e transações
+- **A**tomicidade: tudo ou nada
+- **C**onsistência: o estado é sempre válido
+- **I**solamento: transações não interferem entre si
+- **D**urabilidade: o que foi confirmado persiste
+- Níveis de isolamento (Read Uncommitted, Read Committed, Repeatable Read, Serializable)
+- Condições de corrida e deadlocks em transações
+
+### Consultas e desempenho
+- Seleção, agregações e agrupamentos
+- Subconsultas
+- Planos de consulta (EXPLAIN)
+- Tipos de índice (árvore B, hash) e quando criar índices
+
+### Conceitos não relacionais (quando relevante)
+- Armazenamento de documentos e de chave-valor
+- Teorema CAP (consistência, disponibilidade e tolerância a partições)
+- Consistência eventual
+- Quando usar relacional ou não relacional
+
+### Migrações e versionamento
+- Migrações de esquema e de dados
+- Compatibilidade retroativa
+
+## O que NÃO Inclui
+- Dialetos de SQL específicos
+- Configuração e ajuste de um banco específico
+- Recursos exclusivos de um produto de banco de dados
+
+## Por quê é Universal
+Os conceitos de dados e de transações valem para qualquer banco, relacional ou não.
+
+## Referências
+- IEEE SWEBOK - Software Engineering Body of Knowledge
+- ACM Computing Curricula 2023
+- Martin Fowler - NoSQL Distilled

package/skills/eng-backend/references/6-api-comunicacao.md

@@ -0,0 +1,42 @@
+# 6. API e Comunicação entre Sistemas
+
+**Nível:** FUNDAMENTAL  
+**Independência:** ✅ Válido em qualquer linguagem
+
+## Objetivo
+Projetar APIs claras, seguras e evolutivas para que sistemas se comuniquem de forma confiável.
+
+## Conhecimentos Principais
+
+### REST e HTTP
+- Princípios REST (Representational State Transfer)
+- Métodos HTTP: GET, POST, PUT, PATCH, DELETE, HEAD e OPTIONS
+- Códigos de status (1xx a 5xx)
+- Cabeçalhos HTTP importantes
+- Ausência de estado (statelessness)
+- Design orientado a recursos
+- HATEOAS e hipermídia
+
+### Conceitos de API
+- Versionamento de API e versionamento semântico
+- Autenticação (OAuth, JWT, Basic) e autorização (RBAC e ABAC)
+- Limitação de taxa (rate limiting e throttling)
+- Paginação, filtros e parâmetros de consulta
+- Idempotência: repetir a chamada não repete o efeito
+- Documentação de API por uma especificação padronizada
+
+### Protocolo HTTP/HTTPS
+- HTTPS e TLS
+- Diferenças entre HTTP/1.1, HTTP/2 e HTTP/3
+- Keep-alive e compressão
+
+## O que NÃO Inclui
+- Implementação em um framework web específico
+- Protocolos alternativos muito especializados
+
+## Por quê é Universal
+APIs são a forma padrão de os sistemas conversarem, e os princípios independem de quem as implementa.
+
+## Referências
+- Roy Fielding - Architectural Styles and the Design of Network-based Software Architectures (REST)
+- Especificações do protocolo HTTP (RFCs)

package/skills/eng-backend/references/7-concorrencia-async.md

@@ -0,0 +1,49 @@
+# 7. Concorrência e Assincronismo
+
+**Nível:** IMPORTANTE  
+**Independência:** ✅ Válido em qualquer linguagem
+
+## Objetivo
+Lidar com várias tarefas ao mesmo tempo sem corromper estado nem travar o sistema.
+
+## Conhecimentos Principais
+
+### Conceitos fundamentais
+- Concorrência versus paralelismo
+- Threads versus processos
+- Troca de contexto
+- Segurança entre threads (thread safety)
+- Estado mutável compartilhado como a principal fonte de problemas
+
+### Problemas de concorrência
+- Condições de corrida e data races
+- Deadlocks e livelocks
+- Starvation
+- Problemas de visibilidade de memória
+
+### Soluções
+- Mutexes e locks
+- Semáforos
+- Operações atômicas
+- Imutabilidade
+- Troca de mensagens
+- Modelo de atores (em conceito)
+
+### Assincronismo
+- Callbacks
+- Promessas e futuros
+- Async/await como padrão, não como sintaxe
+- Programação reativa (em conceito)
+- E/S não bloqueante
+
+## O que NÃO Inclui
+- Sintaxe de concorrência de uma linguagem específica
+- Bibliotecas de threads específicas
+
+## Por quê é Universal
+Concorrência é um desafio de qualquer backend, e os problemas e soluções são os mesmos em todas as linguagens.
+
+## Referências
+- IEEE SWEBOK - Software Engineering Body of Knowledge
+- ACM Computing Curricula 2023
+- Literatura clássica sobre concorrência (conceitos aplicáveis a qualquer linguagem)

package/skills/eng-backend/references/8-arquitetura-servidor.md

@@ -0,0 +1,49 @@
+# 8. Arquitetura de Servidor
+
+**Nível:** IMPORTANTE  
+**Independência:** ✅ Válido em qualquer linguagem
+
+## Objetivo
+Estruturar o servidor para atender muitas requisições com escalabilidade e resiliência, sem depender de uma tecnologia específica.
+
+## Conhecimentos Principais
+
+### Padrões de servidor
+- Modelo requisição-resposta
+- Pipeline de tratamento de requisições
+- Padrão middleware
+- Pool de conexões e pool de threads
+
+### Escalabilidade
+- Escala vertical versus horizontal
+- Balanceamento de carga (round robin, menos conexões e similares)
+- Arquitetura sem estado (stateless) versus com estado
+- Gerenciamento de sessão
+- Camadas de cache
+
+### Resiliência
+- Timeouts
+- Retentativas com backoff exponencial
+- Circuit breaker
+- Bulkhead
+- Verificações de saúde (health checks)
+
+### Sistemas distribuídos
+- Teorema CAP
+- Consistência eventual
+- Algoritmos de consenso (em conceito)
+- Transações distribuídas
+- Idempotência em sistemas distribuídos
+
+## O que NÃO Inclui
+- Configuração específica de um servidor web ou proxy
+- Infraestrutura de implantação (contêineres e orquestração)
+
+## Por quê é Universal
+Os padrões de arquitetura de servidor valem com qualquer tecnologia de implementação.
+
+## Referências
+- IEEE SWEBOK - Software Engineering Body of Knowledge
+- ACM Computing Curricula 2023
+- Martin Fowler - Patterns of Enterprise Application Architecture
+- Designing Data-Intensive Applications (conceitos)

package/skills/eng-backend/references/9-testes.md

@@ -0,0 +1,43 @@
+# 9. Testes
+
+**Nível:** FUNDAMENTAL  
+**Independência:** ✅ Válido em qualquer linguagem
+
+## Objetivo
+Garantir, com testes rápidos e confiáveis, que o código faz o que deve e continua fazendo depois das mudanças.
+
+## Conhecimentos Principais
+
+### Tipos de teste
+- Unitários: isolam uma unidade
+- Integração: verificam a interação entre componentes
+- Ponta a ponta (E2E): percorrem o fluxo completo
+- De contrato: validam o contrato das APIs
+
+### Práticas
+- Test-Driven Development (TDD): vermelho, verde, refatorar
+- Behavior-Driven Development (BDD)
+- Cobertura de testes e quando ela é relevante
+- Mocks e stubs
+- Fixtures e dados de teste
+- Padrão Arrange-Act-Assert
+
+### Qualidade dos testes
+- Determinísticos (sem testes instáveis)
+- Rápidos
+- Independentes entre si
+- Legíveis
+- Pirâmide de testes: muitos unitários, poucos de ponta a ponta
+
+## O que NÃO Inclui
+- Frameworks e bibliotecas de teste específicos
+- Sintaxe de uma ferramenta de testes
+
+## Por quê é Universal
+Testar é uma prática universal, independente da linguagem ou do framework de teste.
+
+## Referências
+- IEEE SWEBOK - Software Engineering Body of Knowledge
+- ACM Computing Curricula 2023
+- Kent Beck - Test-Driven Development
+- Martin Fowler - Test Pyramid

package/skills/{eng-arch-c4 → eng-backend-arch-c4}/SKILL.md

@@ -1,9 +1,14 @@
 ---
-name: eng-arch-c4
+name: eng-backend-arch-c4
 description: Cria e mantém documentação de arquitetura usando C4 Model. Use quando precisar documentar sistemas com diagramas de Contexto, Container, Componente e Código.
 argument-hint: "[nivel: context|container|component|code] [sistema-opcional]"
 disable-model-invocation: false
 allowed-tools: Read Write Edit Grep Glob Bash MCP
+metadata:
+  author: jarvis-team
+  version: "1.0"
+  area: backend
+  stack: arch-c4
 ---
 
 # Arch C4 - Documentação de Arquitetura
@@ -43,10 +48,10 @@ Criar e manter documentação de arquitetura usando os 4 níveis do C4:
 
 | Nível | Arquivo |
 |-------|---------|
-| Context | `$IDE/skills/eng-arch-c4/assets/example-context.md` |
-| Container | `$IDE/skills/eng-arch-c4/assets/example-container.md` |
-| Component | `$IDE/skills/eng-arch-c4/assets/example-component.md` |
-| Code | `$IDE/skills/eng-arch-c4/assets/example-code.md` |
+| Context | `$IDE/skills/eng-backend-arch-c4/assets/example-context.md` |
+| Container | `$IDE/skills/eng-backend-arch-c4/assets/example-container.md` |
+| Component | `$IDE/skills/eng-backend-arch-c4/assets/example-component.md` |
+| Code | `$IDE/skills/eng-backend-arch-c4/assets/example-code.md` |
 
 ---
 
@@ -55,7 +60,7 @@ Criar e manter documentação de arquitetura usando os 4 níveis do C4:
 **IMPORTANTE**: Antes de executar, verificar se o `ENV.md` existe e está configurado:
 
 ```bash
-cat $IDE/ENV.md 2>/dev/null || echo "⚠️ ENV.md não encontrado. Execute /init-jarvis primeiro."
+cat $IDE/ENV.md 2>/dev/null || echo "⚠️ ENV.md não encontrado. Execute /jarvis-init primeiro."
 ```
 
 ---
@@ -330,7 +335,7 @@ Referência: https://c4model.com
 
 ### ENV.md não encontrado
 - Interromper execução
-- Orientar usuário a executar `/init-jarvis` primeiro
+- Orientar usuário a executar `/jarvis-init` primeiro
 
 ### Script de detecção não encontrado
 - Executar detecção manual com comandos básicos