mega-brain-ai 1.3.0

package/.claude/skills/using-superpowers/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: 11-SKILL-USING-SUPERPOWERS
+description: Use ao iniciar qualquer conversa - estabelece como encontrar e usar skills disponíveis
+---
+
+> **Auto-Trigger:** Qualquer conversa, encontrar e usar skills disponíveis
+> **Keywords:** "superpower", "poder", "avançado", "capability", "skills", "habilidades"
+> **Prioridade:** MÉDIA
+
+---
+
+# Using Superpowers - Mega Brain
+
+<EXTREMELY-IMPORTANT>
+Se você acha que há 1% de chance de uma skill se aplicar ao que está fazendo, você ABSOLUTAMENTE DEVE invocar a skill.
+
+SE UMA SKILL SE APLICA À SUA TAREFA, VOCÊ NÃO TEM ESCOLHA. VOCÊ DEVE USÁ-LA.
+
+Isso não é negociável. Isso não é opcional. Você não pode racionalizar para sair disso.
+</EXTREMELY-IMPORTANT>
+
+## Como Acessar Skills
+
+**No Claude Code:** Use a ferramenta `Skill`. Quando invocar uma skill, seu conteúdo é carregado e apresentado - siga-o diretamente. Nunca use Read tool em arquivos de skill.
+
+## A Regra
+
+**Invocar skills relevantes ou solicitadas ANTES de qualquer resposta ou ação.** Mesmo 1% de chance de uma skill se aplicar significa que você deve invocar para verificar.
+
+```
+User message received
+        ↓
+Alguma skill pode se aplicar? ──SIM──→ Invocar Skill tool
+        │                                    ↓
+       NÃO                          Anunciar: "Usando [skill] para [propósito]"
+        │                                    ↓
+        ↓                           Tem checklist? ──SIM──→ Criar TodoWrite
+Responder                                   │
+                                           NÃO
+                                            ↓
+                                    Seguir skill exatamente
+                                            ↓
+                                    Responder
+```
+
+## Red Flags
+
+Esses pensamentos significam PARE - você está racionalizando:
+
+| Pensamento | Realidade |
+|------------|-----------|
+| "Isso é só uma pergunta simples" | Perguntas são tarefas. Checar skills. |
+| "Preciso de mais contexto primeiro" | Check de skill vem ANTES de perguntas de clarificação. |
+| "Deixa eu explorar o projeto primeiro" | Skills dizem COMO explorar. Checar primeiro. |
+| "Posso checar arquivos rapidamente" | Arquivos não têm contexto da conversa. Checar skills. |
+| "Deixa eu coletar informação primeiro" | Skills dizem COMO coletar. |
+| "Isso não precisa de skill formal" | Se skill existe, use-a. |
+| "Eu lembro dessa skill" | Skills evoluem. Ler versão atual. |
+| "Isso não conta como tarefa" | Ação = tarefa. Checar skills. |
+| "A skill é overkill" | Coisas simples viram complexas. Use. |
+| "Vou só fazer isso primeiro" | Checar ANTES de fazer qualquer coisa. |
+
+## Prioridade de Skills
+
+Quando múltiplas skills podem se aplicar, usar esta ordem:
+
+1. **Skills de processo primeiro** (brainstorming, executing-plans) - determinam COMO abordar
+2. **Skills de implementação segundo** (dispatching-parallel-agents) - guiam execução
+
+"Vamos processar X" → brainstorming primeiro (se complexo), depois skills de implementação
+"Verificar se está pronto" → verification-before-completion primeiro
+
+## Skills Disponíveis no Mega Brain
+
+### Skills Nativas (00-05)
+| # | Skill | Quando Usar |
+|---|-------|-------------|
+| 00 | SKILL-CREATOR | Criar novas skills |
+| 01 | DOCS-MEGABRAIN | Documentação do Mega Brain |
+| 02 | PYTHON-MEGABRAIN | Scripts Python do projeto |
+| 03 | AGENT-CREATION | Criar novos agentes |
+| 04 | KNOWLEDGE-EXTRACTION | Extrair conhecimento de fontes |
+| 05 | PIPELINE-JARVIS | Pipeline Jarvis completo |
+
+### Skills de Processo (06-11)
+| # | Skill | Quando Usar |
+|---|-------|-------------|
+| 06 | BRAINSTORMING | Criar playbooks, estruturar agentes, design |
+| 07 | DISPATCHING-PARALLEL-AGENTS | 2+ tarefas independentes em paralelo |
+| 08 | EXECUTING-PLANS | Executar plano com checkpoints |
+| 09 | WRITING-PLANS | Spec ou requirements para tarefa multi-step |
+| 10 | VERIFICATION-BEFORE-COMPLETION | Antes de declarar qualquer coisa completa |
+| 11 | USING-SUPERPOWERS | Meta-skill para encontrar outras skills |
+
+## Tipos de Skills
+
+**Rígidas** (verification, executing-plans): Seguir exatamente. Não adaptar longe da disciplina.
+
+**Flexíveis** (brainstorming, writing-plans): Adaptar princípios ao contexto.
+
+A própria skill diz qual é.
+
+## Instruções do Usuário
+
+Instruções dizem O QUE, não COMO. "Processar X" ou "Criar Y" não significa pular workflows.

package/.claude/skills/verification-before-completion/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: 10-SKILL-VERIFICATION-BEFORE-COMPLETION
+description: Use antes de declarar trabalho completo, corrigido ou passando - requer verificação real antes de qualquer afirmação de sucesso
+---
+
+> **Auto-Trigger:** Antes de declarar completo/corrigido, antes de finalizar processamento
+> **Keywords:** "verificar", "validar", "checklist", "finalizar", "completo", "pronto", "concluído"
+> **Prioridade:** ALTA
+
+---
+
+# Verification Before Completion - Mega Brain
+
+## Overview
+
+Declarar trabalho completo sem verificação é desonestidade, não eficiência.
+
+**Princípio central:** Evidência antes de afirmações, sempre.
+
+**Violar a letra desta regra é violar o espírito desta regra.**
+
+## A Lei de Ferro
+
+```
+NENHUMA DECLARAÇÃO DE CONCLUSÃO SEM EVIDÊNCIA DE VERIFICAÇÃO FRESCA
+```
+
+Se você não executou o comando de verificação nesta mensagem, não pode declarar que passou.
+
+## O Gate Function
+
+```
+ANTES de declarar qualquer status ou expressar satisfação:
+
+1. IDENTIFICAR: Qual comando prova esta afirmação?
+2. EXECUTAR: Rodar o comando COMPLETO (fresco, completo)
+3. LER: Output completo, checar exit code, contar falhas
+4. VERIFICAR: Output confirma a afirmação?
+   - Se NÃO: Declarar status real com evidência
+   - Se SIM: Declarar afirmação COM evidência
+5. SÓ ENTÃO: Fazer a afirmação
+
+Pular qualquer passo = mentir, não verificar
+```
+
+## Verificações no Contexto Mega Brain
+
+| Afirmação | Requer | Não Suficiente |
+|-----------|--------|----------------|
+| Arquivo processado | Chunks + Insights gerados | "Deveria estar OK" |
+| Pipeline completo | Todos os 8 steps executados | "Rodei alguns steps" |
+| Agente atualizado | MEMORY com novos insights | "Atualizei o agente" |
+| Dossiê gerado | Arquivo existe + chunk_ids inline | "Criei o dossiê" |
+| Session State atualizado | Verificar arquivo | "Marquei como processado" |
+| JSONs consistentes | Parse sem erro | "Adicionei entradas" |
+
+## Red Flags - PARAR
+
+- Usando "deveria", "provavelmente", "parece que"
+- Expressando satisfação antes de verificar ("Ótimo!", "Perfeito!", "Pronto!")
+- Prestes a declarar task completa sem verificação
+- Confiando em reports de agentes
+- Baseando-se em verificação parcial
+- Pensando "só dessa vez"
+- Cansado e querendo terminar
+- **QUALQUER formulação implicando sucesso sem ter rodado verificação**
+
+## Prevenção de Racionalização
+
+| Desculpa | Realidade |
+|----------|-----------|
+| "Deveria funcionar agora" | RODE a verificação |
+| "Estou confiante" | Confiança ≠ evidência |
+| "Só dessa vez" | Sem exceções |
+| "Chunks foram criados" | Verificar INSIGHTS também |
+| "Agente disse sucesso" | Verificar independentemente |
+| "Estou cansado" | Cansaço ≠ desculpa |
+| "Verificação parcial basta" | Parcial prova nada |
+
+## Padrões Chave
+
+**Processamento de arquivo:**
+```
+✅ [Verifica chunks] [Verifica insights] [Verifica session-state] "Arquivo processado"
+❌ "Deveria estar OK" / "Parece correto"
+```
+
+**Pipeline Jarvis:**
+```
+✅ Step 1.1 ✅ → Step 1.2 ✅ → Step 2.1 ✅ → ... → "Pipeline completo"
+❌ "Rodei o pipeline" (sem verificar cada step)
+```
+
+**Atualização de agente:**
+```
+✅ [Lê MEMORY] [Vê novos insights] [Chunk_ids presentes] "Agente atualizado"
+❌ "Atualizei o MEMORY" (sem verificar)
+```
+
+**Geração de dossiê:**
+```
+✅ [Arquivo existe] [Chunk_ids inline] [Referências válidas] "Dossiê gerado"
+❌ "Criei o dossiê" (sem verificar conteúdo)
+```
+
+## Por Que Isso Importa
+
+No contexto Mega Brain:
+- Arquivos "processados" mas chunks não gerados → perda de conhecimento
+- Insights "extraídos" mas não salvos → retrabalho
+- Agentes "atualizados" mas MEMORY vazio → agente não aprende
+- Session State "atualizado" mas arquivo não tocado → próxima sessão repete trabalho
+
+## Quando Aplicar
+
+**SEMPRE antes de:**
+- QUALQUER variação de afirmação de sucesso/conclusão
+- QUALQUER expressão de satisfação
+- QUALQUER declaração positiva sobre estado do trabalho
+- Marcar task como completa
+- Mover para próxima task
+- Delegar para agentes
+
+## O Resumo
+
+**Sem atalhos para verificação.**
+
+Rode o comando. Leia o output. ENTÃO declare o resultado.
+
+Isso é inegociável.

package/.claude/skills/verify/SKILL.md

@@ -0,0 +1,154 @@
+# /verify - Verification Loop
+
+## Trigger
+`/verify` - Use antes de declarar trabalho completo, corrigido ou passando
+
+## Objetivo
+Implementar o "Verification Loop" do workflow Boris Cherny: Claude testa seu proprio output antes de declarar que terminou.
+
+## Fluxo de Execucao
+
+### 1. IDENTIFICAR O QUE FOI FEITO
+
+Antes de verificar, identifique o escopo:
+- Codigo criado ou modificado
+- Batches processados
+- Agentes criados/atualizados
+- Skills criadas
+- Configuracoes alteradas
+
+### 2. VERIFICACOES POR TIPO
+
+#### Para CODIGO Python:
+```bash
+# Syntax check
+python3 -m py_compile arquivo.py
+
+# Se tiver tests, rodar
+python3 -m pytest arquivo_test.py -v
+
+# Se nao tiver tests, criar teste basico e rodar
+```
+
+#### Para BATCHES:
+```
+[ ] Template V2 completo? (14 secoes)
+[ ] ASCII headers presentes?
+[ ] Cascateamento executado? (REGRA #22)
+[ ] Dual-location gravado? (REGRA #8)
+[ ] Log mostrado no chat?
+```
+
+#### Para AGENTES:
+```
+[ ] Template V3 completo? (11 partes)
+[ ] SOUL.md criado?
+[ ] DNA-CONFIG.yaml criado?
+[ ] Citacoes rastreaveis presentes?
+[ ] Referenciado em _INDEX.md?
+```
+
+#### Para SKILLS:
+```
+[ ] SKILL.md com frontmatter correto?
+[ ] Instrucoes claras?
+[ ] Exemplos de uso?
+[ ] Dependencias listadas?
+```
+
+#### Para CONFIGURACOES:
+```
+[ ] JSON valido?
+[ ] Paths corretos?
+[ ] Permissoes adequadas?
+```
+
+### 3. EXECUTAR VERIFICACAO
+
+```python
+# Template de verificacao
+CHECKLIST = """
+## VERIFICATION LOOP
+
+### Escopo Verificado
+- Tipo: [CODIGO/BATCH/AGENT/SKILL/config]
+- Arquivos: [lista]
+- Modificacoes: [lista]
+
+### Testes Executados
+- [ ] [Teste 1]: [PASS/FAIL] - [detalhes]
+- [ ] [Teste 2]: [PASS/FAIL] - [detalhes]
+- [ ] [Teste 3]: [PASS/FAIL] - [detalhes]
+
+### Resultado
+- Status: [VERIFIED/NEEDS_FIX]
+- Confianca: [X]%
+- Issues encontradas: [N]
+
+### Proxima Acao
+- [Se VERIFIED]: Trabalho pode ser declarado completo
+- [Se NEEDS_FIX]: [lista de fixes necessarios]
+"""
+```
+
+### 4. REGRA DE OURO
+
+```
+NAO DECLARE "PRONTO" SEM RODAR /verify
+NAO DECLARE "CORRIGIDO" SEM RODAR /verify
+NAO DECLARE "PASSANDO" SEM RODAR /verify
+```
+
+### 5. FALHAS COMUNS (EVITAR)
+
+| Falha | Como Evitar |
+|-------|-------------|
+| Dizer "corrigido" sem testar | SEMPRE rodar verificacao |
+| Assumir que syntax esta ok | SEMPRE rodar py_compile |
+| Assumir que batch esta completo | SEMPRE checar 14 secoes |
+| Assumir que agent esta correto | SEMPRE checar 11 partes |
+
+## Exemplo de Uso
+
+**Usuario**: "Crie um script para processar INBOX"
+
+**JARVIS cria o script, depois executa /verify:**
+
+```
+## VERIFICATION LOOP
+
+### Escopo Verificado
+- Tipo: CODIGO
+- Arquivos: scripts/process_inbox.py
+- Modificacoes: Arquivo novo (150 linhas)
+
+### Testes Executados
+- [x] Syntax check: PASS
+- [x] Import check: PASS (todas libs disponiveis)
+- [x] Dry-run test: PASS (executou sem erros)
+- [x] Output validation: PASS (output esperado)
+
+### Resultado
+- Status: VERIFIED
+- Confianca: 95%
+- Issues encontradas: 0
+
+### Proxima Acao
+- Trabalho pode ser declarado completo
+- Script pronto para uso em producao
+```
+
+**SO ENTAO JARVIS declara**: "Script criado e verificado, senhor."
+
+## Integracao com Sistema
+
+Este skill complementa:
+- `stop_hook_completeness.py` - Stop hook que verifica antes de parar
+- `post_write_validator.py` - Valida automaticamente apos Write/Edit
+- `LEDGER.md` - Registra verificacoes no historico
+
+## Metricas de Sucesso
+
+- Reducao de 80% em "bugs pos-entrega"
+- Confianca de 95%+ em trabalho declarado completo
+- Zero retrabalho por falta de verificacao

package/.claude/skills/verify-6-levels/SKILL.md

@@ -0,0 +1,234 @@
+> **Auto-Trigger:** Quando usuário pede verificação, validação, ou checagem de qualidade
+> **Keywords:** "verificar", "verify", "verificação", "validar", "validation", "checar", "check", "qualidade", "quality", "6 níveis", "6 levels"
+> **Prioridade:** ALTA
+> **Tools:** Bash, Read, Grep
+
+---
+
+# /verify-6-levels - Verificação Completa em 6 Níveis
+
+## Propósito
+
+Este skill executa verificação completa do código/sistema seguindo os 6 níveis
+definidos no workflow Boris Cherny + Continuous Claude.
+
+---
+
+## Os 6 Níveis
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                    PIPELINE DE VERIFICAÇÃO                                  │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                                                                             │
+│  NÍVEL 1: LINT/HOOKS                                                        │
+│  ├── O que: Formatação, style guides, pre-commit hooks                     │
+│  ├── Como: pre-commit run --all-files                                      │
+│  └── Falha: Código mal formatado, violações de style                       │
+│                                                                             │
+│  NÍVEL 2: TESTS                                                             │
+│  ├── O que: Testes unitários e de integração                               │
+│  ├── Como: pytest / npm test / go test                                     │
+│  └── Falha: Testes quebrando, cobertura baixa                              │
+│                                                                             │
+│  NÍVEL 3: BUILD/INTEGRITY                                                   │
+│  ├── O que: Compilação, integridade de arquivos                            │
+│  ├── Como: python -m py_compile / npm run build / validate_phase5.py      │
+│  └── Falha: Erros de sintaxe, imports quebrados                            │
+│                                                                             │
+│  NÍVEL 4: VISUAL                                                            │
+│  ├── O que: Revisão visual do output                                       │
+│  ├── Como: Inspeção manual dos resultados                                  │
+│  └── Falha: Output incorreto, formatação errada                            │
+│                                                                             │
+│  NÍVEL 5: STAGING                                                           │
+│  ├── O que: Teste em ambiente staging/preview                              │
+│  ├── Como: Deploy para ambiente de teste                                   │
+│  └── Falha: Funciona local mas quebra em produção                          │
+│                                                                             │
+│  NÍVEL 6: SECURITY                                                          │
+│  ├── O que: Auditoria de segurança                                         │
+│  ├── Como: bandit / npm audit / revisão manual                             │
+│  └── Falha: Vulnerabilidades, secrets expostos                             │
+│                                                                             │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Comandos por Nível
+
+### Nível 1: Lint/Hooks
+```bash
+# Python
+python3 -m py_compile **/*.py
+ruff check .
+black --check .
+
+# JavaScript/TypeScript
+npm run lint
+eslint .
+
+# Pre-commit (universal)
+pre-commit run --all-files
+```
+
+### Nível 2: Tests
+```bash
+# Python
+pytest -v
+pytest --cov=. --cov-report=term-missing
+
+# JavaScript
+npm test
+jest --coverage
+
+# Go
+go test ./...
+```
+
+### Nível 3: Build/Integrity
+```bash
+# Python - Validar sintaxe de todos os arquivos
+find . -name "*.py" -exec python3 -m py_compile {} \;
+
+# JARVIS específico - Validar Fase 5
+python3 scripts/validate_phase5.py
+
+# Validar cascateamento
+python3 scripts/validate_cascading_integrity.py
+
+# JavaScript
+npm run build
+```
+
+### Nível 4: Visual
+```markdown
+Verificação Manual:
+- [ ] Output está formatado corretamente?
+- [ ] ASCII art renderiza corretamente?
+- [ ] Logs estão completos?
+- [ ] Métricas fazem sentido?
+```
+
+### Nível 5: Staging
+```bash
+# Depende do projeto
+# Exemplos:
+vercel --prod
+railway up
+heroku push staging
+```
+
+### Nível 6: Security
+```bash
+# Python
+bandit -r . -ll
+pip-audit
+safety check
+
+# JavaScript
+npm audit
+snyk test
+
+# Secrets
+git secrets --scan
+trufflehog .
+
+# Manual
+# - Revisar .env não commitado
+# - Verificar permissions em APIs
+# - Checar tokens não expirados
+```
+
+---
+
+## Verificação Rápida (JARVIS)
+
+Para verificação rápida do Mega Brain:
+
+```bash
+# Executar todos os níveis aplicáveis
+cd "."
+
+# Nível 1: Sintaxe Python
+echo "=== NÍVEL 1: LINT ===" && \
+find . -name "*.py" -path "./.claude/*" -exec python3 -m py_compile {} \; && \
+echo "PASSED"
+
+# Nível 3: Integridade
+echo "=== NÍVEL 3: INTEGRITY ===" && \
+python3 scripts/validate_phase5.py --fix && \
+echo "PASSED"
+
+# Nível 6: Security Check
+echo "=== NÍVEL 6: SECURITY ===" && \
+grep -r "sk-" .claude/ --include="*.json" && echo "WARNING: API keys found" || echo "PASSED"
+```
+
+---
+
+## Checklist de PR
+
+Use este checklist em Pull Requests:
+
+```markdown
+## Verification Checklist
+- [ ] 1. Hooks/Lint passed
+- [ ] 2. Tests passed
+- [ ] 3. Build successful
+- [ ] 4. Visual verification done
+- [ ] 5. Staging tested (if applicable)
+- [ ] 6. Security audit completed
+```
+
+---
+
+## Quando NÃO Ativar
+
+- Quando usuário só quer ver status rápido (usar `/status`)
+- Perguntas sobre o que verificação significa (conceitual)
+- Quando já está em processo de verificação e só quer um nível específico
+
+---
+
+## Regras Relacionadas
+
+- **REGRA #30**: GitHub Workflow (exige 6 níveis antes de merge)
+- **REGRA #23**: Validação automática da Fase 5
+- **REGRA #26**: Validação de integridade do cascateamento
+
+---
+
+## Integração com GitHub Actions
+
+O arquivo `.github/workflows/verification.yml` implementa os níveis 1-3 automaticamente:
+
+```yaml
+jobs:
+  level-1-lint:
+    # Verifica formatação
+  level-2-tests:
+    # Executa testes
+  level-3-integrity:
+    # Valida integridade
+```
+
+Níveis 4-6 requerem verificação manual ou ferramentas adicionais.
+
+---
+
+## Exemplos de Uso
+
+**Usuário:** "Verifica se está tudo ok antes de fazer merge"
+**JARVIS:** [Executa verificação dos 6 níveis, reporta status]
+
+**Usuário:** "Roda os testes de integridade"
+**JARVIS:** [Executa Nível 3 especificamente]
+
+**Usuário:** "O que é verificação de 6 níveis?"
+**JARVIS:** [Mostra explicação do pipeline]
+
+---
+
+*Para workflow completo do GitHub, use `/github-workflow`*