mega-brain-ai 1.1.0

package/.claude/skills/08-SKILL-EXECUTING-PLANS/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: 08-SKILL-EXECUTING-PLANS
+description: Use quando tiver um plano de processamento para executar com checkpoints de revisão
+---
+
+> **Auto-Trigger:** Executar plano de processamento, implementar pipeline com checkpoints
+> **Keywords:** "executar", "plano", "execução", "pipeline", "checkpoint", "batch", "jarvis"
+> **Prioridade:** ALTA
+
+---
+
+# Executing Plans - Mega Brain
+
+## Overview
+
+Carrega plano, revisa criticamente, executa tarefas em batches, reporta para revisão entre batches.
+
+**Princípio central:** Execução em batch com checkpoints para revisão do usuário.
+
+**Anunciar no início:** "Estou usando a skill executing-plans para implementar este plano."
+
+## O Processo
+
+### Step 1: Carregar e Revisar Plano
+1. Ler arquivo do plano (geralmente em `knowledge/playbooks/drafts/`)
+2. Revisar criticamente - identificar questões ou preocupações
+3. Se houver preocupações: Levantar antes de começar
+4. Se ok: Criar TodoWrite e prosseguir
+
+### Step 2: Executar Batch
+**Default: Primeiras 3 tarefas**
+
+Para cada tarefa:
+1. Marcar como in_progress
+2. Seguir cada passo exatamente
+3. Executar verificações conforme especificado
+4. Marcar como completed
+
+### Step 3: Reportar
+Quando batch completo:
+```
+┌─ BATCH N COMPLETO ─────────────────────────────────────────────────────┐
+│                                                                         │
+│  ✅ TAREFAS CONCLUÍDAS:                                                │
+│  ├─ [Tarefa 1]: [resultado]                                            │
+│  ├─ [Tarefa 2]: [resultado]                                            │
+│  └─ [Tarefa 3]: [resultado]                                            │
+│                                                                         │
+│  📊 VERIFICAÇÕES:                                                       │
+│  ├─ [verificação 1]: ✅                                                 │
+│  └─ [verificação 2]: ✅                                                 │
+│                                                                         │
+│  Pronto para feedback.                                                 │
+│                                                                         │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+### Step 4: Continuar
+Baseado no feedback:
+- Aplicar mudanças se necessário
+- Executar próximo batch
+- Repetir até completar
+
+### Step 5: Completar Processamento
+
+Após todas tarefas completas e verificadas:
+- Atualizar SESSION-STATE.md
+- Atualizar EVOLUTION-LOG.md se houve mudança estrutural
+- Seguir regras de fim de sessão do CLAUDE.md
+
+## Quando Parar e Pedir Ajuda
+
+**PARAR execução imediatamente quando:**
+- Encontrar blocker mid-batch (dependência faltando, verificação falha)
+- Plano tem gaps críticos que impedem começar
+- Não entender uma instrução
+- Verificação falha repetidamente
+
+**Pedir clarificação ao invés de adivinhar.**
+
+## Contexto Mega Brain
+
+### Tipos de Planos
+
+| Tipo de Plano | Exemplo |
+|---------------|---------|
+| Processamento INBOX | "Processar 5 arquivos novos via Jarvis" |
+| Criação de Agente | "Criar agente SALES-COORDINATOR" |
+| Reestruturação | "Migrar THEMES para SOURCES" |
+| Batch Council | "Deliberar 3 decisões estratégicas" |
+
+### Integrações com Pipeline Jarvis
+
+Ao executar planos de processamento:
+- Steps 1.1-2.1: Podem rodar em paralelo (usar dispatching-parallel-agents)
+- Steps 3.1-4.0: Consolidação (rodar sequencialmente)
+- Steps 8.7-8.10: Finalização e logs inteligentes
+
+### Checkpoints Obrigatórios
+
+| Após Step | Checkpoint |
+|-----------|------------|
+| 2.1 (Insights) | Revisar insights extraídos |
+| 4.0 (Dossiers) | Revisar dossiês gerados |
+| 8.8 (Briefing) | Apresentar briefing executivo |
+
+## Lembrar
+
+- Revisar plano criticamente primeiro
+- Seguir passos do plano exatamente
+- Não pular verificações
+- Entre batches: reportar e aguardar
+- Parar quando bloqueado, não adivinhar
+- Atualizar SESSION-STATE após completar

package/.claude/skills/09-SKILL-WRITING-PLANS/SKILL.md

@@ -0,0 +1,184 @@
+---
+name: 09-SKILL-WRITING-PLANS
+description: Use quando tiver spec ou requirements para tarefa multi-step, antes de executar
+---
+
+> **Auto-Trigger:** Spec ou requirements para tarefa multi-step, antes de executar
+> **Keywords:** "plano", "planejamento", "planning", "escrever", "spec", "requirements"
+> **Prioridade:** MÉDIA
+
+---
+
+# Writing Plans - Mega Brain
+
+## Overview
+
+Escreve planos de implementação compreensivos assumindo que o executor tem zero contexto sobre o projeto. Documenta tudo que precisa saber: quais arquivos tocar, passos exatos, verificações, como testar.
+
+**Anunciar no início:** "Estou usando a skill writing-plans para criar o plano de implementação."
+
+**Salvar planos em:** `knowledge/playbooks/drafts/YYYY-MM-DD-<nome-feature>.md`
+
+## Granularidade de Tasks
+
+**Cada passo é uma ação (2-5 minutos):**
+- "Verificar arquivos no INBOX" - step
+- "Rodar Jarvis Step 1.1" - step
+- "Verificar chunks gerados" - step
+- "Rodar Jarvis Step 2.1" - step
+- "Verificar insights" - step
+
+## Header do Plano
+
+**Todo plano DEVE começar com:**
+
+```markdown
+# [Nome da Feature] - Plano de Implementação
+
+**Objetivo:** [Uma frase descrevendo o que será construído]
+
+**Arquitetura:** [2-3 frases sobre a abordagem]
+
+**Dependências:** [Protocolos, arquivos, skills necessárias]
+
+---
+```
+
+## Estrutura de Task
+
+```markdown
+### Task N: [Nome do Componente]
+
+**Arquivos:**
+- Criar: `path/exato/arquivo.md`
+- Modificar: `path/exato/existente.json`
+- Verificar: `path/exato/output/`
+
+**Step 1: Verificar pré-condições**
+
+- Checar se `inbox/` tem arquivos pendentes
+- Verificar SESSION-STATE.md
+
+**Step 2: Executar processamento**
+
+```bash
+# Comando exato ou descrição da ação
+```
+
+**Step 3: Verificar output**
+
+- Checar se chunks foram gerados
+- Validar JSON de estado
+
+**Step 4: Atualizar registros**
+
+- Atualizar SESSION-STATE.md
+- Marcar arquivo como processado
+```
+
+## Tipos de Planos Mega Brain
+
+### 1. Plano de Processamento INBOX
+
+```markdown
+### Task 1: Scan INBOX
+
+**Arquivos:**
+- Input: `inbox/**/*.txt`
+- Output: Lista de arquivos pendentes
+
+**Step 1:** Listar arquivos não processados
+**Step 2:** Categorizar por fonte (Hormozi, Cole Gordon, etc.)
+**Step 3:** Priorizar por relevância
+
+---
+
+### Task 2: Processar [ARQUIVO]
+
+**Arquivos:**
+- Input: `inbox/[PATH]/arquivo.txt`
+- Output: `processing/chunks/[ID].json`
+
+**Step 1:** Rodar Jarvis Step 1.1 (Chunking)
+**Step 2:** Verificar chunks gerados
+**Step 3:** Rodar Jarvis Step 2.1 (Insights)
+**Step 4:** Verificar insights extraídos
+```
+
+### 2. Plano de Criação de Agente
+
+```markdown
+### Task 1: Definir SOUL
+
+**Arquivos:**
+- Criar: `agents/[AREA]/[CARGO]/SOUL.md`
+- Referência: `agents/_TEMPLATES/SOUL-TEMPLATE.md`
+
+**Step 1:** Copiar template
+**Step 2:** Preencher dados do cargo
+**Step 3:** Validar citações de fonte
+
+---
+
+### Task 2: Criar MEMORY
+
+**Arquivos:**
+- Criar: `agents/[AREA]/[CARGO]/MEMORY.md`
+- Input: `knowledge/SOURCES/[PESSOA]/`
+
+**Step 1:** Buscar insights relevantes
+**Step 2:** Estruturar MEMORY com chunk_ids
+**Step 3:** Validar rastreabilidade
+```
+
+### 3. Plano de Reestruturação
+
+```markdown
+### Task 1: Backup
+
+**Arquivos:**
+- Backup: `system/BACKUPS/YYYY-MM-DD/`
+
+**Step 1:** Criar pasta de backup
+**Step 2:** Copiar arquivos afetados
+**Step 3:** Verificar backup completo
+
+---
+
+### Task 2: Migrar [COMPONENTE]
+
+**Arquivos:**
+- De: `[PATH_ANTIGO]/`
+- Para: `[PATH_NOVO]/`
+
+**Step 1:** Criar estrutura nova
+**Step 2:** Mover arquivos
+**Step 3:** Atualizar referências em CLAUDE.md
+**Step 4:** Validar integridade
+```
+
+## Lembrar
+
+- Paths exatos sempre
+- Comandos completos no plano
+- Cada step verificável
+- Referenciar protocolos relevantes
+- Incluir verificações após cada step
+
+## Execution Handoff
+
+Após salvar o plano, oferecer escolha:
+
+**"Plano completo e salvo em `knowledge/playbooks/drafts/<filename>.md`. Duas opções:**
+
+**1. Execução Subagente (esta sessão)** - Dispatch agente por task, review entre tasks
+
+**2. Execução Direta (esta sessão)** - Executar tasks sequencialmente com checkpoints
+
+**Qual abordagem?"**
+
+**Se Execução Subagente:**
+- Usar skill: dispatching-parallel-agents
+
+**Se Execução Direta:**
+- Usar skill: executing-plans

package/.claude/skills/10-SKILL-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/11-SKILL-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.