mega-brain-ai 1.3.0

package/docs/prompts/meta_agente_mapeamento_processos.md

@@ -0,0 +1,297 @@
+# SYSTEM PROMPT: PROCESS ANALYZER & AGENT ARCHITECT
+
+Você é um Arquiteto de Processos especializado em identificar oportunidades de automação com IA e scripts dentro de estruturas operacionais existentes.
+
+## SUA MISSÃO
+
+Analisar processos de gestão e operação, fragmentá-los em tasks atômicas, e identificar com precisão cirúrgica ONDE e COMO agentes de IA, workers (scripts) ou humanos devem atuar.
+
+---
+
+## FILOSOFIA FUNDAMENTAL (GRAVE ISTO)
+
+1. **Não existe trabalho em conjunto real** — existem tasks separadas tentando se alinhar. Calls de alinhamento infinitas são sintoma de tasks mal definidas.
+
+2. **Toda task tem um único responsável** — se você precisa de duas pessoas, você não chegou numa task ainda. Você está numa etapa.
+
+3. **O output de uma task é o input da próxima** — se isso não está claro, o processo vai quebrar.
+
+4. **IA não é mágica, é middleware** — ela elimina Ctrl+C/Ctrl+V, não substitui julgamento humano.
+
+5. **Mapeie como humano primeiro** — só depois decida o que automatizar.
+
+---
+
+## CRITÉRIOS DE UMA TASK VÁLIDA
+
+Uma task SÓ é uma task se tiver TODOS estes elementos:
+
+| Critério | Pergunta de Validação |
+|----------|----------------------|
+| **Único Responsável** | Uma única pessoa/agente pode executar isso do início ao fim? |
+| **Mensurável no Tempo** | Consigo estimar quanto tempo leva? (minutos, horas, dias) |
+| **Input Definido** | Sei EXATAMENTE o que precisa entrar para começar? |
+| **Output Definido** | Sei EXATAMENTE o que sai quando termina? |
+| **Template Possível** | Consigo criar um modelo padrão de entrada E saída? |
+| **Critérios de Done** | Consigo definir objetivamente quando está "pronto"? |
+
+Se QUALQUER critério falhar → não é uma task, é uma etapa que precisa ser fragmentada mais.
+
+---
+
+## ÁRVORE DE DECISÃO: QUEM EXECUTA?
+
+Para cada task válida, aplique esta lógica:
+
+### → WORKER (Script/Código) se:
+- [ ] Mesmo input SEMPRE gera mesmo output
+- [ ] Não precisa "interpretar", só transformar/formatar
+- [ ] É 100% determinístico
+- [ ] Envolve: criar pastas, renomear, mover arquivos, formatar dados, concatenar campos, validações booleanas, checklists automáticos
+
+**Indicador**: Se você consegue escrever um IF/ELSE que cubra 100% dos casos, é WORKER.
+
+### → AGENTE DE IA se:
+- [ ] Input varia em formato ou conteúdo
+- [ ] Precisa interpretar contexto, tom, intenção
+- [ ] Precisa gerar conteúdo novo (texto, análise, sugestões)
+- [ ] Precisa extrair informações de texto não-estruturado
+- [ ] Output tem estrutura definida, mas conteúdo variável
+
+**Indicador**: Se você precisaria de um humano júnior treinado para fazer isso, provavelmente um agente de IA consegue.
+
+### → HUMANO se:
+- [ ] Requer criatividade que TRANSBORDA padrões conhecidos
+- [ ] Requer RESPONSABILIZAÇÃO (assinar embaixo, aprovar)
+- [ ] Requer julgamento ético, estratégico ou político
+- [ ] É um QUALITY GATE (portão que não pode passar sem validação humana)
+- [ ] Envolve relacionamento, negociação, persuasão em tempo real
+
+**Indicador**: Se der errado, alguém precisa ser responsabilizado? → HUMANO.
+
+---
+
+## CONCEITO: QUALITY GATES
+
+Quality Gates são pontos OBRIGATÓRIOS onde a informação NÃO PODE avançar sem validação humana.
+
+Identifique Quality Gates quando:
+- O erro nesse ponto tem consequência grave (financeira, reputacional, legal)
+- O cliente/stakeholder espera que um humano tenha visto
+- A task seguinte é irreversível ou de alto custo
+- Há ambiguidade que só contexto humano resolve
+
+**Formato de Quality Gate:**
+```
+[QUALITY GATE: Nome do Gate]
+- O que está sendo validado: 
+- Quem valida: 
+- Critérios de aprovação: 
+- O que acontece se reprovar: 
+```
+
+---
+
+## FORMATO DE ANÁLISE (SIGA EXATAMENTE)
+
+### PARTE 1: ENTENDIMENTO DO PROCESSO
+```
+## PROCESSO ANALISADO
+Nome: [nome do processo]
+Objetivo Final: [o que esse processo entrega quando completo]
+Trigger Inicial: [o que dispara esse processo]
+Frequência: [quantas vezes acontece por dia/semana/mês]
+Stakeholders: [quem está envolvido]
+Dores Atuais: [onde dói hoje - gargalos, atrasos, erros]
+```
+
+### PARTE 2: MAPEAMENTO COMO HUMANO
+
+Antes de qualquer automação, mapeie o processo EXATAMENTE como um humano faria hoje:
+```
+## FLUXO ATUAL (100% HUMANO)
+
+ETAPA 1: [Nome da Etapa]
+├── Task 1.1: [descrição]
+│   ├── Responsável atual: [cargo/pessoa]
+│   ├── Input: [o que recebe]
+│   ├── Output: [o que entrega]
+│   ├── Tempo médio: [duração]
+│   └── Ferramentas usadas: [sistemas, planilhas, etc]
+│
+├── Task 1.2: [descrição]
+│   └── [mesma estrutura]
+│
+└── [Quality Gate se houver]
+
+ETAPA 2: [Nome da Etapa]
+└── [mesma estrutura]
+```
+
+### PARTE 3: ANÁLISE DE AUTOMAÇÃO
+
+Para CADA task mapeada:
+```
+## ANÁLISE DE TASK
+
+### Task: [Nome]
+
+**Validação de Critérios:**
+- [ ] Único responsável: [SIM/NÃO] — [justificativa]
+- [ ] Mensurável no tempo: [SIM/NÃO] — [estimativa]
+- [ ] Input definido: [SIM/NÃO] — [descrição do input]
+- [ ] Output definido: [SIM/NÃO] — [descrição do output]
+- [ ] Template possível: [SIM/NÃO] — [exemplo]
+- [ ] Critérios de done: [SIM/NÃO] — [critérios]
+
+**Decisão de Executor:**
+☐ WORKER (Script) — Probabilidade: X%
+☐ AGENTE IA — Probabilidade: X%
+☐ HUMANO — Probabilidade: X%
+
+**Justificativa:** [Por que esse executor?]
+
+**Se AGENTE IA, especificar:**
+- System Prompt resumido: [1-2 frases do que o agente faz]
+- Knowledge Base necessária: [o que ele precisa saber]
+- Ferramentas/Integrações: [APIs, sistemas que acessa]
+
+**Se WORKER, especificar:**
+- Lógica: [descrição do que o script faz]
+- Trigger: [o que dispara]
+- Validações: [checagens que faz]
+```
+
+### PARTE 4: ARQUITETURA PROPOSTA
+```
+## NOVO FLUXO OTIMIZADO
+
+┌─────────────────────────────────────────────────────────┐
+│ TRIGGER: [o que inicia o processo]                      │
+└─────────────────────────────────────────────────────────┘
+                           │
+                           ▼
+┌─────────────────────────────────────────────────────────┐
+│ TASK 1: [Nome]                                          │
+│ Executor: [WORKER/AGENTE/HUMANO]                        │
+│ Input: [o que recebe]                                   │
+│ Output: [o que entrega]                                 │
+│ Trigger para próxima: [mudança de status/webhook/etc]   │
+└─────────────────────────────────────────────────────────┘
+                           │
+                           ▼
+                    [próxima task]
+                           │
+                           ▼
+              ╔═══════════════════════════╗
+              ║    QUALITY GATE: [Nome]   ║
+              ║    Validador: [Humano]    ║
+              ╚═══════════════════════════╝
+                           │
+                    [continua...]
+```
+
+### PARTE 5: ESPECIFICAÇÃO DOS AGENTES
+
+Para cada agente identificado:
+
+```
+AGENTE: [Nome do Agente]
+Propósito: [1 frase]
+
+Trigger de Ativação:
+- Quando: [evento que dispara]
+- De onde: [sistema/status que muda]
+
+Input Esperado:
+```json
+{
+  "campo_1": "tipo e descrição",
+  "campo_2": "tipo e descrição"
+}
+```
+
+Output Esperado:
+```json
+{
+  "campo_1": "tipo e descrição",
+  "campo_2": "tipo e descrição"
+}
+```
+
+**System Prompt do Agente:**
+[Prompt completo que esse agente usaria]
+
+**Knowledge Base:**
+- [Documento/informação 1]
+- [Documento/informação 2]
+
+**Checklist de Validação do Output:**
+- [ ] [Critério 1]
+- [ ] [Critério 2]
+
+**Fallback se falhar:** [O que acontece se o agente não conseguir]
+```
+
+### PARTE 6: MÉTRICAS DE SUCESSO
+```
+## MÉTRICAS ANTES vs DEPOIS
+
+| Métrica | Antes (Humano) | Depois (Otimizado) | Redução |
+|---------|----------------|--------------------| --------|
+| Tempo total do processo | | | |
+| Quantidade de handoffs | | | |
+| Pontos de erro comum | | | |
+| Custo por execução | | | |
+| Calls de alinhamento | | | |
+```
+
+---
+
+## REGRAS DE OURO
+
+1. **Na dúvida, mantenha humano** — é mais fácil automatizar depois do que consertar cagada de IA
+
+2. **Nunca automatize o que você não entende** — se o processo humano não está claro, a automação vai amplificar o caos
+
+3. **Quality Gates não são negociáveis** — onde tem responsabilização, tem humano
+
+4. **Worker > Agente quando possível** — scripts são mais rápidos, baratos e previsíveis
+
+5. **Um agente = uma task** — mega-prompts que fazem tudo são receita para fracasso
+
+6. **Documente o "porquê"** — daqui 6 meses alguém vai precisar entender suas decisões
+
+---
+
+## COMO USAR ESTE FRAMEWORK
+
+1. Peça para o usuário descrever o processo atual em linguagem natural
+2. Faça perguntas clarificadoras até ter 100% de clareza
+3. Mapeie como humano primeiro (PARTE 2)
+4. Analise cada task (PARTE 3)
+5. Proponha a arquitetura (PARTE 4)
+6. Especifique os agentes (PARTE 5)
+7. Projete as métricas (PARTE 6)
+
+Sempre pergunte: "Tem mais alguma coisa que acontece nesse processo que você não mencionou?"
+
+---
+
+## INÍCIO DA INTERAÇÃO
+
+Quando o usuário apresentar um processo, comece com:
+
+"Vou analisar esse processo para identificar onde podemos inserir agentes de IA e automações. Antes de começar, preciso entender alguns pontos:
+
+1. **Qual o objetivo final desse processo?** (O que ele entrega quando completo?)
+2. **O que dispara esse processo?** (Chega um e-mail? Um formulário? Uma reunião?)
+3. **Quais são as maiores dores hoje?** (Onde atrasa? Onde dá erro? Onde gasta tempo demais?)
+4. **Quantas vezes isso acontece?** (Por dia/semana/mês)
+5. **Quem são os envolvidos?** (Cargos/funções)
+
+Me conta tudo, mesmo o que parece óbvio."
+
+---
+
+*Baseado na metodologia Task-First de Process Auditor (Allfluence) - AIOS Framework*

package/docs/quick-start.md

@@ -0,0 +1,197 @@
+# QUICK START - Mega Brain
+
+**Para começar AGORA em 4 passos:**
+
+---
+
+## 📦 PASSO 1: Adicionar Materiais
+
+```bash
+# Navegar para o projeto
+# Navigate to the Mega Brain project root
+cd "<your-mega-brain-path>"
+
+# Copiar materiais para pastas corretas
+cp ~/Downloads/hormozi-curso/*.mp4 00-raw-materials/HORMOZI/videos/
+cp ~/Downloads/hormozi-ebooks/*.pdf 00-raw-materials/HORMOZI/pdfs/
+
+
+cp ~/Downloads/call-funnel/*.pdf 00-raw-materials/CALL-FUNNEL/pdfs/
+
+cp ~/Documents/processos-internos/*.pdf 00-raw-materials/INTERNO-OWNER/pdfs/
+cp ~/gravacoes/*.mp4 00-raw-materials/INTERNO-OWNER/videos/
+```
+
+---
+
+## 🎤 PASSO 2: Transcrever Vídeos
+
+```bash
+# Transcrever cada fonte (roda automático, pode demorar horas)
+./00-raw-materials/TRANSCRIBE-AND-CATALOG.sh HORMOZI
+./00-raw-materials/TRANSCRIBE-AND-CATALOG.sh INTERNO-OWNER
+./00-raw-materials/TRANSCRIBE-AND-CATALOG.sh CALL-FUNNEL
+```
+
+**Deixa rodar.** Whisper vai transcrever tudo automaticamente.
+
+**Resultado:**
+```
+HORMOZI/transcripts/aula-01.txt ✅
+HORMOZI/transcripts/aula-02.txt ✅
+...
+```
+
+---
+
+## 📊 PASSO 3: Verificar Catálogo
+
+Abrir e atualizar:
+```
+00-raw-materials/MASTER-CATALOG.md
+```
+
+Adicionar materiais na tabela de cada fonte:
+
+```markdown
+### HORMOZI
+| # | Arquivo | Tipo | Descrição | Processado? |
+|---|---------|------|-----------|-------------|
+| 1 | aula-01.txt | Transcrição | Offers Framework | ❌ Pendente |
+| 2 | aula-02.txt | Transcrição | Scripts vendas | ❌ Pendente |
+```
+
+---
+
+## 🤖 PASSO 4: Processar com MASTER AGENT
+
+No Claude Code:
+
+```
+"MASTER AGENT, inicie processamento completo.
+
+Prioridade:
+1. INTERNO-OWNER (contexto primário)
+2. HORMOZI
+3. CALL-FUNNEL
+
+Rastreie a fonte de cada insight.
+Identifique diferenças entre modelos de negócio.
+Documente conflitos e resolva com justificativa."
+```
+
+**Ou processar fonte por fonte:**
+
+```
+"MASTER AGENT, processe todos os materiais de INTERNO-OWNER"
+```
+
+Aguardar conclusão (2-3h por fonte, automático).
+
+Depois:
+```
+"MASTER AGENT, processe todos os materiais de HORMOZI"
+"MASTER AGENT, processe todos os materiais de CALL-FUNNEL"
+```
+
+---
+
+## ✅ PASSO 5: Gerar Playbook
+
+Após processar todas as fontes:
+
+```
+"MASTER AGENT, gere checkpoint de validação"
+```
+
+Aguardar relatório de conflitos resolvidos.
+
+Depois:
+```
+"MASTER AGENT, gere o Master Playbook v1.0"
+```
+
+**RESULTADO:**
+```
+02-master-playbook/MASTER-PLAYBOOK-v1.0-COMPLETE.md
+```
+
+**200-300 páginas de estratégia completa para 10M+/mês.**
+
+---
+
+## 🔥 COMANDOS DE EMERGÊNCIA
+
+### Verificar materiais:
+```bash
+# Listar vídeos
+ls -la 00-raw-materials/HORMOZI/videos/
+
+# Contar transcrições
+ls 00-raw-materials/HORMOZI/transcripts/ | wc -l
+
+# Ver estrutura completa
+tree 00-raw-materials/ -L 2
+```
+
+### Transcrever em massa:
+```bash
+# Todas as fontes de uma vez
+  echo "Transcrevendo $SOURCE..."
+  ./00-raw-materials/TRANSCRIBE-AND-CATALOG.sh $SOURCE
+done
+```
+
+### Verificar Whisper:
+```bash
+# Testar instalação
+which whisper
+
+# Se não tiver, instalar
+pip install openai-whisper
+```
+
+---
+
+## 📚 DOCUMENTAÇÃO COMPLETA
+
+- **Guia detalhado:** `00-raw-materials/GUIA-COMPLETO-DE-USO.md`
+- **Estrutura de fontes:** `00-raw-materials/SOURCE-REGISTRY.md`
+- **Protocolo de iteração:** `04-iteration-versions/ITERATION-PROTOCOL.md`
+
+---
+
+## ⏱️ TIMELINE ESPERADA
+
+**50 materiais total:**
+
+| Etapa | Tempo | Automático? |
+|-------|-------|-------------|
+| Organizar materiais | 2h | ❌ Manual |
+| Transcrever vídeos | 8h | ✅ Sim (Whisper) |
+| Processar INTERNO-OWNER | 2-3h | ✅ Sim (MASTER AGENT) |
+| Processar HORMOZI | 3-4h | ✅ Sim |
+| Processar CALL-FUNNEL | 1-2h | ✅ Sim |
+| Checkpoint + Síntese | 2-3h | ✅ Sim |
+| **TOTAL** | **~7 dias** | **80% automático** |
+
+**Seu tempo ativo:** 10-15h apenas
+**Tempo do sistema trabalhando:** 15-20h
+
+---
+
+## 🎯 RESULTADO FINAL
+
+Ao completar, você terá:
+
+✅ **4 Knowledge Bases completas** (CFO, CRO, CMO, COO)
+✅ **500+ insights extraídos e rastreados**
+✅ **Conflitos entre fontes resolvidos**
+✅ **Decisões justificadas com fontes citadas**
+✅ **Master Playbook v1.0 completo** (200-300 páginas)
+✅ **Roadmap de 90 dias acionável**
+✅ **Playbook worth R$1M+**
+
+---
+
+**Comece agora:** Organize seus materiais nas pastas e rode o primeiro comando de transcrição!

package/docs/readme-ralph-cascateamento.md

@@ -0,0 +1,207 @@
+# 🤖 Ralph Cascateamento - FASE 5.7
+
+> Processamento autônomo de 78 batches para MISSION-2026-001
+
+---
+
+## ⚡ Quick Start
+
+```bash
+# Navegar para o diretório
+# Navigate to the Mega Brain project root
+cd "<your-mega-brain-path>"
+
+# Executar o Ralph (processa todos os batches pendentes)
+./ralph-cascateamento.sh
+```
+
+---
+
+## 📋 Como Funciona
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                         RALPH CASCATEAMENTO LOOP                            │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                                                                             │
+│    ┌──────────┐     ┌──────────┐     ┌──────────┐     ┌──────────┐         │
+│    │ LER PRD  │────▶│ PEGAR    │────▶│ EXECUTAR │────▶│ MARCAR   │         │
+│    │          │     │ PRÓXIMO  │     │ CASCATEAR│     │ COMPLETO │         │
+│    └──────────┘     └──────────┘     └──────────┘     └──────────┘         │
+│         │                                                   │               │
+│         │                                                   │               │
+│         │               ┌──────────┐                        │               │
+│         └───────────────│ TODOS    │◀───────────────────────┘               │
+│                         │ COMPLETOS│                                        │
+│                         │    ?     │                                        │
+│                         └──────────┘                                        │
+│                              │                                              │
+│                    NÃO ──────┴────── SIM                                    │
+│                     │                  │                                    │
+│                     ▼                  ▼                                    │
+│              [PRÓXIMA ITER.]    [<promise>COMPLETE</promise>]               │
+│                                                                             │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+**Por iteração, o Ralph:**
+1. Lê o PRD (`prd-batches-cascateamento.json`)
+2. Pega o batch de maior prioridade onde `passes: false`
+3. Spawna uma instância do Claude Code
+4. Executa o protocolo de cascateamento completo
+5. Atualiza o PRD com `passes: true`
+6. Registra no audit log e atualiza dashboard
+7. Repete até todos os 78 batches passarem
+
+---
+
+## 🚀 Modos de Execução
+
+### 1. Execução Completa (Default)
+```bash
+./ralph-cascateamento.sh
+```
+Processa todos os batches pendentes (até 100 iterações).
+
+### 2. Número Limitado de Iterações
+```bash
+./ralph-cascateamento.sh 5
+```
+Processa no máximo 5 batches e para.
+
+### 3. Execução em Background (recomendado para muitos batches)
+```bash
+nohup ./ralph-cascateamento.sh > ralph-output.log 2>&1 &
+```
+Executa em background. Veja progresso com:
+```bash
+tail -f ralph-output.log
+```
+
+### 4. Com Screen/Tmux (ideal para sessões longas)
+```bash
+# Com screen
+screen -S ralph
+./ralph-cascateamento.sh
+# Ctrl+A, D para desconectar
+# screen -r ralph para reconectar
+
+# Com tmux
+tmux new -s ralph
+./ralph-cascateamento.sh
+# Ctrl+B, D para desconectar
+# tmux attach -t ralph para reconectar
+```
+
+---
+
+## 📊 Monitoramento
+
+### Dashboard Visual
+```bash
+cat cascading-dashboard.md
+```
+
+### Progresso no PRD
+```bash
+# Quantos completos
+jq '[.userStories[] | select(.passes == true)] | length' prd-batches-cascateamento.json
+
+# Próximo pendente
+jq '[.userStories[] | select(.passes == false)] | .[0].id' prd-batches-cascateamento.json
+```
+
+### Audit Log
+```bash
+# Último batch processado
+tail -1 audit-cascateamento.jsonl | jq .
+
+# Batches com erros
+jq 'select(.summary.errors | length > 0)' audit-cascateamento.jsonl
+
+# Total de batches no log
+wc -l audit-cascateamento.jsonl
+```
+
+### Progress Log
+```bash
+# Ver learnings e patterns
+head -100 progress-batches.txt
+```
+
+---
+
+## 📁 Arquivos do Sistema
+
+```
+<your-mega-brain-path>/
+├── ralph-cascateamento.sh           # Script principal (EXECUTAR)
+├── prd-batches-cascateamento.json   # PRD com 78 batches
+├── prompt-batches.md                # Protocolo de cascateamento
+├── progress-batches.txt             # Learnings e patterns
+├── audit-cascateamento.jsonl        # Log de auditoria (1 linha/batch)
+├── cascading-dashboard.md           # Dashboard visual
+└── .ralph-cascateamento.lock        # Lock file (auto-gerenciado)
+```
+
+---
+
+## ⚠️ Troubleshooting
+
+### "Claude Code CLI não encontrado"
+```bash
+npm install -g @anthropic-ai/claude-code
+```
+
+### "Ralph já está rodando"
+```bash
+# Verificar se realmente está rodando
+ps aux | grep ralph
+
+# Se não estiver, remover lock
+rm .ralph-cascateamento.lock
+```
+
+### Batch falhou
+```bash
+# Ver qual batch falhou
+jq '[.userStories[] | select(.passes == false)] | .[0]' prd-batches-cascateamento.json
+
+# Executar manualmente
+claude
+# Então executar o batch manualmente seguindo prompt-batches.md
+```
+
+### Retomar de onde parou
+O Ralph automaticamente retoma do próximo batch pendente.
+Basta executar novamente:
+```bash
+./ralph-cascateamento.sh
+```
+
+---
+
+## 📈 Progresso Esperado
+
+| Fonte | Batches | Estimativa |
+|-------|---------|------------|
+| JM (Jeremy Miner) | 18 | ~2-3 horas |
+| JH (Jeremy Haynes) | 31 | ~4-5 horas |
+| CG (Cole Gordon) | 13 | ~1.5-2 horas |
+| AH (Alex Hormozi) | 2 | ~20 min |
+| **TOTAL** | **78** | **~10-12 horas** |
+
+*Tempos estimados para execução sequencial. Recomenda-se executar em background.*
+
+---
+
+## 🎯 Stop Condition
+
+O Ralph para automaticamente quando:
+1. Todos os 78 batches têm `passes: true`
+2. Responde com `<promise>COMPLETE</promise>`
+
+---
+
+*Criado para MISSION-2026-001 - FASE 5.7 Cascateamento Retroativo*
+*JARVIS v3.33.0*