wizz-method 2.12.0 → 2.14.0

package/tools/installer/guided/flow.js

@@ -0,0 +1,203 @@
+/**
+ * Guided install: the default path for a first install in an interactive
+ * terminal. Four steps (folder, profile, AI tool, name), a review screen and
+ * sensible defaults for everything else. The full question-by-question flow
+ * stays available with --advanced, and every non-interactive flag keeps
+ * working exactly as before (those paths never reach this file).
+ */
+const prompts = require('../prompts');
+const { t, LANGUAGES } = require('./messages');
+const { getProfile, summarizeAreas } = require('./profiles');
+const steps = require('./steps');
+const { AREA_LABELS } = require('./labels');
+
+// Flags that already answer part of the install: when present the user is
+// scripting or knows what they want, so the legacy flow handles it verbatim.
+const SCRIPTED_FLAGS = [
+  'yes',
+  'advanced',
+  'modules',
+  'tools',
+  'areas',
+  'mcps',
+  'clis',
+  'customSource',
+  'action',
+  'set',
+  'channel',
+  'allStable',
+  'allNext',
+  'next',
+  'pin',
+];
+
+/**
+ * Whether this run should take the guided path.
+ * @param {Object} options - Parsed CLI options
+ * @param {boolean} [isTTY] - Injection seam for tests
+ * @returns {boolean}
+ */
+function isGuidedEligible(options = {}, isTTY = !!process.stdin.isTTY) {
+  if (!isTTY) return false;
+  return !SCRIPTED_FLAGS.some((flag) => {
+    const value = options[flag];
+    return Array.isArray(value) ? value.length > 0 : value !== undefined && value !== false;
+  });
+}
+
+async function listModules() {
+  const { OfficialModules } = require('../modules/official-modules');
+  const { ExternalModuleManager } = require('../modules/external-manager');
+  const builtIn = ((await new OfficialModules().listAvailable()).modules || []).map((mod) => ({
+    code: mod.id,
+    name: mod.name,
+    description: mod.description,
+    defaultSelected: mod.defaultSelected,
+    fromBmad: false,
+  }));
+  const seen = new Set(builtIn.map((mod) => mod.code));
+  const external = (await new ExternalModuleManager().listAvailable())
+    .filter((mod) => !mod.builtIn && !mod.deprecated && !mod.advancedOnly && !seen.has(mod.code))
+    .map((mod) => ({
+      code: mod.code,
+      name: mod.name,
+      description: mod.description,
+      defaultSelected: false,
+      fromBmad: String(mod.url || '').includes('bmad-code-org'),
+    }));
+  return [...builtIn, ...external];
+}
+
+/**
+ * Resolve what a profile installs. Custom asks modules and areas here.
+ * @returns {Promise<{modules: string[], areas: string[]}>} areas [] = all
+ */
+async function resolveSelection(profileId, lang, registry) {
+  const profile = getProfile(profileId);
+  if (profile.id !== 'custom') {
+    return { modules: [...profile.modules], areas: profile.areas ? [...profile.areas] : [] };
+  }
+  const modules = await steps.askModules(lang, await listModules());
+  const areas = modules.includes('bmm') ? await steps.askAreas(lang, registry) : [];
+  return { modules, areas };
+}
+
+async function showReview(ctx) {
+  const { lang, profileId, selection, registry, ides } = ctx;
+  const color = await prompts.getColor();
+  const summary = summarizeAreas(registry, selection.areas);
+  const ok = color.green('✓');
+  const lines = [
+    `${ok} ${t(lang, 'reviewAgents', { n: summary.agents })}  ${color.dim(summary.areas.map((key) => (AREA_LABELS[key] ? AREA_LABELS[key][lang].name : key)).join(' · '))}`,
+    `${ok} ${t(lang, 'reviewSkills', { n: summary.skills })}  ${color.dim(t(lang, 'reviewSkillsHint'))}`,
+    `${ok} ${t(lang, 'reviewMemory')}  ${color.dim(t(lang, 'reviewMemoryHint'))}`,
+    `${ok} ${t(lang, 'reviewTools')}  ${color.dim(ides.join(', '))}`,
+  ];
+  if (selection.modules.includes('lowticket')) lines.push(`${ok} ${t(lang, 'reviewLowticket')}`);
+  await prompts.note(lines.join('\n'), `${t(lang, 'reviewTitle')} (${getProfile(profileId)[lang].name})`);
+}
+
+async function chooseClis(ui, lang, selection) {
+  const plan = await ui.selectClis(selection.modules, selection.areas, {
+    cliMessage: t(lang, 'optionalTitle'),
+    cliOption: (cli) => steps.cliOption(cli, lang),
+  });
+  if (plan.alreadyInstalled.length > 0) {
+    await prompts.log.info(t(lang, 'alreadyInstalled', { list: plan.alreadyInstalled.map((c) => c.id).join(', ') }));
+  }
+  return plan;
+}
+
+async function chooseMcps(ui, lang, profileId, selection) {
+  // Profiles never write MCP config on their own: they only print the
+  // command, like --yes does. Custom asks, same as the legacy flow.
+  if (profileId !== 'custom') return ui.selectMcps(selection.modules, selection.areas, { yes: true });
+  return ui.selectMcps(selection.modules, selection.areas, { mcpMessage: t(lang, 'mcpsQuestion') });
+}
+
+/**
+ * Steps 2 to 4 plus the review loop. Returns everything the installer
+ * needs except module configs.
+ */
+async function collectChoices(ui, lang, registry, ideManager) {
+  let profileId = 'everything';
+  let selection;
+  let ides;
+  let userName;
+  for (;;) {
+    await steps.stepHeader(lang, 2);
+    profileId = await steps.askProfile(lang, profileId);
+    selection = await resolveSelection(profileId, lang, registry);
+    if (!ides) {
+      await steps.stepHeader(lang, 3);
+      ides = await steps.askTools(lang, ideManager);
+      await steps.stepHeader(lang, 4);
+      userName = await steps.askName(lang);
+    }
+    await showReview({ lang, profileId, selection, registry, ides });
+    const cliPlan = await chooseClis(ui, lang, selection);
+    const action = await prompts.select({
+      message: t(lang, 'reviewAction'),
+      choices: [
+        { name: t(lang, 'actionInstall'), value: 'install' },
+        { name: t(lang, 'actionProfile'), value: 'profile' },
+        { name: t(lang, 'actionCustomize'), value: 'customize' },
+      ],
+      default: 'install',
+    });
+    if (action === 'install') {
+      const mcpPlan = await chooseMcps(ui, lang, profileId, selection);
+      return { profileId, selection, ides, userName, cliPlan, mcpPlan };
+    }
+    if (action === 'customize') profileId = 'custom';
+  }
+}
+
+/**
+ * Run the guided fresh install and return the same config shape the legacy
+ * flow returns, so the installer itself does not change.
+ * @param {Object} ui - The UI instance (reuses its validators and pickers)
+ * @param {Object} options - Parsed CLI options
+ * @param {{directory: string, lang: 'en'|'pt', channelOptions: Object}} ctx
+ */
+async function runGuidedInstall(ui, options, ctx) {
+  const { directory, lang, channelOptions } = ctx;
+  const registry = await ui._loadSkillsRegistry();
+  const { IdeManager } = require('../ide/manager');
+  const ideManager = new IdeManager();
+  await ideManager.ensureInitialized();
+
+  const choices = await collectChoices(ui, lang, registry, ideManager);
+  const modules = ['core', ...choices.selection.modules.filter((code) => code !== 'core')];
+  const language = LANGUAGES.find((l) => l.value === lang).communication;
+  const { moduleConfigs, setOverrides } = await ui.collectModuleConfigs(directory, modules, {
+    ...options,
+    userName: choices.userName,
+    communicationLanguage: language,
+    documentOutputLanguage: language,
+    outputFolder: '_wizz-output',
+    yes: true,
+    quiet: true,
+    channelOptions,
+  });
+
+  return {
+    actionType: 'install',
+    directory,
+    modules,
+    ides: choices.ides,
+    skipIde: choices.ides.length === 0,
+    selectedAreas: choices.selection.areas,
+    mcpPlan: choices.mcpPlan,
+    cliPlan: choices.cliPlan,
+    coreConfig: moduleConfigs.core || {},
+    moduleConfigs,
+    setOverrides,
+    skipPrompts: false,
+    channelOptions,
+    traceEnabled: null,
+    guided: { lang, profile: choices.profileId },
+  };
+}
+
+module.exports = { isGuidedEligible, runGuidedInstall, SCRIPTED_FLAGS };

package/tools/installer/guided/labels.js

@@ -0,0 +1,185 @@
+/**
+ * Human-facing labels for the guided installer: one line per area and per
+ * CLI, in English (default) and Portuguese.
+ *
+ * Lives here, not in skills-registry.yaml, on purpose: agents read the
+ * registry at runtime and every extra field there costs tokens on every
+ * routed request. The registry stays the routing contract; this file is only
+ * what a person reads while installing. test/test-guided-installer.js fails
+ * when an area or CLI in the registry has no entry here, so the two cannot
+ * drift apart silently.
+ */
+
+const AREA_LABELS = {
+  designer: {
+    en: { name: 'Design', help: 'UI, landing pages, design systems, motion, video' },
+    pt: { name: 'Design', help: 'interface, landing page, design system, motion, vídeo' },
+  },
+  copy: {
+    en: { name: 'Copy', help: 'sales copy, headlines, emails, sequences' },
+    pt: { name: 'Copy', help: 'texto de venda, headline, e-mail, sequência' },
+  },
+  seo: {
+    en: { name: 'SEO', help: 'audits, AI search, schema, programmatic pages' },
+    pt: { name: 'SEO', help: 'auditoria, busca por IA, schema, páginas em escala' },
+  },
+  growth: {
+    en: { name: 'Growth', help: 'conversion, launch, pricing, retention, offers' },
+    pt: { name: 'Growth', help: 'conversão, lançamento, preço, retenção, oferta' },
+  },
+  social: {
+    en: { name: 'Social', help: 'posts, Reels scripts, content calendar, publishing' },
+    pt: { name: 'Social', help: 'post, roteiro de Reels, calendário, publicação' },
+  },
+  ads: {
+    en: { name: 'Ads', help: 'paid campaigns, ad creatives, conversion tracking' },
+    pt: { name: 'Anúncios', help: 'campanha paga, criativo, tracking de conversão' },
+  },
+  architect: {
+    en: { name: 'Architecture', help: 'databases, security, infra, technical decisions' },
+    pt: { name: 'Arquitetura', help: 'banco, segurança, infra, decisão técnica' },
+  },
+  qa: {
+    en: { name: 'QA', help: 'tests, browser checks, security audit, launch readiness' },
+    pt: { name: 'QA', help: 'teste, verificação no navegador, auditoria, pré-lançamento' },
+  },
+  analyst: {
+    en: { name: 'Analysis', help: 'research, project kickoff, implementation plan' },
+    pt: { name: 'Análise', help: 'pesquisa, kickoff de projeto, plano de implementação' },
+  },
+  dev: {
+    en: { name: 'Development', help: 'build features, fix bugs, code review, sprints' },
+    pt: { name: 'Desenvolvimento', help: 'feature, bug, review de código, sprint' },
+  },
+  pm: {
+    en: { name: 'Product', help: 'briefs, PRDs, requirements, scope' },
+    pt: { name: 'Produto', help: 'brief, PRD, requisitos, escopo' },
+  },
+  'tech-writer': {
+    en: { name: 'Docs', help: 'technical documentation and diagrams' },
+    pt: { name: 'Documentação', help: 'docs técnicas e diagramas' },
+  },
+  'ux-designer': {
+    en: { name: 'UX', help: 'user flows, UX specs, user stories' },
+    pt: { name: 'UX', help: 'fluxos, especificação de UX, user stories' },
+  },
+  memoria: {
+    en: { name: 'Memory', help: 'saves decisions and project state between sessions' },
+    pt: { name: 'Memória', help: 'guarda decisões e estado do projeto entre sessões' },
+  },
+};
+
+// Requirement tokens a CLI can carry. Anything not listed means the tool is
+// free and light. `platform` gates come from the registry itself.
+const NEED_LABELS = {
+  'api-key': { en: 'API key', pt: 'chave de API' },
+  account: { en: 'account', pt: 'conta' },
+  paid: { en: 'paid', pt: 'pago' },
+  'free-plan': { en: 'free plan', pt: 'plano grátis' },
+  docker: { en: 'Docker', pt: 'Docker' },
+  python: { en: 'Python', pt: 'Python' },
+  ffmpeg: { en: 'ffmpeg', pt: 'ffmpeg' },
+  heavy: { en: 'heavy download', pt: 'download pesado' },
+};
+
+const CLI_LABELS = {
+  hyperframes: {
+    needs: ['ffmpeg'],
+    en: 'design video scenes in HTML',
+    pt: 'desenhar cenas de vídeo em HTML',
+  },
+  'claude-video': {
+    needs: ['ffmpeg'],
+    en: 'watch and summarize an existing video',
+    pt: 'assistir e resumir um vídeo existente',
+  },
+  'get-brolls': {
+    needs: ['ffmpeg', 'python'],
+    en: 'find real B-roll footage for a video',
+    pt: 'achar imagens de apoio reais para um vídeo',
+  },
+  buttercut: {
+    needs: ['heavy'],
+    en: 'cut and rough-edit recorded video',
+    pt: 'cortar e pré-editar vídeo gravado',
+  },
+  voicebox: {
+    needs: ['heavy'],
+    en: 'local voice-over and voice cloning',
+    pt: 'narração e clonagem de voz local',
+  },
+  'ctc-align': {
+    needs: ['python'],
+    en: 'word-level timing to sync captions',
+    pt: 'timing palavra a palavra para legenda',
+  },
+  'apple-design': {
+    needs: [],
+    en: 'review native iOS/macOS UI against Apple HIG',
+    pt: 'revisar UI nativa iOS/macOS pelo guia da Apple',
+  },
+  distribb: {
+    needs: ['account', 'paid'],
+    en: 'publish SEO articles and build backlinks',
+    pt: 'publicar artigos de SEO e ganhar backlinks',
+  },
+  buffer: {
+    needs: ['account', 'free-plan'],
+    en: 'publish and schedule social posts',
+    pt: 'publicar e agendar posts nas redes',
+  },
+  'sentry-cli': {
+    needs: ['account'],
+    en: 'read errors from a project that already uses Sentry',
+    pt: 'ler erros de um projeto que já usa Sentry',
+  },
+  archify: {
+    needs: [],
+    en: 'draw validated architecture diagrams',
+    pt: 'desenhar diagramas de arquitetura validados',
+  },
+  'agent-browser': {
+    needs: [],
+    en: 'drive a real browser for checks and screenshots',
+    pt: 'usar um navegador real para testar e tirar print',
+  },
+  strix: {
+    needs: ['docker', 'api-key'],
+    en: 'automated pentest, only on systems you own',
+    pt: 'pentest automático, só em sistema seu',
+  },
+  rtk: {
+    needs: [],
+    en: 'cuts 60-90% of tokens on dev commands',
+    pt: 'corta 60-90% dos tokens em comandos de dev',
+  },
+};
+
+/**
+ * Requirement badges for a CLI, in the chosen language. Adds the platform
+ * gate (Apple Silicon, macOS) from the registry entry.
+ * @param {{id: string, platform?: string|string[]}} cli - Resolved CLI entry
+ * @param {'en'|'pt'} lang - Display language
+ * @returns {string[]} Short badge texts; empty means free and light
+ */
+function cliBadges(cli, lang) {
+  const info = CLI_LABELS[cli.id];
+  const badges = ((info && info.needs) || []).map((need) => NEED_LABELS[need][lang]);
+  const platforms = [cli.platform || []].flat();
+  if (platforms.includes('darwin-arm64')) badges.push('Apple Silicon');
+  else if (platforms.length === 1 && platforms[0] === 'darwin') badges.push('macOS');
+  return badges;
+}
+
+/**
+ * One-line description for a CLI, falling back to the registry id.
+ * @param {string} id - CLI id
+ * @param {'en'|'pt'} lang - Display language
+ * @returns {string}
+ */
+function cliDescription(id, lang) {
+  const info = CLI_LABELS[id];
+  return info ? info[lang] : '';
+}
+
+module.exports = { AREA_LABELS, CLI_LABELS, NEED_LABELS, cliBadges, cliDescription };

package/tools/installer/guided/messages.js

@@ -0,0 +1,132 @@
+/**
+ * Guided installer text, English (default) and Portuguese. Every string the
+ * guided path prints comes from here, so adding a language is one more
+ * block and nothing else.
+ */
+
+const MESSAGES = {
+  en: {
+    tagline: 'Your AI team: one agent for each area.',
+    whatHappens: 'What happens next',
+    duration: '~2 min',
+    stepNames: ['Where to install', "What you'll use it for", 'Which AI tool you use', 'Your name'],
+    languageHint: 'Language: English. Portuguese is available on the next screen.',
+    languageQuestion: 'Language · Idioma',
+    step: 'Step {n} of {total}',
+    dirQuestion: 'Where should Wizz Method be installed?',
+    dirCreate: 'This folder does not exist yet. Create {dir}?',
+    dirRetry: 'Okay, pick another folder.',
+    existingFound: 'Wizz Method is already installed here. Choose what to do.',
+    profileQuestion: 'What will you use it for?',
+    toolQuestion: 'Which AI tool do you use?',
+    toolDetected: 'found on this machine',
+    toolOther: 'Other tools…',
+    toolOtherHelp: '45 more: Windsurf, Cline, Gemini CLI, Kiro…',
+    toolOtherQuestion: 'Pick your tools (type to filter)',
+    toolNone: 'Pick at least one tool so the agents have somewhere to live.',
+    nameQuestion: 'What should the agents call you?',
+    modulesQuestion: 'Which modules?',
+    fromBmad: 'from BMAD',
+    areasQuestion: 'Which areas?',
+    mcpsQuestion: 'Which MCP servers? (they give the agents live access to a service)',
+    reviewTitle: "You're getting",
+    reviewAgents: '{n} agents',
+    reviewSkills: '{n} skills',
+    reviewSkillsHint: 'list them anytime: wizz catalog',
+    reviewMemory: 'Memory',
+    reviewMemoryHint: 'decisions saved per project',
+    reviewTools: 'AI tool',
+    reviewLowticket: 'Low Ticket playbook',
+    optionalTitle: 'Optional tools (tick to install now, or install later)',
+    free: 'free',
+    alreadyInstalled: 'already installed: {list}',
+    reviewAction: 'Ready?',
+    actionInstall: 'Install',
+    actionProfile: 'Change profile',
+    actionCustomize: 'Customize',
+    nextSteps: 'Next steps',
+    tryAsking: 'Try asking your agent:',
+    skippedTools: 'Tools left for later (install commands are listed above):',
+    docs: 'Docs',
+    help: 'Help',
+    catalogLegend: '✓ installed   ⌘ command-line tool   ◇ MCP server',
+  },
+  pt: {
+    tagline: 'Seu time de IA: um agente para cada área.',
+    whatHappens: 'O que vai acontecer',
+    duration: '~2 min',
+    stepNames: ['Onde instalar', 'Pra que você vai usar', 'Qual IA você usa', 'Seu nome'],
+    languageHint: 'Idioma: inglês. Português está disponível na próxima tela.',
+    languageQuestion: 'Language · Idioma',
+    step: 'Passo {n} de {total}',
+    dirQuestion: 'Onde instalar o Wizz Method?',
+    dirCreate: 'Essa pasta ainda não existe. Criar {dir}?',
+    dirRetry: 'Tudo bem, escolha outra pasta.',
+    existingFound: 'O Wizz Method já está instalado aqui. Escolha o que fazer.',
+    profileQuestion: 'Pra que você vai usar?',
+    toolQuestion: 'Qual IA você usa?',
+    toolDetected: 'encontrada nesta máquina',
+    toolOther: 'Outras ferramentas…',
+    toolOtherHelp: 'mais 45: Windsurf, Cline, Gemini CLI, Kiro…',
+    toolOtherQuestion: 'Escolha suas ferramentas (digite pra filtrar)',
+    toolNone: 'Escolha pelo menos uma ferramenta, é nela que os agentes vão morar.',
+    nameQuestion: 'Como os agentes devem te chamar?',
+    modulesQuestion: 'Quais módulos?',
+    fromBmad: 'do BMAD',
+    areasQuestion: 'Quais áreas?',
+    mcpsQuestion: 'Quais servidores MCP? (dão aos agentes acesso direto a um serviço)',
+    reviewTitle: 'O que vai entrar',
+    reviewAgents: '{n} agentes',
+    reviewSkills: '{n} skills',
+    reviewSkillsHint: 'veja a lista quando quiser: wizz catalog',
+    reviewMemory: 'Memória',
+    reviewMemoryHint: 'decisões salvas por projeto',
+    reviewTools: 'IA',
+    reviewLowticket: 'Playbook Low Ticket',
+    optionalTitle: 'Ferramentas opcionais (marque pra instalar agora, ou instale depois)',
+    free: 'grátis',
+    alreadyInstalled: 'já instaladas: {list}',
+    reviewAction: 'Tudo certo?',
+    actionInstall: 'Instalar',
+    actionProfile: 'Trocar perfil',
+    actionCustomize: 'Personalizar',
+    nextSteps: 'Próximos passos',
+    tryAsking: 'Experimente pedir ao seu agente:',
+    skippedTools: 'Ferramentas que ficaram pra depois (os comandos estão logo acima):',
+    docs: 'Docs',
+    help: 'Ajuda',
+    catalogLegend: '✓ instalada   ⌘ ferramenta de terminal   ◇ servidor MCP',
+  },
+};
+
+const LANGUAGES = [
+  { value: 'en', label: 'English', communication: 'English' },
+  { value: 'pt', label: 'Português', communication: 'Português (Brasil)' },
+];
+
+/**
+ * Normalize a --lang value to a supported code.
+ * @param {string|undefined} raw - e.g. "pt", "pt-BR", "en"
+ * @returns {'en'|'pt'|null} null when absent or unknown
+ */
+function normalizeLang(raw) {
+  if (!raw) return null;
+  const code = String(raw).toLowerCase().slice(0, 2);
+  return MESSAGES[code] ? code : null;
+}
+
+/**
+ * Translate a key, filling {placeholders}.
+ * @param {'en'|'pt'} lang - Display language
+ * @param {string} key - Message key
+ * @param {Object} [vars] - Placeholder values
+ * @returns {string}
+ */
+function t(lang, key, vars = {}) {
+  const table = MESSAGES[lang] || MESSAGES.en;
+  const value = key in table ? table[key] : MESSAGES.en[key];
+  if (typeof value !== 'string') return value;
+  return value.replaceAll(/\{(\w+)\}/g, (match, name) => (name in vars ? String(vars[name]) : match));
+}
+
+module.exports = { MESSAGES, LANGUAGES, normalizeLang, t };

package/tools/installer/guided/outro.js

@@ -0,0 +1,32 @@
+const prompts = require('../prompts');
+const { paint, BRAND_ORANGE } = require('../banner');
+const { t } = require('./messages');
+const { getProfile } = require('./profiles');
+
+/**
+ * Closing screen of the guided install: three things to ask the agent
+ * right now (picked by profile) and the names of the tools the user left
+ * for later.
+ * @param {Object} config - The config returned by runGuidedInstall
+ */
+async function showGuidedOutro(config) {
+  const { lang, profile } = config.guided;
+  const color = await prompts.getColor();
+  const colorOn = color.isColorSupported !== false;
+  const lines = [color.bold(t(lang, 'tryAsking'))];
+  for (const ask of getProfile(profile).tryAsking[lang]) {
+    lines.push(`  ${paint(BRAND_ORANGE, '›', colorOn)} ${ask}`);
+  }
+
+  // Only the names here: the full install commands were printed above by the
+  // installer, and repeating long clone commands buries the next steps.
+  const skipped = ((config.cliPlan && config.cliPlan.toRecommend) || []).map((cli) => cli.id);
+  if (skipped.length > 0) {
+    lines.push('', color.bold(t(lang, 'skippedTools')), `  ${color.dim(skipped.join(' · '))}`);
+  }
+
+  lines.push('', color.dim(`${t(lang, 'docs')}  method.wizzcomms.com`), color.dim(`${t(lang, 'help')}  wizz doctor · wizz catalog`));
+  await prompts.note(lines.join('\n'), t(lang, 'nextSteps'));
+}
+
+module.exports = { showGuidedOutro };

package/tools/installer/guided/profiles.js

@@ -0,0 +1,95 @@
+/**
+ * Install profiles for the guided installer. A profile answers "what will
+ * you use it for?" and decides modules and skill areas in one choice, so the
+ * normal path never shows the module or area lists.
+ *
+ * `areas: null` means every area (the installSkillsLib sentinel is `[]`).
+ */
+
+const BASE_MODULES = ['wizz', 'bmm'];
+
+const PROFILES = [
+  {
+    id: 'everything',
+    modules: BASE_MODULES,
+    areas: null,
+    en: { name: 'Everything', help: 'product, code, design, content and marketing' },
+    pt: { name: 'Completo', help: 'produto, código, design, conteúdo e marketing' },
+    tryAsking: {
+      en: ['plan a new feature from the brief to the first story', 'write a LinkedIn post about our launch', 'audit the SEO of my site'],
+      pt: [
+        'planeja uma feature nova, do brief à primeira story',
+        'escreve um post pro LinkedIn sobre o lançamento',
+        'faz uma auditoria de SEO do meu site',
+      ],
+    },
+  },
+  {
+    id: 'marketing',
+    modules: BASE_MODULES,
+    areas: ['designer', 'copy', 'seo', 'growth', 'social', 'ads', 'analyst', 'memoria'],
+    en: { name: 'Content & marketing', help: 'copy, social, video, ads and SEO' },
+    pt: { name: 'Conteúdo e marketing', help: 'copy, social, vídeo, anúncios e SEO' },
+    tryAsking: {
+      en: ['write a LinkedIn post about our launch', "plan next week's content calendar", 'write 3 headline variations for a Meta ad'],
+      pt: [
+        'escreve um post pro LinkedIn sobre o lançamento',
+        'monta o calendário de conteúdo da semana',
+        'cria 3 variações de headline pra um anúncio na Meta',
+      ],
+    },
+  },
+  {
+    id: 'product',
+    modules: BASE_MODULES,
+    areas: ['designer', 'architect', 'qa', 'analyst', 'dev', 'pm', 'tech-writer', 'ux-designer', 'memoria'],
+    en: { name: 'Product & code', help: 'planning, architecture, development and tests' },
+    pt: { name: 'Produto e código', help: 'planejamento, arquitetura, desenvolvimento e testes' },
+    tryAsking: {
+      en: ['write the PRD for a new feature', 'fix this bug and add a test for it', 'review the code in my last commit'],
+      pt: ['escreve o PRD de uma feature nova', 'corrige esse bug e cria um teste pra ele', 'revisa o código do meu último commit'],
+    },
+  },
+  {
+    id: 'custom',
+    modules: null,
+    areas: null,
+    en: { name: 'Custom', help: 'pick modules, areas and tools one by one' },
+    pt: { name: 'Personalizar', help: 'escolher módulos, áreas e ferramentas um a um' },
+    tryAsking: {
+      en: ['what can you do in this project?', 'start a new project with me'],
+      pt: ['o que você sabe fazer neste projeto?', 'começa um projeto novo comigo'],
+    },
+  },
+];
+
+/**
+ * @param {string} id - Profile id
+ * @returns {Object|undefined}
+ */
+function getProfile(id) {
+  return PROFILES.find((profile) => profile.id === id);
+}
+
+/**
+ * What a set of areas brings in, read from the registry so the review screen
+ * never shows a number that drifted from the real catalog.
+ * @param {Object|null} registry - Parsed skills-registry.yaml
+ * @param {string[]|null} areas - Chosen areas; null or [] means all
+ * @returns {{areas: string[], agents: number, skills: number}}
+ */
+function summarizeAreas(registry, areas) {
+  const all = (registry && registry.areas) || {};
+  const chosen = !areas || areas.length === 0 ? Object.keys(all) : areas.filter((key) => all[key]);
+  const skillIds = new Set();
+  const agents = new Set();
+  for (const key of chosen) {
+    const area = all[key];
+    if (area.agent) agents.add(area.agent);
+    for (const skill of area.skills || []) skillIds.add(skill.id);
+  }
+  for (const skill of (registry && registry.utility) || []) skillIds.add(skill.id);
+  return { areas: chosen, agents: agents.size, skills: skillIds.size };
+}
+
+module.exports = { PROFILES, getProfile, summarizeAreas };