mega-brain-ai 1.1.0

package/.claude/skills/05-SKILL-PIPELINE-JARVIS/SKILL.md

@@ -0,0 +1,430 @@
+# SKILL-PIPELINE-JARVIS
+## Padrões do Pipeline de Processamento Jarvis
+
+> **Auto-Trigger:** Processamento de novo material, comando /process
+> **Keywords:** "processar", "pipeline", "jarvis", "novo material", "inbox"
+> **Prioridade:** ALTA
+
+---
+
+## PROPÓSITO
+
+Garantir que todo processamento via Pipeline Jarvis siga:
+- As 8 fases obrigatórias
+- Checkpoints de validação
+- Logs estruturados
+- Integração completa
+
+---
+
+## QUANDO USAR
+
+### ✅ USAR quando:
+- Processar qualquer material novo
+- Executar /process ou /scan-inbox
+- Material entra no inbox
+- Reprocessar material existente
+
+### ❌ NÃO USAR quando:
+- Consultas (queries ao RAG)
+- Criação manual de documentos
+- Operações que não envolvem novo conteúdo
+
+---
+
+## AS 8 FASES DO PIPELINE
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                     PIPELINE JARVIS                              │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  FASE 1: INITIALIZATION                                          │
+│  └── Validação, setup, identificação de fonte                   │
+│                                                                  │
+│  FASE 2: CHUNKING                                                │
+│  └── Segmentação semântica do conteúdo                          │
+│                                                                  │
+│  FASE 3: ENTITY RESOLUTION                                       │
+│  └── Canonicalização de entidades                               │
+│                                                                  │
+│  FASE 4: INSIGHT EXTRACTION                                      │
+│  └── Extração com tags DNA                                      │
+│                                                                  │
+│  FASE 5: NARRATIVE SYNTHESIS                                     │
+│  └── Síntese narrativa coerente                                 │
+│                                                                  │
+│  FASE 6: DOSSIER COMPILATION                                     │
+│  └── Compilação de dossiês                                      │
+│                                                                  │
+│  FASE 6.6: SOURCES COMPILATION                                   │
+│  └── Compilação pessoa + tema                                   │
+│                                                                  │
+│  FASE 7: AGENT ENRICHMENT                                        │
+│  └── Alimentação dos agentes                                    │
+│                                                                  │
+│  FASE 8: FINALIZATION                                            │
+│  └── Relatório, logs, cleanup                                   │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## FASE 1: INITIALIZATION
+
+### Input
+- Arquivo em `inbox/[FONTE]/`
+- URL de vídeo
+- Documento anexado
+
+### Validações
+```python
+checklist = {
+    "arquivo_existe": True,
+    "formato_suportado": True,  # .mp4, .pdf, .txt, .md, .docx
+    "tamanho_ok": True,         # < 500MB
+    "fonte_identificada": True,  # Quem é o autor?
+    "id_gerado": True           # Ex: CG004, AH-HR002
+}
+```
+
+### Output
+```json
+{
+  "source_id": "CG004",
+  "source_type": "video",
+  "source_person": "Cole Gordon",
+  "source_company": "Cole Gordon",
+  "original_path": "/inbox/cole-gordon/video.mp4",
+  "estimated_duration": "45:00",
+  "status": "ready_for_processing"
+}
+```
+
+### Checkpoint
+```
+✅ FASE 1 COMPLETA
+├── Source ID: CG004
+├── Tipo: Video (45min)
+├── Pessoa: Cole Gordon
+└── Status: Pronto para chunking
+```
+
+---
+
+## FASE 2: CHUNKING
+
+### Regras de Segmentação
+
+| Critério | Valor |
+|----------|-------|
+| Tamanho mínimo | 200 caracteres |
+| Tamanho máximo | 1000 caracteres |
+| Overlap | 50 caracteres |
+| Break natural | Pausa > 2s, mudança de tema |
+
+### Processo
+1. Transcrever (se áudio/vídeo)
+2. Identificar breaks naturais
+3. Segmentar respeitando limites
+4. Manter contexto suficiente
+5. Registrar timestamps
+
+### Output
+```json
+{
+  "source_id": "CG004",
+  "total_chunks": 127,
+  "chunks": [
+    {
+      "chunk_id": "CG004-CHK-001",
+      "start_time": "00:00:00",
+      "end_time": "00:00:45",
+      "content": "Texto do chunk...",
+      "speaker": "Cole Gordon",
+      "confidence": 0.94
+    }
+  ]
+}
+```
+
+### Checkpoint
+```
+✅ FASE 2 COMPLETA
+├── Chunks gerados: 127
+├── Duração média: 21s
+├── Confiança média: 0.91
+└── Status: Pronto para entity resolution
+```
+
+---
+
+## FASE 3: ENTITY RESOLUTION
+
+### Entidades a Detectar
+
+| Tipo | Exemplo | Ação |
+|------|---------|------|
+| Pessoa | "Cole Gordon" | Mapear para CANONICAL-MAP |
+| Empresa | "Cole Gordon" | Mapear para companies |
+| Conceito | "Show Rate" | Verificar glossário |
+| Framework | "CLOSER Framework" | Mapear para frameworks |
+| Métrica | "30% close rate" | Extrair valor numérico |
+
+### Processo
+1. Identificar menções de entidades
+2. Resolver aliases (Sam = Sam Ovens)
+3. Verificar CANONICAL-MAP
+4. Criar novas entradas se necessário
+5. Linkar chunks às entidades
+
+### Output
+```json
+{
+  "source_id": "CG004",
+  "entities_found": {
+    "persons": ["Cole Gordon", "Alex Hormozi"],
+    "companies": ["Cole Gordon", "Alex Hormozi"],
+    "concepts": ["Show Rate", "Close Rate", "Qualification"],
+    "frameworks": ["CLOSER Framework"],
+    "metrics": [
+      {"name": "close_rate", "value": 0.30, "context": "target"}
+    ]
+  },
+  "new_entities": 2,
+  "resolved_aliases": 5
+}
+```
+
+### Checkpoint
+```
+✅ FASE 3 COMPLETA
+├── Entidades encontradas: 23
+├── Pessoas: 4
+├── Conceitos: 12
+├── Novas entidades: 2
+└── Status: Pronto para insight extraction
+```
+
+---
+
+## FASE 4: INSIGHT EXTRACTION
+
+### Aplicar SKILL-KNOWLEDGE-EXTRACTION
+
+Para cada chunk:
+1. Identificar se contém insight acionável
+2. Classificar com tag DNA
+3. Extrair em linguagem clara
+4. Atribuir prioridade e confidence
+5. Verificar duplicatas
+
+### Output
+```json
+{
+  "source_id": "CG004",
+  "total_insights": 47,
+  "by_dna_layer": {
+    "FILOSOFIA": 3,
+    "MODELO-MENTAL": 8,
+    "HEURISTICA": 15,
+    "FRAMEWORK": 12,
+    "METODOLOGIA": 9
+  },
+  "by_priority": {
+    "HIGH": 18,
+    "MEDIUM": 21,
+    "LOW": 8
+  }
+}
+```
+
+### Checkpoint
+```
+✅ FASE 4 COMPLETA
+├── Insights extraídos: 47
+├── Alta prioridade: 18
+├── Média confiança: 0.87
+└── Status: Pronto para narrative synthesis
+```
+
+---
+
+## FASE 5: NARRATIVE SYNTHESIS
+
+### Processo
+1. Agrupar insights por tema
+2. Ordenar cronologicamente
+3. Criar narrativa coerente
+4. Manter referências aos chunks
+5. Gerar resumo executivo
+
+### Output: SOURCE-[ID].md
+```markdown
+# SOURCE: CG004 - Cole Gordon - [Título]
+
+> **Processado:** [Data]
+> **Duração:** 45:00
+> **Insights:** 47
+
+---
+
+## RESUMO EXECUTIVO
+
+[Síntese de 3-5 parágrafos do conteúdo principal]
+
+---
+
+## PRINCIPAIS INSIGHTS
+
+### [FILOSOFIA]
+- [Insight 1]
+- [Insight 2]
+
+### [FRAMEWORK]
+- [Framework principal explicado]
+
+...
+
+---
+
+## TIMELINE
+
+| Tempo | Tema | Insight Key |
+|-------|------|-------------|
+| 00:05 | Intro | [Insight] |
+| 05:30 | Core | [Insight] |
+
+---
+
+## FONTES DOS CHUNKS
+
+[Lista de chunk_ids para rastreabilidade]
+```
+
+---
+
+## FASE 6: DOSSIER COMPILATION
+
+### Atualizar ou Criar Dossiê
+
+```markdown
+# DOSSIER: [PESSOA/TEMA]
+
+> **Última atualização:** [Data]
+> **Fontes processadas:** [N]
+
+---
+
+## SÍNTESE CUMULATIVA
+
+[Conhecimento acumulado de todas as fontes]
+
+---
+
+## FONTES
+
+| ID | Tipo | Data | Insights |
+|----|------|------|----------|
+| CG001 | Video | [Data] | 32 |
+| CG002 | PDF | [Data] | 18 |
+| CG003 | Video | [Data] | 45 |
+| CG004 | Video | [Data] | 47 |
+```
+
+---
+
+## FASE 6.6: SOURCES COMPILATION
+
+### Criar/Atualizar SOURCE por Pessoa + Tema
+
+```
+/knowledge/SOURCES/
+└── COLE-GORDON/
+    ├── SOURCE-SALES-MANAGEMENT.md  # Compilação de múltiplas fontes
+    ├── SOURCE-CLOSING.md
+    └── SOURCE-SHOW-RATES.md
+```
+
+---
+
+## FASE 7: AGENT ENRICHMENT
+
+### Para cada insight HIGH priority:
+1. Identificar agentes afetados
+2. Atualizar MEMORY dos agentes
+3. Se nova metodologia → atualizar ROLE
+4. Se novo framework → registrar
+
+### Verificação de Threshold
+```
+Se pessoa tem 3+ fontes processadas E
+   100+ insights extraídos:
+   → Verificar se merece AGENT-PERSON
+```
+
+---
+
+## FASE 8: FINALIZATION
+
+### Relatório Final
+```
+════════════════════════════════════════════════════════════════
+📊 PROCESSAMENTO CONCLUÍDO: CG004
+════════════════════════════════════════════════════════════════
+
+ESTATÍSTICAS
+├── Chunks: 127
+├── Insights: 47 (18 HIGH, 21 MEDIUM, 8 LOW)
+├── Entidades: 23 (2 novas)
+├── Tempo: 12m 34s
+
+ARQUIVOS GERADOS
+├── /processing/chunks/CG004-chunks.json
+├── /processing/insights/CG004-insights.json
+├── /knowledge/SOURCES/cole-gordon/SOURCE-CG004.md
+├── /knowledge/dossiers/persons/DOSSIER-COLE-GORDON.md (atualizado)
+
+AGENTES ATUALIZADOS
+├── MEMORY-CLOSER.md (+5 entries)
+├── MEMORY-SALES-MANAGER.md (+3 entries)
+
+PRÓXIMAS AÇÕES
+├── [ ] Revisar insights HIGH priority
+├── [ ] Verificar conflitos detectados
+└── [ ] Confirmar novas entidades no glossário
+
+════════════════════════════════════════════════════════════════
+```
+
+### Atualizações Obrigatórias
+- [ ] SESSION-STATE.md
+- [ ] CANONICAL-MAP.json (se novas entidades)
+- [ ] Glossário (se novos termos)
+- [ ] FILE-REGISTRY
+- [ ] RAG index
+
+---
+
+## ANTI-PATTERNS (NUNCA FAZER)
+
+1. ❌ Pular fases do pipeline
+2. ❌ Processar sem gerar source_id
+3. ❌ Não verificar duplicatas
+4. ❌ Não atualizar SESSION-STATE
+5. ❌ Chunks sem timestamp
+6. ❌ Insights sem referência ao chunk
+7. ❌ Não indexar no RAG
+8. ❌ Ignorar relatório final
+
+---
+
+## META-INFORMAÇÃO
+
+- **Versão:** 1.0.0
+- **Domínio:** Processamento
+- **Prioridade:** ALTA
+- **Dependências:** 
+  - SKILL-KNOWLEDGE-EXTRACTION
+  - SKILL-DOCS-MEGABRAIN

package/.claude/skills/06-SKILL-BRAINSTORMING/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: 06-SKILL-BRAINSTORMING
+description: "Use ANTES de criar playbooks, estruturar agentes, ou modificar a arquitetura do Mega Brain. Explora intenção, requisitos e design antes da implementação."
+---
+
+> **Auto-Trigger:** Antes de criar playbooks, estruturar agentes, design de conhecimento
+> **Keywords:** "brainstorm", "ideias", "ideação", "playbook", "design", "estrutura", "agentes", "arquitetura"
+> **Prioridade:** MÉDIA
+
+---
+
+# Brainstorming para Mega Brain
+
+## Overview
+
+Transforma ideias em designs estruturados através de diálogo colaborativo. Usado para:
+- Criar novos playbooks de vendas
+- Estruturar novos agentes (SOUL, MEMORY, DNA)
+- Redesenhar arquiteturas de conhecimento
+- Planejar pipelines de processamento
+
+**Anunciar no início:** "Estou usando a skill de brainstorming para explorar essa ideia."
+
+## O Processo
+
+**Entendendo a ideia:**
+- Verificar o estado atual do projeto (arquivos, agentes existentes, SESSION-STATE)
+- Fazer perguntas uma de cada vez para refinar a ideia
+- Preferir múltipla escolha quando possível
+- Foco: propósito, restrições, critérios de sucesso
+
+**Explorando abordagens:**
+- Propor 2-3 abordagens diferentes com trade-offs
+- Apresentar opções conversacionalmente com recomendação
+- Liderar com a opção recomendada e explicar o porquê
+
+**Apresentando o design:**
+- Quando entender o que será construído, apresentar o design
+- Dividir em seções de 200-300 palavras
+- Perguntar após cada seção se está correto até agora
+- Cobrir: estrutura, componentes, fluxo de dados, integração com sistema existente
+
+## Após o Design
+
+**Documentação:**
+- Escrever design validado em `knowledge/playbooks/drafts/YYYY-MM-DD-<topico>-design.md`
+- Atualizar SESSION-STATE.md com novo design
+
+**Implementação (se continuar):**
+- Perguntar: "Pronto para implementar?"
+- Para processamento de conteúdo: usar Pipeline Jarvis
+- Para criação de agentes: seguir Agent Integrity Protocol
+
+## Princípios Chave
+
+- **Uma pergunta de cada vez** - Não sobrecarregar
+- **Múltipla escolha preferida** - Mais fácil de responder
+- **YAGNI** - Remover features desnecessárias
+- **Explorar alternativas** - Sempre 2-3 abordagens
+- **Validação incremental** - Apresentar em seções, validar cada uma
+- **Ser flexível** - Voltar e clarificar quando necessário
+
+## Quando Usar
+
+| Situação | Usar? |
+|----------|-------|
+| Criar novo playbook de vendas | ✅ |
+| Estruturar novo agente | ✅ |
+| Redesenhar taxonomy de temas | ✅ |
+| Planejar processamento em lote | ✅ |
+| Processar arquivo simples | ❌ (usar Pipeline Jarvis direto) |
+| Corrigir erro em arquivo | ❌ |

package/.claude/skills/07-SKILL-DISPATCHING-PARALLEL-AGENTS/SKILL.md

@@ -0,0 +1,193 @@
+---
+name: 07-SKILL-DISPATCHING-PARALLEL-AGENTS
+description: Use quando tiver 2+ tarefas independentes que podem ser processadas em paralelo sem dependências
+---
+
+> **Auto-Trigger:** 2+ arquivos INBOX, múltiplos processamentos, paralelização de tarefas
+> **Keywords:** "paralelo", "agents", "dispatch", "múltiplos", "batch", "concorrente", "INBOX"
+> **Prioridade:** ALTA
+
+---
+
+# Dispatching Parallel Agents - Mega Brain
+
+## Overview
+
+Quando há múltiplos arquivos no INBOX ou tarefas independentes, processá-los sequencialmente desperdiça tempo. Cada processamento é independente e pode acontecer em paralelo.
+
+**Princípio central:** Dispatch de um agente por domínio independente. Deixá-los trabalhar concorrentemente.
+
+## Quando Usar
+
+**Usar quando:**
+- 3+ arquivos no INBOX de fontes diferentes
+- Múltiplas extrações de conhecimento independentes
+- Cada processamento pode ser entendido sem contexto dos outros
+- Sem estado compartilhado entre investigações
+
+**NÃO usar quando:**
+- Arquivos são da mesma fonte (processar juntos para consistência)
+- Precisa entender o estado completo do sistema
+- Agentes interfeririam uns com os outros (editando mesmos arquivos)
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│  DECISÃO: PARALELO OU SEQUENCIAL?                                       │
+├─────────────────────────────────────────────────────────────────────────┤
+│                                                                         │
+│  Múltiplos arquivos? ──NO──→ Processo único                            │
+│        │                                                                │
+│       YES                                                               │
+│        │                                                                │
+│  São independentes? ──NO──→ Processar juntos (mesma fonte/tema)        │
+│        │                                                                │
+│       YES                                                               │
+│        │                                                                │
+│  ┌─────▼─────┐                                                         │
+│  │ PARALLEL  │                                                         │
+│  │ DISPATCH  │                                                         │
+│  └───────────┘                                                         │
+│                                                                         │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+## O Padrão
+
+### 1. Identificar Domínios Independentes
+
+Agrupar por o que será processado:
+- Arquivo A: Cole Gordon - Cole Gordon
+- Arquivo B: Alex Hormozi - Alex Hormozi
+
+Cada domínio é independente - processar Cole Gordon não afeta Hormozi.
+
+### 2. Criar Tasks de Agente Focadas
+
+Cada agente recebe:
+- **Escopo específico:** Um arquivo ou fonte
+- **Objetivo claro:** Extrair chunks e insights
+- **Constraints:** Não modificar outros arquivos
+- **Output esperado:** Resumo do que foi extraído
+
+### 3. Dispatch em Paralelo
+
+```
+Task("Processar CG-SM002.txt via Pipeline Jarvis Steps 1-3")
+Task("Processar AH-HR003.txt via Pipeline Jarvis Steps 1-3")
+// Todos rodam concorrentemente
+```
+
+### 4. Revisar e Integrar
+
+Quando agentes retornam:
+- Ler cada resumo
+- Verificar se não há conflitos em canonical/entities
+- Rodar consolidação (Steps 4-6 do Jarvis)
+- Integrar todos os outputs
+
+## Estrutura do Prompt de Agente
+
+```markdown
+Processar arquivo: inbox/COLE GORDON/PODCASTS/CG-SM002.txt
+
+Pipeline Jarvis Steps 1.1 a 2.1:
+1. Chunking semântico → processing/chunks/
+2. Entity Resolution → processing/canonical/
+3. Insight Extraction → processing/insights/
+
+Constraints:
+- NÃO modificar arquivos de outras fontes
+- Seguir protocolos existentes em agents/protocols/
+- Atualizar INSIGHTS-STATE.json com novos insights
+
+Retornar: Resumo de chunks gerados, entidades encontradas, insights extraídos.
+```
+
+## Erros Comuns
+
+| ❌ Errado | ✅ Correto |
+|-----------|-----------|
+| "Processar todo o INBOX" | "Processar CG-SM002.txt" |
+| Sem contexto do arquivo | Incluir path completo e fonte |
+| Sem constraints | "NÃO modificar outros arquivos" |
+| Output vago | "Retornar resumo de extrações" |
+
+## Exemplo Real - Mega Brain
+
+**Cenário:** 5 arquivos novos no INBOX de 3 fontes diferentes
+
+**Arquivos:**
+- Cole Gordon: CG-SM002.txt, CG-SM003.txt
+- Alex Hormozi: AH-HR002.txt
+
+**Decisão:**
+- CG arquivos → 1 agente (mesma fonte)
+- AH arquivo → 1 agente
+
+**Dispatch:**
+```
+Agent 1 → Processar CG-SM002.txt + CG-SM003.txt
+Agent 2 → Processar AH-HR002.txt
+```
+
+**Resultados:**
+- Agent 1: 45 chunks, 23 insights sobre Sales Management
+- Agent 2: 30 chunks, 18 insights sobre Hiring
+
+**Integração:** Consolidar insights-state.json, rodar Steps 4-6
+
+## Benefícios
+
+1. **Paralelização** - Múltiplos processamentos simultâneos
+2. **Foco** - Cada agente tem escopo narrow
+3. **Independência** - Agentes não interferem
+4. **Velocidade** - 3 problemas resolvidos no tempo de 1
+
+## Verificação
+
+Após agentes retornarem:
+1. **Revisar cada resumo** - Entender o que foi extraído
+2. **Checar conflitos** - Agentes editaram mesmos arquivos?
+3. **Validar integridade** - JSONs de estado estão consistentes?
+4. **Rodar consolidação** - Steps 4-6 do Pipeline Jarvis
+
+---
+
+## INTEGRACAO COM JARVIS_PARALLEL_DISPATCHER.PY
+
+O sistema agora possui um dispatcher automatizado em `scripts/jarvis_parallel_dispatcher.py`.
+
+### Uso Programatico
+
+```python
+import sys
+sys.path.insert(0, "scripts")
+from jarvis_parallel_dispatcher import get_dispatcher, analyze_for_parallelism
+
+# Analisar prompt
+analysis = analyze_for_parallelism("Processar proximos 3 batches")
+# Retorna: {"can_parallelize": True, "reason": "Multiplos batches detectado"}
+
+# Criar tarefas
+dispatcher = get_dispatcher()
+tasks = dispatcher.create_parallel_tasks(prompt, context)
+commands = dispatcher.generate_task_commands(tasks)
+```
+
+### Logs Gerados
+
+| Arquivo | Conteudo |
+|---------|----------|
+| `logs/dispatch.jsonl` | Acoes de dispatch |
+| `system/active_parallel_tasks.json` | Tarefas ativas |
+| `/tmp/claude/.../tasks/*.output` | Output de cada agente |
+
+### Monitoramento
+
+```bash
+# Ver progresso de um agente
+tail -50 /tmp/claude/<project-path>/tasks/[id].output
+
+# Status de todas as tarefas
+python scripts/jarvis_parallel_dispatcher.py
+```