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 TODAS as missões do catálogo (M1 em diante — a quantidade que a página tiver): 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, M11 radar de mercado, coleta da M7) disparam primeiro, em sessões paralelas — eu só inicio e vou embora. Missões interativas e híbridas (M1 agenda, M5, M9 sprint de decisões, M4 conselheiro, M10 playbook, M12 automações, M13 se eu quiser) 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; M12 rende mais depois da M1 e da M2; a M14 (fechamento) é SEMPRE a última, no fim do dia 07. NEM TODAS CABEM EM 2 DIAS: use a entrevista pra cortar — 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.

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

Quero fechar num sprint só as decisões da minha área que estão abertas esperando alguém bater o martelo. Você prepara, eu decido — decisão bem preparada pelo modelo mais inteligente é exatamente o que esta janela tem de melhor.

1. CAÇAR AS DECISÕES (subagentes baratos, em paralelo): varra minhas tarefas no ClickUp (paradas há mais de 1 semana, marcadas como aguardando aprovação, ou com comentário perguntando algo que ninguém respondeu), minhas mensagens recentes no Zoom (perguntas que me fizeram e seguem sem resposta) e o que mais estiver conectado. Depois me pergunte numa mensagem só: que outras decisões estão na minha cabeça esperando? Junte tudo numa lista única.

2. PREPARAR CADA DECISÃO (você, effort alto): pra cada uma, monte o dossiê curto: contexto em 3 linhas, as opções reais, sua recomendação com o trade-off explícito e o custo de continuar sem decidir. Se faltar dado pra recomendar, mande um subagente buscar — não me traga decisão pela metade. Cada recomendação passa por um auditor separado que tenta derrubá-la antes de chegar em mim.

3. SPRINT (comigo): me traga uma decisão por vez, na ordem do maior custo de espera. Eu bato o martelo; você registra na hora: a decisão com o porquê no meu Brain (kind decisão), e a ação que ela dispara vira tarefa com dono e prazo. O que eu decidir NÃO decidir agora, registre também, com data de revisão.

Entregável: pauta zerada — cada decisão com desfecho registrado, ação encaminhada ou adiamento consciente com data. Nada é executado sem eu aprovar.

CONFIGURAÇÃO DA SESSÃO (leia antes de tudo): modelo principal Fable 5, effort alto na estrutura; redação em subagentes Sonnet/Opus; revisor em Opus effort alto — você decide os modelos do squad. Tipo: HÍBRIDA — entrevista comigo no começo; depois a redação roda sozinha e você me chama só na revisão final. Execução: paralela, sem dependências (rende mais depois da M5, se eu tiver rodado). Se esta missão veio de uma task do Brain: in_progress ao começar, complete_task ao terminar.

Quero tirar da minha cabeça os processos críticos da minha função e transformar em playbooks que outra pessoa (ou um agente de IA) execute sem mim. Depois da reestruturação, o que só eu sei fazer é o maior risco da minha área.

1. MAPEAR (subagentes + entrevista): agentes baratos varrem o que JÁ existe documentado da minha área (ClickUp, pastas de processos, docs) pra não redocumentar o que está pronto. Em paralelo, me entreviste: quais rotinas só eu executo? O que quebra se eu ficar 2 semanas fora? Que perguntas o time me faz toda semana? Priorize comigo os 3 a 5 processos mais críticos — não tente documentar tudo.

2. EXTRAIR (comigo, um processo por vez): me faça descrever cada processo como se eu estivesse ensinando um substituto no primeiro dia: passo a passo, sistemas e acessos usados, decisões no meio do caminho (e o critério de cada uma), erros comuns e como perceber que deu errado. Eu posso simplesmente falar — você estrutura.

3. REDIGIR (agentes menores, em paralelo): um playbook por processo, formato padrão: objetivo, gatilho (quando roda), passo a passo com sistema/tela/campo, critérios de decisão, exceções e sinais de incêndio. Marque o que um agente de IA já poderia executar hoje e o que ainda precisa de humano.

4. REVISAR EM LOOP (revisor separado): o revisor tenta EXECUTAR cada playbook só lendo o documento, sem me perguntar nada. Onde ele travar ou precisar adivinhar, o playbook volta pra redação com a lacuna apontada. Só chega em mim o que um leigo conseguiria seguir.

Entregável: os playbooks aprovados salvos onde meu time encontra (pasta de processos da área + link no ClickUp), e a lista do que virou candidato a automação — pronta pra virar skill depois da janela.

CONFIGURAÇÃO DA SESSÃO (leia antes de tudo): modelo principal Fable 5, effort alto na síntese; pesquisa em subagentes Sonnet com busca na web — você decide os modelos do squad. Tipo: AUTÔNOMA depois de 3 perguntas iniciais — avise o usuário que pode ir pra outra sessão. Execução: paralela, sem dependências — boa candidata a disparar cedo. Se esta missão veio de uma task do Brain: in_progress ao começar, complete_task ao terminar.

Quero um radar de mercado da minha área — a leitura de cenário que eu nunca tenho tempo de fazer. Antes de começar, me pergunte só: (1) minha área e o que eu entrego, (2) quem eu considero concorrente ou referência (se eu souber), (3) que decisão essa pesquisa deveria informar.

1. PESQUISAR (subagentes em paralelo, cada um num ângulo): concorrentes diretos e o que estão oferecendo e cobrando; referências fora do Brasil fazendo o mesmo trabalho; o que mudou nos últimos 6 meses com IA na minha função (ferramentas, práticas, o que virou commodity); benchmarks e métricas típicas da função pra eu me comparar. Cada achado com fonte e data — pesquisa sem fonte é opinião.

2. VERIFICAR (auditor separado): cada afirmação que vai pro relatório passa por checagem — a fonte existe, a data confere, o número bate. O que não sobreviver, sai.

3. SINTETIZAR (você, effort alto): relatório curto e direto: as 5 coisas que mudaram e eu preciso saber; onde estamos atrás e onde estamos na frente; 3 oportunidades concretas pra minha área nos próximos 90 dias; e o que eu deveria parar de fazer porque o mercado já resolveu de outro jeito. Salve os achados que valem memória no meu Brain (fatos com data) e me entregue o relatório.

CONFIGURAÇÃO DA SESSÃO (leia antes de tudo): modelo principal Fable 5, effort alto no desenho; coleta em subagentes Sonnet — você decide os modelos do squad. Tipo: HÍBRIDA — coleta sozinha, entrevista curta comigo, desenho sozinho. Execução: rende mais DEPOIS da M1 (raio-X da agenda) e da M2 (skills existentes) — antes de começar, rode list_tasks e confira; se não estiverem feitas, dá pra rodar mesmo assim, só me avise que a base será a entrevista. Se esta missão veio de uma task do Brain: in_progress ao começar, complete_task ao terminar.

Quero sair desta janela com a minha rotina repetitiva especificada como automações — o plano feito agora no modelo mais inteligente, a construção depois com os menores. Plano bom sobrevive ao modelo.

1. CAÇAR REPETIÇÃO (subagentes baratos): varra minha agenda (reuniões e blocos que se repetem), meu ClickUp (tarefas que eu crio e concluo toda semana com o mesmo nome), meu histórico de sessões de IA (o que eu peço pro Claude repetidamente, pasta ~/.claude/projects) e minhas skills atuais (o que já existe, pra não duplicar). Depois me pergunte numa mensagem só: o que você faz toda semana no braço que dá preguiça só de pensar?

2. PRIORIZAR (você, effort alto): monte a lista de candidatas, cada uma com frequência real, tempo gasto estimado e risco de automatizar errado. Me traga o top e me deixe escolher 3 a 5.

3. ESPECIFICAR (você desenha, agentes detalham): pra cada escolhida, escreva a spec completa que um modelo menor consiga construir depois da janela sem me perguntar nada: o que dispara, de onde vêm os dados (MCP, arquivo, API), o passo a passo, o que exige aprovação humana no meio, como saber que funcionou, e o esqueleto da skill (nome, estrutura, exemplos de uso). Um revisor separado tenta achar buraco em cada spec — ambiguidade, permissão que falta, caso não tratado — e devolve até passar limpo.

4. DEIXAR PRONTO PRA DEPOIS: salve cada spec como task no meu Brain ("Construir skill: nome", com a spec inteira no details e a instrução de rodar em Sonnet/Opus), pra eu só abrir sessão depois do dia 07 e falar "leia a task e construa".

Entregável: 3 a 5 specs completas salvas como tasks prontas pra execução pós-janela — mais a estimativa de horas por semana que eu recupero quando estiverem rodando.

CONFIGURAÇÃO DA SESSÃO (leia antes de tudo): modelo principal Fable 5, effort máximo; sem squad — esta é uma conversa, não um pipeline. Tipo: INTERATIVA e PESSOAL — o conteúdo fica entre o usuário e o Brain dele. Execução: paralela, sem dependências; boa pra fazer com calma, não no meio de outras 5 sessões. Se esta missão veio de uma task do Brain: in_progress ao começar, complete_task ao terminar.

Aja como meu conselheiro de desenvolvimento profissional — conversa franca, entre a gente. Contexto: a empresa passou por reestruturação, funções mudaram, e o trabalho em si está mudando com IA e agentes. Quero pensar a MINHA trajetória com a mesma seriedade que a empresa pensa a dela.

Me entreviste de verdade, uma pergunta de cada vez, sem pressa: o que mudou na minha função e como eu me sinto nela hoje; onde eu gero mais valor e onde eu só apago incêndio; que parte do meu trabalho um agente faz em 2 anos, e o que isso exige que eu me torne; o que eu quero estar fazendo em 2 anos — e o que estou fazendo hoje que me leva pra lá (ou não).

Não valide por educação: se minhas respostas se contradisserem, aponte. Se eu estiver confortável demais, pergunte o que estou evitando. Devolva o que ouvir com padrões que eu não estou vendo.

No final, monte comigo: (1) as 2-3 habilidades que mais mudam meu jogo nos próximos 12 meses e como treinar cada uma no trabalho real (não em curso), (2) uma conversa que eu preciso ter e estou adiando, (3) o plano de 90 dias em passos pequenos. Salve o essencial no meu Brain (insights e o plano), deixando de fora os detalhes íntimos que eu pedir pra não registrar.

CONFIGURAÇÃO DA SESSÃO (leia antes de tudo): modelo principal Fable 5, effort alto; verificação em subagentes Sonnet — você decide os modelos do squad. Tipo: INTERATIVA curta (30-45 min). Execução: a ÚLTIMA missão da janela — rode no fim do dia 07/07, depois que as outras terminarem ou forem abandonadas. Se esta missão veio de uma task do Brain: in_progress ao começar, complete_task ao terminar.

A janela do Fable está fechando. Sua missão: garantir que NADA do que foi produzido nela dependa de memória de sessão — plano bom sobrevive ao modelo, mas só se estiver gravado.

1. INVENTARIAR (subagentes): rode list_tasks no meu Brain e liste todas as "Missão Fable M#": o que está done (com que outcome), o que está in_progress e o que nem começou. Varra também os artefatos que as missões geraram (diffs aprovados, playbooks, specs, relatórios) e onde cada um está salvo.

2. CAÇAR O QUE VAI MORRER (você, effort alto): o que existe só dentro de uma conversa e não foi salvo? Decisão tomada mas não registrada, spec pela metade, diff não aplicado, aprendizado solto. Pra cada item: salve agora (nota ou task no Brain, com o contexto completo dentro) ou me pergunte se pode descartar.

3. EMPACOTAR O QUE FICOU PELO CAMINHO: missão que não terminou vira task no Brain com o estado atual, o que falta e o prompt pra continuar em Opus/Sonnet — título "Continuar Missão M# (pós-Fable)". Missão que nem começou: me pergunte se mantém (reescrita pra modelo menor) ou se mata.

4. ME ENTREGAR O MAPA: uma mensagem final com o que a janela produziu (uma linha por missão), as tasks prontas pra rodar em modelo menor (na ordem) e as 3 coisas mais valiosas que saíram desses 2 dias. Salve esse balanço como nota no meu Brain.