wizz-method 2.11.2 → 2.13.0

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 };

package/tools/installer/guided/steps.js

@@ -0,0 +1,154 @@
+/**
+ * One function per guided screen. Each returns plain data; the order and the
+ * loop (change profile, customize) live in flow.js.
+ */
+const os = require('node:os');
+const fs = require('../fs-native');
+const prompts = require('../prompts');
+const { paint, BRAND_ORANGE } = require('../banner');
+const { t, LANGUAGES } = require('./messages');
+const { PROFILES } = require('./profiles');
+const { AREA_LABELS, cliBadges, cliDescription } = require('./labels');
+const { detectAiTools } = require('./detect-tools');
+
+const TOTAL_STEPS = 4;
+const OTHER_TOOLS = '__other__';
+
+async function stepHeader(lang, n) {
+  const color = await prompts.getColor();
+  const colorOn = color.isColorSupported !== false;
+  const track = Array.from({ length: TOTAL_STEPS }, (_, i) => (i < n ? '●' : '○')).join('───');
+  await prompts.log.message(`${paint(BRAND_ORANGE, track, colorOn)}  ${color.dim(t(lang, 'step', { n, total: TOTAL_STEPS }))}`);
+}
+
+async function askLanguage() {
+  return prompts.select({
+    message: t('en', 'languageQuestion'),
+    choices: LANGUAGES.map((l) => ({ name: l.label, value: l.value })),
+    default: 'en',
+  });
+}
+
+async function askDirectory(ui, lang) {
+  for (;;) {
+    const raw = await prompts.directory({
+      message: t(lang, 'dirQuestion'),
+      default: process.cwd(),
+      placeholder: process.cwd(),
+      validate: (input) => ui.validateDirectorySync(input),
+    });
+    const directory = raw && raw.trim() ? ui.expandUserPath(raw) : process.cwd();
+    if (await fs.pathExists(directory)) return directory;
+    const create = await prompts.confirm({ message: t(lang, 'dirCreate', { dir: directory }), default: true });
+    if (create) return directory;
+    await prompts.log.warn(t(lang, 'dirRetry'));
+  }
+}
+
+async function askProfile(lang, current) {
+  return prompts.select({
+    message: t(lang, 'profileQuestion'),
+    choices: PROFILES.map((p) => ({ name: p[lang].name, value: p.id, hint: p[lang].help })),
+    default: current || 'everything',
+  });
+}
+
+async function askAreas(lang, registry) {
+  const keys = Object.keys((registry && registry.areas) || {});
+  const selected = await prompts.multiselect({
+    message: t(lang, 'areasQuestion'),
+    options: keys.map((key) => {
+      const label = AREA_LABELS[key] ? AREA_LABELS[key][lang] : { name: key, help: '' };
+      return { label: label.name, value: key, hint: label.help };
+    }),
+    initialValues: keys,
+    required: true,
+  });
+  return selected.length === keys.length ? [] : selected;
+}
+
+async function askModules(lang, available) {
+  const selected = await prompts.multiselect({
+    message: t(lang, 'modulesQuestion'),
+    options: available.map((mod) => ({
+      label: mod.fromBmad ? `${mod.name} · ${t(lang, 'fromBmad')}` : mod.name,
+      value: mod.code,
+      hint: mod.description,
+    })),
+    initialValues: available.filter((mod) => mod.defaultSelected).map((mod) => mod.code),
+    required: true,
+  });
+  return selected;
+}
+
+async function askTools(lang, ideManager) {
+  const preferred = ideManager.getPreferredIdes();
+  const others = ideManager.getOtherIdes();
+  const detected = new Set(detectAiTools());
+  const initial = preferred.filter((ide) => detected.has(ide.value)).map((ide) => ide.value);
+  const picked = await prompts.multiselect({
+    message: t(lang, 'toolQuestion'),
+    options: [
+      ...preferred.map((ide) => ({
+        label: ide.name,
+        value: ide.value,
+        hint: detected.has(ide.value) ? t(lang, 'toolDetected') : undefined,
+      })),
+      { label: t(lang, 'toolOther'), value: OTHER_TOOLS, hint: t(lang, 'toolOtherHelp') },
+    ],
+    initialValues: initial.length > 0 ? initial : [preferred[0].value],
+    required: true,
+  });
+  const chosen = picked.filter((id) => id !== OTHER_TOOLS);
+  if (!picked.includes(OTHER_TOOLS)) return chosen;
+  const extra = await prompts.autocompleteMultiselect({
+    message: t(lang, 'toolOtherQuestion'),
+    options: others.map((ide) => ({ label: ide.name, value: ide.value })),
+    required: chosen.length === 0,
+    maxItems: 8,
+  });
+  return [...chosen, ...(extra || [])];
+}
+
+function defaultUserName() {
+  let name;
+  try {
+    name = os.userInfo().username;
+  } catch {
+    name = process.env.USER || process.env.USERNAME || 'User';
+  }
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+async function askName(lang) {
+  const fallback = defaultUserName();
+  const value = await prompts.text({ message: t(lang, 'nameQuestion'), default: fallback, placeholder: fallback });
+  return (value && String(value).trim()) || fallback;
+}
+
+/**
+ * Label and hint for a CLI in the optional-tools list: plain description,
+ * then requirement badges ("free" when there are none).
+ */
+function cliOption(cli, lang) {
+  const badges = cliBadges(cli, lang);
+  const needs = badges.length > 0 ? badges.join(' · ') : t(lang, 'free');
+  const description = cliDescription(cli.id, lang);
+  // Description in the label, not the hint: clack only shows a hint for the
+  // focused row, and the point here is comparing tools at a glance.
+  const label = description ? `${cli.id.padEnd(14)} ${description} · ${needs}` : `${cli.id.padEnd(14)} ${needs}`;
+  return { label, value: cli.id };
+}
+
+module.exports = {
+  stepHeader,
+  askLanguage,
+  askDirectory,
+  askProfile,
+  askAreas,
+  askModules,
+  askTools,
+  askName,
+  cliOption,
+  defaultUserName,
+};

package/tools/installer/install-messages.yaml

@@ -6,11 +6,11 @@
 startMessage: |
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  Método de agência orientado por IA, em PT-BR. Agentes por área, skills curadas e memória de projeto.
-  Escolha os módulos durante o setup para montar a instalação do seu jeito.
+  Full install: choices come from your flags or from the complete question list.
+  For the short guided install, run `npx wizz-method install` with no flags.
 
   📖 Docs:     https://method.wizzcomms.com/
-  ✉️  Suporte:  support@wizzcomms.com
+  ✉️  Support:  support@wizzcomms.com
 
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 

package/tools/installer/modules/external-manager.js

@@ -145,6 +145,10 @@ class ExternalModuleManager {
       marketplacePlugin: mod.marketplace_plugin === true || mod['marketplace-plugin'] === true || mod.marketplacePlugin === true,
       postInstallMessage: mod.post_install_message || mod['post-install-message'] || mod.postInstallMessage || null,
       builtIn: mod.built_in === true,
+      // Só aparece no modo avançado do instalador guiado (--advanced ou a
+      // lista completa de módulos); experimental ou de nicho demais pra
+      // quem instala pela primeira vez.
+      advancedOnly: mod.advanced_only === true,
       isExternal: mod.built_in !== true,
       // Códigos anteriores sob os quais este módulo foi registrado (ex.: `bmad-loop`
       // era `bauto`). Deixa um módulo renomeado continuar resolvendo instalações