Missões Fable 5

Você é a minha SESSÃO MÃE das Missões Fable 5. Rode no Fable 5 com effort alto. Seu trabalho: me entrevistar rápido, decidir a ordem certa das missões pra mim, criar as tasks no meu Brain e me soltar pra trabalhar com várias sessões em paralelo — maximizando o tempo em que o Claude trabalha sozinho enquanto eu faço outra coisa.

1. COLETAR O CATÁLOGO: baixe a página https://missoes-fable5.ericluciano.com.br e extraia as 8 missões (M1 a M8): o prompt completo de cada uma (blocos de código) e a configuração que está no topo de cada prompt (tipo autônoma/interativa/híbrida, execução paralela/sequencial, dependências, modelos e effort).

2. ENTREVISTA CURTA (no máximo 5 perguntas, uma mensagem só): qual é minha área e o sistema mais importante que eu opero? Tenho Brain instalado e desde quando? Tenho WhatsApp Agent (instalei agora ou já tinha histórico)? Que ferramentas estão conectadas no meu Claude Code (Outlook, ClickUp, Zoom, ChatGuru, Brain)? Qual minha maior dor agora — agenda, sistema, área, memória do agente?

3. DECIDIR A ORDEM (regra de ouro: primeiro o que RODA SOZINHO, depois o que precisa de mim): missões autônomas (M2 skills, M6 memória, M8 backfill, M3 fase 1, coleta da M7) disparam primeiro, em sessões paralelas — eu só inicio e vou embora. Missões interativas (M1 agenda, M5, M4 conselheiro) eu faço enquanto as autônomas rodam. Respeite dependências: M8 antes da M7 se meu WhatsApp Agent for novo; M3 fase 2 só depois da fase 1 aprovada; M4 rende mais depois da M1. Ajuste pela entrevista: minha maior dor sobe na fila; missão que não se aplica a mim (ex.: não tenho o sistema, não tenho Brain) sai da fila com justificativa.

4. CRIAR AS TASKS NO MEU BRAIN (save_task, uma por missão, na ordem decidida): título padronizado "Missão Fable M# — <nome>", due 07/07/2026, prioridade refletindo a ordem. No campo details de cada task, cole: (a) a CONFIGURAÇÃO da sessão — modelo principal e effort, tipo (autônoma/interativa/híbrida), execução (paralela ou sequencial e de quem depende); (b) o PROMPT completo da missão extraído da página; (c) o PROTOCOLO DE ACIONAMENTO: "ao ser acionada, primeiro rode list_tasks e confira se as dependências estão done; se não estiverem, diga o que falta e PARE; se estiverem, marque esta task in_progress e execute o prompt; ao terminar, complete_task com o resumo do resultado". Antes de criar, rode list_tasks pra não duplicar se eu já tiver rodado a Missão 0 antes.

5. ENTREGAR O PLANO: me mostre a fila final em duas colunas — ABRIR AGORA EM PARALELO (autônomas, com quantas sessões abrir) e FAZER QUANDO EU ESTIVER LIVRE PRA FALAR (interativas, na ordem) — e me ensine o comando: pra cada missão, abrir uma sessão nova e dizer só "leia a task Missão Fable M# no meu Brain e execute o protocolo dela". A partir daí eu não copio mais nada na mão.

CONFIGURAÇÃO DA SESSÃO (leia antes de tudo): modelo principal Fable 5, effort alto; coleta e contagem em subagentes Sonnet ou mais barato — você decide os modelos do squad. Tipo: INTERATIVA, o usuário precisa estar presente respondendo. Execução: paralela, sem dependências. Se esta missão veio de uma task do Brain: marque a task in_progress ao começar e complete_task com o resumo ao terminar.

Me ajude a repriorizar minha agenda e minhas tarefas com base em dados reais, não em achismo — e rode como orquestrador: você, no modelo mais inteligente, SÓ entrevista, julga e decide; a coleta e a contagem saem em subagentes de modelo menor, e contar é trabalho de script, não de agente.

Primeiro, subagentes baratos coletam meu histórico real com as ferramentas conectadas: minha agenda do Outlook das últimas 4-6 semanas (reuniões, blocos, recorrências), minhas tarefas do ClickUp (o que concluí, o que está aberto, o que está parado há mais de 2 semanas), meu histórico de sessões de IA (pasta ~/.claude/projects, se existir) e o que mais estiver disponível (email, Brain, arquivos da minha área). O que não estiver conectado, me peça (print ou export) em vez de assumir. Você recebe os resumos e monta o raio-X: onde meu tempo realmente foi, versus o que era prioridade da minha função.

Depois, me entreviste antes de concluir qualquer coisa: minha área mudou na reestruturação? O que entrou e o que saiu do meu escopo? Quais metas valem para os próximos 90 dias? Não assuma — pergunte.

Com o raio-X + a nova realidade, ponha agentes independentes (modelos menores) analisando por ângulos diferentes: (a) o que só eu posso fazer vs o que delego ou automatizo, (b) o que estou fazendo que não deveria mais existir, (c) o que NÃO estou fazendo e a nova função exige, (d) reuniões e rotinas que sobreviveram à reorganização por inércia. Cada conclusão passa por verificação adversarial: outro agente tenta derrubar, e só sobrevive o que resistir com evidência (dado da agenda ou do ClickUp, não opinião). O que cair volta pra análise, não pra mim.

Me entregue: top 5 prioridades para as próximas 2 semanas, a lista explícita do que PARAR de fazer, e uma agenda-modelo semanal com blocos por macro-tema (um tema por bloco, sem multitarefa picada). Nada muda na minha agenda ou no ClickUp sem eu aprovar.

CONFIGURAÇÃO DA SESSÃO (leia antes de tudo): modelo principal Fable 5, effort médio na orquestração; braçal em subagentes Sonnet; revisor em Opus effort alto — você decide os modelos do squad. Tipo: AUTÔNOMA — depois de iniciada, avise o usuário que pode abrir outra sessão e trabalhar em paralelo; só o chame para as aprovações finais. Execução: paralela, sem dependências. Se esta missão veio de uma task do Brain: marque in_progress ao começar e complete_task com o resumo ao terminar.

Faça a revisão completa das minhas skills até ficarem tão boas que um modelo menor execute sem errar — e rode como pipeline de squad que se corrige sozinho, não como um agente só. Regra de custo: você, o orquestrador, SÓ planeja, decide e consolida; todo o braçal sai em subagentes de modelo menor.

1. EXPLORAR (modelos baratos, em paralelo): um script varre meu histórico de sessões (pasta ~/.claude/projects) e conta o uso real de cada skill — contar é trabalho de script, não de agente. Subagentes Sonnet leem as skills em lotes e resumem o que cada uma promete versus onde ela falha na prática. Você não lê tudo: recebe os resumos.

2. PLANEJAR (você, effort alto): com os números na mão, priorize — quais skills valem reescrever, quais arquivar (me pergunte antes de arquivar) e o que exatamente muda em cada uma. O plano inteiro sai do modelo mais inteligente.

3. IMPLEMENTAR (Sonnet/Opus em paralelo): distribua a reescrita entre agentes menores, um por skill ou grupo de skills, cada um isolado (branch ou worktree próprio quando for repositório) — sem conflito entre si.

4. REVISAR EM LOOP (agente revisor separado, effort alto): o revisor tenta provar que a skill reescrita falha, rodando o cenário real dela. Achou erro, devolve pro agente de implementação corrigir e revisa de novo — até passar limpo.

5. Só então me traga o consolidado: diff e evidência por skill, com o antes e depois. Eu não reviso no olho — só chega em mim o que sobreviveu ao loop. Nada sobe pro git sem eu aprovar.

CONFIGURAÇÃO DA SESSÃO (leia antes de tudo): modelo principal Fable 5, effort alto; exploração em subagentes Sonnet; implementação em Sonnet/Opus; revisor em Opus effort alto — você decide os modelos do squad. Tipo: AUTÔNOMA depois da pergunta inicial — avise o usuário que pode ir pra outra sessão; chame-o só na aprovação entre as fases. Execução: fase 1 paralela; fase 2 SEQUENCIAL, só começa com a fase 1 aprovada. Se esta missão veio de uma task do Brain: in_progress ao começar, complete_task ao terminar.

Quero revisar e depois corrigir o sistema mais importante da minha área com um squad que se corrige sozinho — você orquestra, agentes executam, e o token do modelo caro paga só o que exige inteligência. Antes de começar, me pergunte: qual sistema é, onde vive (repositório, Supabase, fluxos no ChatGuru/Make, config do CRM, planilha) e o que ele promete fazer.

FASE 1 — DIAGNÓSTICO (não corrija nada ainda):
- EXPLORAR (3 ou mais subagentes de modelo menor, em paralelo): cada um varre um domínio — segurança, bugs e performance, manutenibilidade e dependências. Eles leem o código; você recebe os resumos.
- CONSOLIDAR (você, effort alto): cada achado passa por verificação adversarial — outro agente tenta provar que é falso positivo, e só entra no relatório o que sobreviver, com localização exata (arquivo:linha, fluxo, campo) e evidência.
- Me entregue o diagnóstico priorizado por impacto x esforço, do crítico ao cosmético, e PARE para eu escolher o que corrigir.

FASE 2 — CORREÇÃO (só do que eu aprovar):
- PLANEJAR (você, o modelo mais inteligente): o plano inteiro de mudança sai de você — é a fase que decide tudo.
- IMPLEMENTAR (agentes Sonnet/Opus em paralelo): distribua a execução entre modelos menores, cada um num git worktree isolado, sem conflito entre si.
- JUNTAR: consolide o melhor das versões numa só.
- REVISAR EM LOOP (revisor separado, effort alto): achou erro, devolve pra implementação corrigir e revisa de novo — até passar limpo.
- PULL REQUEST: só chega em mim o código que sobreviveu ao loop, com evidência (testes rodados, resultado real). Eu aprovo o resultado final, não os passos.

CONFIGURAÇÃO DA SESSÃO (leia antes de tudo): modelo principal Fable 5, effort máximo; coleta de dados em subagentes Sonnet — você decide os modelos do squad. Tipo: INTERATIVA, o usuário precisa estar presente. Execução: recomendada DEPOIS da Missão M1 — antes de começar, rode list_tasks no Brain e confira se a "Missão Fable M1" está done; se não estiver, avise e pergunte se o usuário quer seguir mesmo assim. Se esta missão veio de uma task do Brain: in_progress ao começar, complete_task ao terminar.

Aja como meu conselheiro estratégico para a MINHA área e rode no effort mais alto — quero profundidade, não velocidade. Regra de custo: a coleta de dados sai em subagentes de modelo menor; você, no modelo mais inteligente, fica só com a análise e o julgamento.

Primeiro, os subagentes coletam os dados reais da área com o que estiver conectado: tarefas e prazos no ClickUp, agenda do Outlook, métricas que eu apontar (CRM, churn, SLA, entregas, NPS) e arquivos da área. O que não estiver conectado, me peça. Depois me entreviste sobre a nova realidade: o que a área ganhou e perdeu na reestruturação, que promessas estão de pé, que time sobrou.

Ponha agentes independentes analisando por ângulos diferentes: uso do tempo, resultado por esforço, gargalos de crescimento, o que a área deveria parar de fazer. Antes de me trazer qualquer conclusão, ela passa por um auditor separado que tenta derrubá-la: se não sobreviver, volta pro estudo — não pra mim.

Quero os 3 maiores gargalos da minha área e onde focar nos próximos 90 dias, cada um ancorado em evidência dos meus dados, não em conselho genérico. Seja direto — não me poupe do desconfortável.

CONFIGURAÇÃO DA SESSÃO (leia antes de tudo): modelo principal Fable 5, effort alto; varredura em subagentes Sonnet ou mais barato — você decide os modelos do squad. Tipo: HÍBRIDA — depois da pergunta inicial, a varredura roda sozinha (avise o usuário que pode ir pra outra sessão); chame-o de volta pra entrevista quando a lista estiver pronta. Execução: paralela, sem dependências. Se esta missão veio de uma task do Brain: in_progress ao começar, complete_task ao terminar.

A empresa reduziu o time e redistribuiu funções. Me ajude a encontrar o que ficou órfão na minha área antes que vire incêndio. Comece me perguntando: quem saiu da minha área nos últimos meses e o que cada um fazia.

Depois, os subagentes varrem as fontes em paralelo: tarefas no ClickUp que eram dessas pessoas (atribuídas, criadas ou comentadas por elas), rotinas e processos documentados que as citam, reuniões recorrentes que morreram na agenda, e sistemas ou acessos que só elas operavam. Contar e listar é trabalho de script e agente barato — você recebe os resumos.

Com a lista na mão, me entreviste: das rotinas órfãs, o que ainda precisa existir? Para cada uma que precisa, proponha: quem assume, o que vira automação (na linha "cada saída vira automação") e o que morre oficialmente. Toda recomendação de "pode morrer" passa por verificação adversarial: outro agente tenta provar que alguma coisa quebra se isso sumir — o que cair volta pra análise.

Entregável: uma tabela com rotina órfã, dono anterior, decisão (assumir, automatizar ou matar), responsável e prazo. Nada é executado sem eu aprovar.

CONFIGURAÇÃO DA SESSÃO (leia antes de tudo): modelo principal Fable 5, effort médio na orquestração; lotes de leitura em Sonnet; revisor em Opus effort alto — você decide os modelos do squad. Tipo: AUTÔNOMA — avise o usuário que pode trabalhar em paralelo; chame-o só na aprovação do diff. Execução: paralela, sem dependências. Se esta missão veio de uma task do Brain: in_progress ao começar, complete_task ao terminar.

Otimize a memória do meu agente (CLAUDE.md + arquivos de memória + notas do meu Brain, se eu tiver) pelo meu uso real, não por opinião — e rode como pipeline de squad: você, no modelo mais inteligente, só decide; o braçal sai em modelos menores.

1. EXPLORAR (script + modelos baratos): um script varre meu histórico de sessões (pasta ~/.claude/projects) e conta com exatidão que tools, MCPs e skills eu uso de verdade, onde eu corrijo o agente repetidas vezes, que regra foi violada na prática e que contexto ele vive me perguntando — contar é trabalho de script. Subagentes Sonnet leem o histórico e a memória em lotes pequenos (senão estoura o limite): um caça regra que existe mas não segura, outro regra morta e duplicada, outro o que falta, outro o que o modelo atual já faz sozinho e pode sair. Se eu tiver Brain, os mesmos lotes revisam as notas: duplicatas, notas gigantes, resumos fracos.

2. PLANEJAR (você, effort alto): consolide os achados num diff único da memória, com evidência por mudança e o custo em tokens do que carrego em toda sessão, antes e depois.

3. APLICAR (agente menor): backup primeiro, depois aplica o diff aprovado.

4. REVISAR EM LOOP (revisor separado): o revisor tenta provar que o CLAUDE.md novo quebra um caso real do meu histórico (uma regra removida que fazia falta, um contexto que voltou a faltar). Achou problema, devolve e corrige — até passar limpo.

Eu não reviso no olho: me mostre o diff consolidado que sobreviveu ao loop. Nada sobrescreve sem eu aprovar.

CONFIGURAÇÃO DA SESSÃO (leia antes de tudo): modelo principal Fable 5, effort alto na curadoria; leitura em subagentes Sonnet — você decide os modelos do squad. Tipo: HÍBRIDA — a coleta do Zoom roda sozinha (o usuário pode ir pra outra sessão); os exports de WhatsApp e ChatGuru dependem dele; a curadoria roda sozinha com checkpoints. Execução: se o usuário instalou o WhatsApp Agent agora, confira com list_tasks se a "Missão Fable M8" está done ANTES de usar exports de WhatsApp como fonte — o resto pode começar já. Se esta missão veio de uma task do Brain: in_progress ao começar, complete_task ao terminar.

Quero nutrir o meu Brain (meu segundo cérebro conectado via MCP) com todo o histórico que eu conseguir juntar — e rodar como pipeline de squad: você, no modelo mais inteligente, só decide o que vira conhecimento; agentes menores fazem toda a leitura. Me guie passo a passo no que depender de mim.

FASE 1 — COLETAR (scripts + agentes baratos):
- Zoom chat: use o MCP do Zoom para listar meus canais e conversas privadas e exportar o histórico que tenho acesso.
- Reuniões do Zoom: use o MCP para baixar gravações/transcrições das reuniões que tenho acesso; o que não tiver transcrição, transcreva localmente.
- ChatGuru: me guie para exportar o relatório de conversas (ou abra o painel via Playwright comigo) e salve os arquivos numa pasta de trabalho.
- WhatsApp: me peça para exportar do celular as conversas e grupos importantes (Exportar conversa, com mídia) e apontar a pasta dos arquivos.
Organize tudo numa pasta local com origem e data. Nada vai para o Brain ainda.

FASE 2 — LER EM LOTES (subagentes Sonnet em paralelo): os agentes leem os arquivos em lotes pequenos e extraem candidatos a conhecimento: decisões com motivo, regras e princípios que eu uso, fatos e métricas com data, padrões recorrentes, perguntas em aberto, contexto de clientes e projetos. Cada candidato vem com a citação da fonte (arquivo + data). Fofoca, dado sensível de terceiros e assunto pessoal que eu não queira registrado ficam DE FORA — na dúvida, me pergunte.

FASE 3 — CURAR E GRAVAR (você, effort alto): você julga o que vira nota: UMA ideia por nota, resumo de uma frase, tipo certo (decisão, princípio, fato, padrão, insight, pergunta) e conexões entre notas relacionadas. Antes de gravar cada nota, faça recall no Brain para não duplicar. Grave em lotes e me mostre o progresso (quantas notas, por tema).

FASE 4 — VERIFICAR (revisor separado): o revisor amostra as notas gravadas contra as fontes — nota sem fonte real ou com interpretação inventada é corrigida ou apagada. Me entregue o balanço final: quantos arquivos lidos, quantas notas criadas por tema, e o que ficou de fora e por quê.

CONFIGURAÇÃO DA SESSÃO (leia antes de tudo): modelo principal Fable 5, effort alto no plano; execução em scripts e subagentes Sonnet — você decide os modelos do squad. Tipo: AUTÔNOMA depois que o usuário apontar os arquivos exportados — avise que ele pode ir pra outra sessão; chame-o só na aprovação do plano (pós dry-run) e na verificação final. Execução: rodar ANTES da Missão M7. Se esta missão veio de uma task do Brain: in_progress ao começar, complete_task ao terminar.

Acabei de instalar o WhatsApp Agent e ele não tem histórico. Quero fazer o backfill retroativo: importar para o banco (Supabase) do MEU WhatsApp Agent as conversas que eu exportei do celular — texto e mídia — com os timestamps originais, e transcrever os áudios. Rode como pipeline: você, no modelo mais inteligente, planeja e valida; scripts e agentes menores executam.

1. COLETA: me pergunte onde estão os arquivos exportados (.zip ou pasta com .txt + mídias) e quais conversas são.

2. PLANEJAR (você, effort alto): leia a estrutura do meu WhatsApp Agent (tabelas do Supabase: chats, mensagens, mídia) e desenhe o plano de importação: como parsear o formato do export do WhatsApp (.txt + arquivos de mídia), como mapear remetente, data e tipo de mensagem, como evitar duplicata se eu rodar duas vezes (chave de dedupe determinística) e como preservar os timestamps originais. Me mostre o plano e um DRY-RUN com contagens (mensagens, áudios, imagens por conversa) ANTES de escrever qualquer linha no banco.

3. EXECUTAR (script + agentes menores): importe em lotes, transcreva os áudios (Whisper local ou API disponível) e marque tudo com origem backfill — se algo der errado, tem que dar para apagar só o que o backfill inseriu, sem tocar no resto.

4. VERIFICAR: confira contagens antes/depois (mensagens no arquivo versus linhas no banco), amostre 10 mensagens comparando com o export original (remetente, hora, conteúdo) e me mostre a prova. Só declare concluído com essa verificação feita.

Depois de importado, esse histórico vira fonte da missão de nutrir o Brain.