edusquads-cli 0.2.1 → 0.2.3

package/.claude/skills/edusquads/SKILL.md

@@ -34,10 +34,11 @@ Operar squads multiagente no Claude Code com comportamento semelhante ao OpenSqu
 ## Processo
 1. ler contexto obrigatório e memória ativa
 2. validar campos críticos de memória; coletar lacunas antes de planejar
-3. diagnosticar intenção e mapear squads/agentes/skills adequados
-4. propor ou executar plano em etapas com checkpoints
-5. registrar decisões, evidências e status no run correspondente
-6. encerrar com próximos passos objetivos
+3. refinar público com skill de ICP quando o público estiver genérico
+4. diagnosticar intenção e mapear squads/agentes/skills adequados
+5. propor ou executar plano em etapas com checkpoints
+6. registrar decisões, evidências e status no run correspondente
+7. encerrar com próximos passos objetivos
 
 ## Saída
 - plano de execução multi-squad (quando aplicável)
@@ -87,21 +88,34 @@ Operar squads multiagente no Claude Code com comportamento semelhante ao OpenSqu
 - Toda saída deve conter critério de qualidade.
 
 ## Memória do usuário (obrigatório)
-### Arquivo
-- `_edusquads/memoria/USUARIO-ATIVO.md`
+### Arquivos
+- ativo: `_edusquads/memoria/USUARIO-ATIVO.md`
+- modelo: `_edusquads/memoria/USUARIO-MODELO.md`
+- perfis: `_edusquads/memoria/usuarios/<slug>.md`
 
 ### Campos críticos
-- nicho
-- público-alvo
-- objetivo principal
-- canal principal
-- oferta principal (ou hipótese)
+- nome preferido
+- o que a pessoa faz
+- onde vende
+- meta principal (30-90 dias)
+- formato favorito
+- público inicial (rascunho)
 
 ### Fluxo de memória
 1. Ler memória ativa.
-2. Se campo crítico faltar, perguntar objetivamente (1-3 perguntas curtas).
-3. Atualizar o arquivo de memória com os novos dados.
-4. Só então propor plano de squads.
+2. Se campo crítico faltar, iniciar onboarding enxuto.
+3. Salvar briefing no perfil individual (`usuarios/<slug>.md`).
+4. Atualizar `USUARIO-ATIVO.md` com o briefing coletado.
+5. Refinar público com skill ICP (`squads/02-pesquisa/skills/refinar-icp.md`).
+6. Só então propor plano de squads.
+
+### Roteiro de briefing obrigatório
+1. quem é a pessoa e o que ela faz
+2. o que vende e onde vende
+3. meta principal (30-90 dias)
+4. formato favorito de conteúdo
+5. público inicial em linguagem da pessoa
+6. acionar skill de ICP para refinar público (`squads/02-pesquisa/skills/refinar-icp.md`)
 
 ## Modo de comando `/edusquads`
 Interpretar intenção do usuário por subcomando semântico.
@@ -110,9 +124,11 @@ Interpretar intenção do usuário por subcomando semântico.
 - Diagnóstico rápido e sugestão do próximo passo.
 
 ### `/edusquads init`
-- Inicializa memória do usuário.
-- Coleta dados críticos.
-- Define ponto de partida do sistema.
+- Inicia onboarding do usuário.
+- Coleta briefing enxuto e salva perfil + usuário ativo.
+
+### `/edusquads onboarding`
+- Força nova coleta de briefing para troca/atualização de usuário.
 
 ### `/edusquads status`
 - Resume estado atual: memória, squads sugeridos, artefatos-chave.

package/README.md

@@ -29,8 +29,22 @@ npx edusquads-cli install --ide claude,codex,opencode,kilocode,antigravity
 npx edusquads-cli install --ide all
 npx edusquads-cli install --force
 npx edusquads-cli install --dry-run
+npx edusquads-cli install --skip-onboarding
 ```
 
+Após instalar, o CLI pergunta no terminal se a pessoa quer preencher o briefing na hora.
+Se aceitar, ele executa onboarding enxuto e grava a memória automaticamente.
+
+Briefing enxuto coleta apenas:
+- o que a pessoa faz
+- o que vende e onde vende
+- meta principal (30-90 dias)
+- formato favorito
+- público inicial (rascunho)
+
+Depois disso, o sistema refina o público com a skill de ICP.
+
+
 Depois da instalação, abra o projeto no Claude Code e use:
 
 - `/edusquads`
@@ -43,7 +57,8 @@ Como o Claude Code suporta skills em `.claude/skills/<nome>/SKILL.md`, a skill `
 - `especialistas/`: biblioteca de fundamentos por especialista
 - `squads/`: definição dos squads e agentes oficiais
 - `pesquisa/web/`: sínteses com fontes públicas
-- `_edusquads/memoria/`: memória operacional do usuário
+- `_edusquads/memoria/`: memória operacional do usuário (ativo + perfis em `usuarios/`)
+- `squads/02-pesquisa/skills/refinar-icp.md`: skill para refinar público a partir do briefing
 - `_edusquads/runs/`: histórico de execuções do `/edusquads`
 - `_edusquads/browser_profile/`: sessão local de navegação (Playwright)
 - `_edusquads/evidencias/`: evidências de investigação web
@@ -54,6 +69,8 @@ Sistema operacional implementado com foco em:
 - comando `/edusquads`
 - paridade funcional base inspirada no OpenSquad
 - memória persistida do usuário (`_edusquads/memoria/USUARIO-ATIVO.md`)
+- onboarding interativo enxuto de briefing (`base/scripts/edusquads_onboarding_memoria.py`)
+- refino de público via skill ICP (`squads/02-pesquisa/skills/refinar-icp.md`)
 - histórico de runs (`_edusquads/runs/`)
 - protocolo de investigação web com Playwright (`base/protocolo-playwright-edusquads.md`)
 - playbooks por plataforma (`base/playbooks/investigacao/`)

package/_edusquads/memoria/USUARIO-ATIVO.md

@@ -1,42 +1,31 @@
 # Memória do Usuário Ativo
 
 ## Identidade
-- Nome preferido: não informado
-- Projeto/negócio: EduSquads
-- Papel do usuário: arquiteto/produto do framework
+- Nome preferido:
+- O que a pessoa faz:
 
-## Estado atual
-- Nicho principal: framework de squads de IA para Claude Code
-- Público-alvo: equipes, creators e operadores que querem executar pipelines multiagente
-- Oferta principal: sistema `/edusquads` com squads interligados e memória operacional
-- Maturidade da operação (inicial/intermediária/avançada): intermediária (arquitetura já estruturada)
+## Negócio e Canal
+- O que vende:
+- Onde vende:
 
-## Objetivos em andamento
-- Objetivo principal (30-90 dias): paridade funcional base com OpenSquad no Claude via `/edusquads`
-- Objetivo secundário: consolidar integração entre squads e catálogo operacional
-- KPI principal: capacidade de iniciar objetivo e receber plano/execução multi-squad com memória aplicada
+## Meta principal
+- Meta (30-90 dias):
 
-## Preferências
-- Canais prioritários: não informado
-- Estilo de comunicação: direto, prático, em PT-BR
-- Formato de entrega preferido: estrutura operacional com arquivos e comandos
-
-## Restrições
-- Tempo disponível: não informado
-- Equipe disponível: não informado
-- Orçamento aproximado: não informado
-- Limites operacionais: manter padrão de fundamento por especialista e comando único `/edusquads`
+## Público
+- Público inicial (rascunho):
+- ICP prioritário (refinado):
+- Variações de ICP:
+  -
+  -
+  -
 
-## Stack e ativos
-- Ferramentas atuais: Claude Code + skills locais
-- Ativos existentes (lista/email/site/perfis): base de squads, agentes, especialistas e matrizes já criada neste repositório
-- Dados disponíveis: documentação interna do projeto + pesquisas web registradas
+## Preferências
+- Formato favorito:
+- Estilo de comunicação preferido:
 
 ## Histórico de decisões
-- [x] comando principal adotado: `/edusquads`
-- [x] estrutura oficial: 16 squads e 160 agentes
-- [x] memória ativa do usuário em `_edusquads/memoria/USUARIO-ATIVO.md`
+- [ ]
 
 ## Última atualização
-- Data: 2026-04-11
-- Origem da atualização: consolidação automática a partir da conversa atual
+- Data:
+- Origem da atualização:

package/base/comandos/edusquads-comandos.md

@@ -6,11 +6,16 @@
 
 ## Subcomandos semânticos (via args)
 - `/edusquads init`
-  - inicializa memória do usuário e contexto do projeto
+  - inicia onboarding e coleta briefing enxuto da pessoa usuária
+  - salva perfil em `_edusquads/memoria/usuarios/` e atualiza `USUARIO-ATIVO.md`
+- `/edusquads onboarding`
+  - força nova coleta de briefing para troca/atualização de usuário
 - `/edusquads status`
   - resume estado dos squads, memória e artefatos
 - `/edusquads memoria`
   - mostra e atualiza memória ativa
+- `/edusquads icp`
+  - refina público-alvo com a skill de ICP (`squads/02-pesquisa/skills/refinar-icp.md`)
 - `/edusquads squads`
   - lista os 16 squads e indica quais usar no objetivo atual
 - `/edusquads plano <objetivo>`
@@ -28,13 +33,19 @@
   - inicia fluxo de autenticação manual para sessão Playwright
 - `/edusquads revogar-sessoes`
   - remove sessão local persistida em `_edusquads/browser_profile/`
+- `/edusquads estruturar-coleta <run_id>`
+  - converte coleta bruta em sinais estruturados por plataforma
+  - usa `python base/scripts/edusquads_estruturar_coleta.py`
 - `/edusquads concluir-investigacao <run_id>`
   - preenche síntese/extrações automaticamente e fecha run
   - usa `python base/scripts/edusquads_concluir_investigacao.py`
 
 ## Regras
 - todos os subcomandos usam `_edusquads/memoria/USUARIO-ATIVO.md`
-- se memória crítica estiver vazia, coletar antes de executar o plano
+- onboarding é obrigatório quando memória crítica estiver vazia
+- onboarding pode ser executado por `base/scripts/edusquads_onboarding_memoria.py`
+- após onboarding, refinar público com `squads/02-pesquisa/skills/refinar-icp.md`
+- onboarding deve salvar perfil em `_edusquads/memoria/usuarios/` e atualizar `USUARIO-ATIVO.md`
 - cada execução relevante deve gerar/atualizar um run em `_edusquads/runs/`
 - toda investigação web deve seguir `base/protocolo-playwright-edusquads.md`
 - toda investigação web deve aplicar o playbook da plataforma em `base/playbooks/investigacao/`
@@ -42,5 +53,4 @@
 - para estruturar coleta, usar `base/scripts/edusquads_estruturar_coleta.py`
 - para fechar investigação, usar `base/scripts/edusquads_concluir_investigacao.py`
 - nunca persistir sessão sem consentimento explícito
-- decisões relevantes devem ser registradas na seção de histórico da memória e no run ativo
-ões relevantes devem ser registradas na seção de histórico da memória e no run ativo
+- decisões relevantes devem ser registradas na memória e no run ativo

package/base/protocolo-memoria-usuario.md

@@ -1,50 +1,52 @@
 # Protocolo de Memória do Usuário (EduSquads)
 
 ## Objetivo
-Manter uma memória operacional do usuário para personalizar a atuação dos squads no comando `/edusquads`.
+Manter uma memória operacional da pessoa usuária para personalizar a atuação dos squads no comando `/edusquads`.
 
-## Arquivo ativo
-- `_edusquads/memoria/USUARIO-ATIVO.md`
+## Arquivos de memória
+- ativo: `_edusquads/memoria/USUARIO-ATIVO.md`
+- modelo: `_edusquads/memoria/USUARIO-MODELO.md`
+- perfis por pessoa: `_edusquads/memoria/usuarios/<slug>.md`
 
 ## Quando coletar memória
 1. Primeira execução do `/edusquads` no projeto
-2. Quando o usuário pedir atualização de contexto pessoal/profissional
-3. Quando houver mudança relevante de nicho, objetivo ou estilo
-
-## Campos mínimos
-- nome preferido
-- projeto/negócio principal
-- nicho
-- público-alvo
-- objetivos atuais
-- canais prioritários
-- stack/ferramentas
-- restrições (tempo, orçamento, equipe)
-- estilo de comunicação preferido
-- decisões já tomadas
+2. Quando houver troca de usuário
+3. Quando a pessoa pedir atualização de contexto
 
 ## Princípios
-- coletar apenas dados úteis para execução
-- resumir em linguagem operacional
-- separar fato de inferência
+- coletar somente dados úteis para execução
+- manter briefing enxuto
+- não pedir KPI técnico no onboarding inicial
 - nunca registrar segredos/token/senhas na memória
 
-## Formato de atualização
-Sempre atualizar por bloco:
-1. `## Estado atual`
-2. `## Objetivos em andamento`
-3. `## Preferências`
-4. `## Restrições`
-5. `## Histórico de decisões`
-
 ## Regras de uso no comando
 - antes de planejar squads, ler `USUARIO-ATIVO.md`
-- se campos críticos estiverem vazios, perguntar objetivamente
-- toda recomendação deve refletir esse contexto
+- se campos críticos estiverem vazios, executar onboarding enxuto
+- salvar briefing no perfil individual e atualizar o usuário ativo
+- após onboarding, refinar público com skill ICP
 
 ## Campos críticos (não seguir sem isso)
-- nicho
-- público-alvo
-- objetivo principal
-- canal principal
-- oferta principal (ou hipótese de oferta)
+- nome preferido
+- o que a pessoa faz
+- onde vende
+- meta principal (30-90 dias)
+- formato favorito
+- público inicial (rascunho)
+
+## Roteiro obrigatório de briefing (onboarding enxuto)
+1. Quem é a pessoa e o que ela faz
+2. O que vende e onde vende
+3. Meta principal para os próximos 30-90 dias
+4. Formato favorito de conteúdo
+5. Público inicial em linguagem da pessoa
+6. Refinar esse público com a skill de ICP (`squads/02-pesquisa/skills/refinar-icp.md`)
+
+## Formato de atualização
+Sempre atualizar por bloco:
+1. `## Identidade`
+2. `## Negócio e Canal`
+3. `## Meta principal`
+4. `## Público`
+5. `## Preferências`
+6. `## Histórico de decisões`
+7. `## Última atualização`

package/base/scripts/edusquads_onboarding_memoria.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""
+Onboarding enxuto de memória do EduSquads.
+
+Coleta briefing essencial e salva em:
+- _edusquads/memoria/USUARIO-ATIVO.md
+- _edusquads/memoria/usuarios/<slug>.md
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import re
+from pathlib import Path
+
+RESET = "\033[0m"
+BOLD = "\033[1m"
+DIM = "\033[2m"
+CYAN = "\033[36m"
+GREEN = "\033[32m"
+YELLOW = "\033[33m"
+
+
+def ui_title(text: str) -> None:
+    print(f"\n{BOLD}{CYAN}╭──────────────────────────────────────────────╮{RESET}")
+    print(f"{BOLD}{CYAN}│{RESET} {BOLD}{text:<44}{RESET} {BOLD}{CYAN}│{RESET}")
+    print(f"{BOLD}{CYAN}╰──────────────────────────────────────────────╯{RESET}\n")
+
+
+def ui_step(number: int, title: str) -> None:
+    print(f"{BOLD}{CYAN}[{number}/6]{RESET} {BOLD}{title}{RESET}")
+
+
+def ask(prompt: str, required: bool = True, hint: str | None = None) -> str:
+    if hint:
+        print(f"{DIM}{hint}{RESET}")
+    while True:
+        value = input(f"{prompt}: ").strip()
+        if value or not required:
+            return value
+        print(f"{YELLOW}Campo obrigatório. Responda para continuar.{RESET}")
+
+
+def slugify(text: str) -> str:
+    t = text.strip().lower()
+    t = re.sub(r"[^a-z0-9\s-]", "", t)
+    t = re.sub(r"\s+", "-", t)
+    t = re.sub(r"-+", "-", t)
+    return t or "usuario"
+
+
+def refine_icp(data: dict) -> tuple[str, list[str]]:
+    publico_base = data["publico_inicial"]
+    canal = data["onde_vende"]
+    meta = data["meta_90_dias"]
+    formato = data["formato_favorito"]
+
+    icp_prioritario = (
+        f"Profissionais que já reconhecem o problema que {data['o_que_faz']} resolve, "
+        f"estão buscando avanço prático nos próximos 90 dias e consomem {formato} "
+        f"antes de decidir compra em {canal}."
+    )
+
+    variacoes = [
+        f"Conservador: {publico_base} com urgência imediata para atingir '{meta}'.",
+        f"Principal: {icp_prioritario}",
+        f"Expansão: público adjacente a {publico_base}, com dor semelhante e menor consciência do problema.",
+    ]
+
+    return icp_prioritario, variacoes
+
+
+def render_memory(data: dict, source: str) -> str:
+    today = dt.date.today().isoformat()
+    icp_prioritario, variacoes = refine_icp(data)
+
+    return f"""# Memória do Usuário Ativo
+
+## Identidade
+- Nome preferido: {data['nome']}
+- O que a pessoa faz: {data['o_que_faz']}
+
+## Negócio e Canal
+- O que vende: {data['o_que_vende']}
+- Onde vende: {data['onde_vende']}
+
+## Meta principal
+- Meta (30-90 dias): {data['meta_90_dias']}
+
+## Público
+- Público inicial (rascunho): {data['publico_inicial']}
+- ICP prioritário (refinado): {icp_prioritario}
+- Variações de ICP:
+  - {variacoes[0]}
+  - {variacoes[1]}
+  - {variacoes[2]}
+
+## Preferências
+- Formato favorito: {data['formato_favorito']}
+- Estilo de comunicação preferido: {data['estilo']}
+
+## Histórico de decisões
+- [x] briefing inicial coletado no onboarding enxuto
+- [x] público refinado via skill de ICP (`squads/02-pesquisa/skills/refinar-icp.md`)
+
+## Última atualização
+- Data: {today}
+- Origem da atualização: {source}
+"""
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Onboarding enxuto de memória EduSquads")
+    parser.add_argument("--target", default=".", help="Diretório do projeto")
+    args = parser.parse_args()
+
+    root = Path(args.target).resolve()
+    mem_dir = root / "_edusquads" / "memoria"
+    users_dir = mem_dir / "usuarios"
+    mem_dir.mkdir(parents=True, exist_ok=True)
+    users_dir.mkdir(parents=True, exist_ok=True)
+
+    ui_title("EduSquads · Onboarding de Briefing")
+    print("Briefing enxuto: poucas perguntas, resposta objetiva.\n")
+
+    ui_step(1, "Identidade")
+    nome = ask("Nome preferido")
+    o_que_faz = ask("O que você faz", hint="Ex.: consultoria em IA, mentoria de vendas, agência de tráfego")
+
+    ui_step(2, "Oferta")
+    o_que_vende = ask("O que você vende", hint="Produto, serviço, programa, assinatura etc.")
+    onde_vende = ask("Onde você vende", hint="Ex.: Instagram DM, WhatsApp, landing page, LinkedIn, YouTube")
+
+    ui_step(3, "Meta")
+    meta_90_dias = ask("Meta principal (30-90 dias)", hint="Troque KPI técnico por resultado que você quer alcançar")
+
+    ui_step(4, "Público inicial")
+    publico_inicial = ask("Quem você quer atingir hoje", hint="Pode ser rascunho. A skill ICP vai refinar")
+
+    ui_step(5, "Preferências")
+    formato_favorito = ask("Formato favorito de conteúdo", hint="Ex.: carrossel, reels, live, aula, newsletter")
+    estilo = ask("Estilo de comunicação", required=False) or "direto e prático"
+
+    ui_step(6, "Confirmação")
+    print(f"{DIM}Vamos salvar e gerar ICP refinado automaticamente.{RESET}")
+
+    data = {
+        "nome": nome,
+        "o_que_faz": o_que_faz,
+        "o_que_vende": o_que_vende,
+        "onde_vende": onde_vende,
+        "meta_90_dias": meta_90_dias,
+        "publico_inicial": publico_inicial,
+        "formato_favorito": formato_favorito,
+        "estilo": estilo,
+    }
+
+    content = render_memory(data, source="onboarding-enxuto-interativo")
+
+    active_path = mem_dir / "USUARIO-ATIVO.md"
+    active_path.write_text(content, encoding="utf-8")
+
+    slug = slugify(nome)
+    profile_path = users_dir / f"{slug}.md"
+    profile_path.write_text(content, encoding="utf-8")
+
+    print(f"\n{GREEN}✅ Briefing salvo com sucesso{RESET}")
+    print(f"- ativo: {active_path}")
+    print(f"- perfil: {profile_path}")
+    print(f"- icp skill: squads/02-pesquisa/skills/refinar-icp.md\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/bin/edusquads.js

@@ -3,11 +3,35 @@
 const fs = require("fs");
 const path = require("path");
 const readline = require("readline");
+const { spawnSync } = require("child_process");
+
+const UI = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+};
+
+function style(text, ...codes) {
+  return `${codes.join("")}${text}${UI.reset}`;
+}
+
+function panel(title) {
+  const w = 52;
+  const t = ` ${title} `;
+  const line = "─".repeat(Math.max(0, w - t.length));
+  console.log(`\n${style("╭" + t + line + "╮", UI.cyan, UI.bold)}`);
+  console.log(`${style("╰" + "─".repeat(w) + "╯", UI.cyan, UI.bold)}`);
+}
 
 const args = process.argv.slice(2);
 const command = args.find((a) => !a.startsWith("-")) || "install";
 const force = args.includes("--force");
 const dryRun = args.includes("--dry-run");
+const skipOnboarding = args.includes("--skip-onboarding");
 const targetArgIndex = args.findIndex((a) => a === "--target");
 const targetDir =
   targetArgIndex >= 0 && args[targetArgIndex + 1]
@@ -34,6 +58,8 @@ const SHARED_INSTALL_ITEMS = [
   { src: "pesquisa", dest: "pesquisa" },
   { src: "squads", dest: "squads" },
   { src: "_edusquads/memoria/USUARIO-ATIVO.md", dest: "_edusquads/memoria/USUARIO-ATIVO.md" },
+  { src: "_edusquads/memoria/USUARIO-MODELO.md", dest: "_edusquads/memoria/USUARIO-MODELO.md" },
+  { src: "_edusquads/memoria/usuarios/README.md", dest: "_edusquads/memoria/usuarios/README.md" },
   { src: "_edusquads/runs/RUN-MODELO.md", dest: "_edusquads/runs/RUN-MODELO.md" },
   { src: "_edusquads/runs/RUNS-INDEX.md", dest: "_edusquads/runs/RUNS-INDEX.md" },
   { src: "_edusquads/evidencias/EVIDENCIA-MODELO.md", dest: "_edusquads/evidencias/EVIDENCIA-MODELO.md" },
@@ -56,6 +82,7 @@ Opções:
                    Se omitido, o CLI pergunta no terminal.
   --force          Sobrescreve arquivos existentes
   --dry-run        Simula instalação sem gravar arquivos
+  --skip-onboarding Não pergunta briefing após instalar
 `);
 }
 
@@ -165,6 +192,34 @@ function ask(promptText) {
   });
 }
 
+async function askOnboarding() {
+  if (skipOnboarding || dryRun) return false;
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+  const ans = (await ask(`${style("\n→", UI.cyan, UI.bold)} Deseja iniciar o briefing guiado agora? ${style("(s/N)", UI.dim)} `)).trim().toLowerCase();
+  return ["s", "sim", "y", "yes"].includes(ans);
+}
+
+function runOnboarding(target) {
+  const script = path.join(target, "base", "scripts", "edusquads_onboarding_memoria.py");
+  if (!fs.existsSync(script)) {
+    console.log("\n⚠️ Script de onboarding não encontrado. Pule e rode manualmente depois.");
+    return;
+  }
+
+  const pyCmd = process.platform === "win32" ? "python" : "python3";
+  const r = spawnSync(pyCmd, [script, "--target", target], {
+    stdio: "inherit",
+    cwd: target,
+    env: process.env,
+  });
+
+  if (r.status !== 0) {
+    console.log("\n⚠️ Não foi possível concluir o onboarding automaticamente.");
+    console.log("Rode manualmente:");
+    console.log(`  ${pyCmd} base/scripts/edusquads_onboarding_memoria.py --target ${target}`);
+  }
+}
+
 async function resolveIdes() {
   if (ideArg) return parseIdes(ideArg);
 
@@ -172,15 +227,15 @@ async function resolveIdes() {
     return ["claude"];
   }
 
-  console.log("\nSelecione a(s) IDE(s) para instalar o EduSquads:");
-  console.log("  1) claude (Claude Code)");
-  console.log("  2) codex");
-  console.log("  3) opencode");
-  console.log("  4) kilocode");
-  console.log("  5) antigravity");
-  console.log("  6) all (todas)");
+  panel("EduSquads · Seleção de IDE");
+  console.log(`${style("  1)", UI.cyan)} claude ${style("(Claude Code)", UI.dim)}`);
+  console.log(`${style("  2)", UI.cyan)} codex`);
+  console.log(`${style("  3)", UI.cyan)} opencode`);
+  console.log(`${style("  4)", UI.cyan)} kilocode`);
+  console.log(`${style("  5)", UI.cyan)} antigravity`);
+  console.log(`${style("  6)", UI.cyan)} all ${style("(todas)", UI.dim)}`);
 
-  const answer = (await ask("Digite número(s) separados por vírgula (default: 1): ")).trim();
+  const answer = (await ask(`${style("\n→", UI.cyan, UI.bold)} Digite número(s) separados por vírgula ${style("[default: 1]", UI.dim)}: `)).trim();
   if (!answer) return ["claude"];
 
   const numberMap = {
@@ -240,14 +295,21 @@ async function install() {
   const gitignoreChanged = patchGitignore(targetDir);
   writeInstallMarker(targetDir, ides);
 
-  console.log(`\nEduSquads ${dryRun ? "(simulação) " : ""}instalado em: ${targetDir}`);
-  console.log(`IDEs instaladas: ${ides.join(", ")}`);
-  console.log(`Arquivos criados: ${report.created}`);
-  console.log(`Arquivos sobrescritos: ${report.overwritten}`);
-  console.log(`Arquivos ignorados (já existiam): ${report.skipped}`);
-  console.log(`.gitignore atualizado: ${gitignoreChanged ? "sim" : "não"}`);
+  panel("EduSquads · Instalação concluída");
+  console.log(`${style("✔", UI.green, UI.bold)} destino: ${targetDir}`);
+  console.log(`${style("✔", UI.green, UI.bold)} IDEs: ${ides.join(", ")}`);
+  console.log(`${style("•", UI.cyan)} criados: ${report.created}`);
+  console.log(`${style("•", UI.cyan)} sobrescritos: ${report.overwritten}`);
+  console.log(`${style("•", UI.cyan)} ignorados: ${report.skipped}`);
+  console.log(`${style("•", UI.cyan)} .gitignore atualizado: ${gitignoreChanged ? "sim" : "não"}`);
+
+  const doOnboarding = await askOnboarding();
+  if (doOnboarding) {
+    console.log(`\n${style("→", UI.cyan, UI.bold)} Iniciando briefing guiado...\n`);
+    runOnboarding(targetDir);
+  }
 
-  console.log("\nComandos esperados por IDE (após abrir o projeto na IDE):");
+  console.log(`\n${style("Próximo passo", UI.bold)}:`);
   for (const ide of ides) {
     if (ide === "claude") console.log("- Claude Code: /edusquads");
     else console.log(`- ${ide}: skill 'edusquads' instalada em ${IDE_SKILL_PATHS[ide]}`);

package/carrosseis.md

@@ -2,6 +2,19 @@
 
 Voce e um agente especializado em criar carrosseis profissionais para o Instagram no estilo editorial/investigativo inspirado em [PERFIL_INSPIRACAO] e perfis de growth/conteudo viral. Todos os carrosseis sao de autoria do **[SEU_INSTAGRAM]** e tem como tema principal **Inteligencia Artificial**.
 
+## Pre-check obrigatorio (antes de qualquer criacao)
+
+Antes de iniciar, **sempre** coletar e validar as credenciais da pessoa usuaria:
+
+- `APIFY_API_TOKEN` (para pesquisa de tendencias no Reddit)
+- `UNSPLASH_ACCESS_KEY` (para busca de fotos)
+
+Regras:
+- Nao iniciar roteiro, HTML ou imagens sem essas duas chaves.
+- Se alguma chave faltar, pausar e pedir a chave primeiro.
+- Nunca expor a chave em resposta, log, markdown ou print.
+- Quando o ambiente suportar coleta segura, usar fluxo seguro de segredo (ex.: coleta mascarada).
+
 ---
 
 ## Identidade Visual (Estilo Editorial/Investigativo)
@@ -243,7 +256,7 @@ Use a API do Apify para acessar o Reddit e encontrar topicos em alta sobre **Int
 
 ```bash
 # Buscar posts trending no Reddit sobre IA
-curl -X POST "https://api.apify.com/v2/acts/trudax~reddit-scraper/runs?token=apify_api_nRqx0LcknCK9HAkJChOYhLlAgzmNkf2eh8cE" \
+curl -X POST "https://api.apify.com/v2/acts/trudax~reddit-scraper/runs?token=${APIFY_API_TOKEN}" \
   -H "Content-Type: application/json" \
   -d '{
     "startUrls": [
@@ -266,7 +279,7 @@ Depois, busque os resultados:
 
 ```bash
 # Verificar status e buscar resultados
-curl "https://api.apify.com/v2/acts/trudax~reddit-scraper/runs/last/dataset/items?token=apify_api_nRqx0LcknCK9HAkJChOYhLlAgzmNkf2eh8cE"
+curl "https://api.apify.com/v2/acts/trudax~reddit-scraper/runs/last/dataset/items?token=${APIFY_API_TOKEN}"
 ```
 
 **Subreddits de IA recomendados:**
@@ -288,7 +301,7 @@ Analise os posts com mais engajamento e extraia:
 
 ```bash
 # Buscar imagens relevantes ao tema
-curl -H "Authorization: Client-ID [SUA_UNSPLASH_ACCESS_KEY]" \
+curl -H "Authorization: Client-ID ${UNSPLASH_ACCESS_KEY}" \
   "https://api.unsplash.com/search/photos?query=TEMA_AQUI&per_page=10&orientation=portrait"
 ```
 
@@ -955,6 +968,7 @@ Siga [SEU_INSTAGRAM] para mais conteudo sobre IA.
 
 Quando o usuario pedir para criar um carrossel, siga este fluxo:
 
+0. **Coletar e validar credenciais** (`APIFY_API_TOKEN` e `UNSPLASH_ACCESS_KEY`)
 1. **Pesquise tendencias de IA** no Reddit usando Apify API
 2. **Escolha o tema** mais relevante/viral encontrado
 3. **Crie o roteiro** com titulos investigativos e textos para cada slide
@@ -970,19 +984,23 @@ Quando o usuario pedir para criar um carrossel, siga este fluxo:
 
 ### Unsplash API
 - **Endpoint**: `https://api.unsplash.com/search/photos`
-- **Header**: `Authorization: Client-ID [SUA_UNSPLASH_ACCESS_KEY]`
-- **Application ID**: `904033`
-- **Access Key**: `[SUA_UNSPLASH_ACCESS_KEY]`
-- **Secret Key**: `[SUA_UNSPLASH_SECRET_KEY]`
-- **Redirect URI**: `urn:ietf:wg:oauth:2.0:oob`
+- **Header**: `Authorization: Client-ID ${UNSPLASH_ACCESS_KEY}`
+- **Variavel obrigatoria**: `UNSPLASH_ACCESS_KEY`
+- **Opcional**: `UNSPLASH_SECRET_KEY` (nao necessaria para busca publica de fotos)
 - **Docs**: https://unsplash.com/documentation
 - **Campo de URL para slides**: `results[n].urls.regular` (1080px)
 
 ### Apify (Reddit Scraper)
-- **Token**: `apify_api_nRqx0LcknCK9HAkJChOYhLlAgzmNkf2eh8cE`
+- **Token**: `${APIFY_API_TOKEN}`
+- **Variavel obrigatoria**: `APIFY_API_TOKEN`
 - **Actor**: `trudax~reddit-scraper`
 - **Endpoint base**: `https://api.apify.com/v2/acts/trudax~reddit-scraper/runs`
 
 ### Playwright MCP
 - Usar para renderizar HTML e capturar screenshots dos slides
 - Viewport: 1080x1350 (formato Instagram 4:5)
+
+### Politica de seguranca
+- Nunca escrever chaves em markdown, codigo fonte, logs ou resposta final.
+- Nunca usar token fixo/hardcoded no comando.
+- Se faltar credencial, interromper e solicitar antes de continuar.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edusquads-cli",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Instalador do framework EduSquads para Claude Code via npx.",
   "bin": {
     "edusquads": "bin/edusquads.js"

package/squads/02-pesquisa/skills/refinar-icp.md

@@ -0,0 +1,60 @@
+# Skill: Refinar ICP
+
+## objetivo
+Refinar o público inicial informado pela pessoa usuária em um ICP operacional, específico e acionável para conteúdo, oferta e aquisição.
+
+## quando usar
+- quando o briefing tiver público genérico (ex.: "empreendedores", "empresas")
+- quando a mensagem estiver ampla demais
+- antes de gerar plano de conteúdo, copy ou tráfego
+
+## quando não usar
+- quando o usuário já trouxer ICP específico validado recentemente
+- quando a tarefa não exigir definição de público
+
+## entradas
+- o que a pessoa faz
+- o que vende
+- onde vende
+- meta principal (30-90 dias)
+- formato favorito
+- público inicial (rascunho)
+
+## processo
+1. Identificar quem compra hoje vs. quem a pessoa gostaria de atrair.
+2. Mapear dor principal, contexto e nível de consciência do público.
+3. Delimitar recorte de ICP por cenário de compra (canal + momento + problema).
+4. Redigir ICP em linguagem objetiva (quem é, dor, objetivo, objeção, gatilho de compra).
+5. Gerar 3 variações de ICP (foco conservador, foco principal, foco expansão).
+6. Recomendar ICP prioritário com justificativa curta.
+
+## saída
+- ICP prioritário (1 parágrafo)
+- 3 variações de ICP (bullets)
+- sinais de validação inicial (o que observar em 2-4 semanas)
+- ajustes de mensagem por formato favorito
+
+## critérios
+- específico o suficiente para segmentação prática
+- coerente com o que a pessoa vende e onde vende
+- linguagem simples, sem jargão desnecessário
+- aplicável em conteúdo/copy/oferta imediatamente
+
+## fundamento
+Inspirado em princípios publicamente associados a April Dunford (posicionamento), Joanna Wiebe (voz do cliente) e Donald Miller (clareza de mensagem).
+
+## heurísticas
+- "genérico" não é ICP: sempre exigir recorte de contexto
+- priorizar dor concreta sobre atributo demográfico isolado
+- ICP bom facilita decisão editorial e comercial na mesma direção
+
+## anti-padrões
+- ICP amplo demais ("todo mundo")
+- foco em persona estética sem dor/comportamento de compra
+- trocar ICP a cada semana sem evidência
+
+## fontes
+- `especialistas/posicionamento/april-dunford.md`
+- `especialistas/copy/joanna-wiebe.md`
+- `especialistas/mensagem/donald-miller.md`
+- `base/protocolo-memoria-usuario.md`