wizz-method 2.18.0 → 2.19.0

package/tools/installer/core/hooks-smoke.js

@@ -0,0 +1,134 @@
+// hooks-smoke.js — o `wizz doctor` EXECUTA cada hook instalado em
+// `_wizz/hooks/` com um payload mínimo válido (por evento) e reporta o que
+// quebrou. Existe porque os hooks são fail-open: uma cópia parcial (lib
+// faltando, arquivo corrompido) faz a feature sumir em silêncio, e checar só
+// "o arquivo existe" não pega isso.
+//
+// Roda com WIZZ_DEBUG=1, então os erros que o hook engole (ver
+// tools/hooks/wizz-debug-lib.js) chegam em stderr e entram no relatório.
+// Nada é gravado: WIZZ_DEBUG_FILE aponta para o null device, WIZZ_TRACE fica
+// vazio e o payload do artifact-guard usa um arquivo que não existe.
+//
+// Rápido de propósito: ~40 ms por hook, timeout curto, sem rede.
+
+const os = require('node:os');
+const path = require('node:path');
+const { it } = require('../install-text');
+const { HOOK_DEFS } = require('./hooks-settings');
+
+const HOOK_TIMEOUT_MS = 4000;
+
+// Falha ao carregar o código do próprio hook = feature morta. É o caso que o
+// smoke existe para pegar, então vira error (o resto é warn).
+const LOAD_FAILURE_RE = /require |Cannot find module|MODULE_NOT_FOUND|SyntaxError/;
+
+/**
+ * Payload mínimo válido por hook (formato real que o Claude Code envia).
+ * @param {string} id - basename do hook
+ * @param {string} projectDir
+ * @returns {object}
+ */
+function probePayload(id, projectDir) {
+  const base = { cwd: projectDir };
+  switch (id) {
+    case 'session-rules.js': {
+      return { ...base, hook_event_name: 'SessionStart', source: 'startup' };
+    }
+    case 'wizz-router-enforce.js': {
+      return { ...base, hook_event_name: 'UserPromptSubmit', prompt: 'implementa a feature de login com testes e validação' };
+    }
+    case 'security-defensive-context.js': {
+      return { ...base, hook_event_name: 'PreToolUse', tool_name: 'Skill', tool_input: { skill: 'security-review' } };
+    }
+    case 'rtk-rewrite.sh':
+    case 'rtk-rewrite.js': {
+      return { ...base, hook_event_name: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'echo wizz-doctor' } };
+    }
+    case 'wizz-artifact-guard.js': {
+      return {
+        ...base,
+        hook_event_name: 'PostToolUse',
+        tool_name: 'Write',
+        tool_input: { file_path: path.join(projectDir, '__wizz-doctor-probe__.txt'), content: '' },
+      };
+    }
+    case 'wizz-decision-trace.js':
+    case 'wizz-close-reminder.js': {
+      return { ...base, hook_event_name: 'Stop', stop_hook_active: false };
+    }
+    default: {
+      return base;
+    }
+  }
+}
+
+/**
+ * Execução real de um hook. Injetável em `deps.runHookProcess` nos testes.
+ * @param {{file: string, kind: 'node'|'shell', payload: object, cwd: string}} args
+ * @returns {{status: number|null, stderr: string, error: string|null}}
+ */
+function defaultRunHookProcess({ file, kind, payload, cwd }) {
+  const { spawnSync } = require('node:child_process');
+  const [cmd, args] = kind === 'shell' ? ['bash', [file]] : [process.execPath, [file]];
+  const res = spawnSync(cmd, args, {
+    cwd,
+    input: JSON.stringify(payload),
+    encoding: 'utf8',
+    timeout: HOOK_TIMEOUT_MS,
+    env: { ...process.env, WIZZ_DEBUG: '1', WIZZ_DEBUG_FILE: os.devNull, WIZZ_TRACE: '', CLAUDE_PROJECT_DIR: cwd },
+  });
+  return { status: res.status, stderr: res.stderr || '', error: res.error ? res.error.message : null };
+}
+
+function debugLines(stderr) {
+  return String(stderr)
+    .split('\n')
+    .filter((line) => line.startsWith('[wizz-debug]'));
+}
+
+/**
+ * Executa cada hook instalado e classifica o resultado.
+ * @param {object} deps
+ * @param {string} deps.wizzDir
+ * @param {string} deps.projectDir
+ * @param {(p: string) => boolean} deps.fileExists
+ * @param {boolean} deps.rtkOnPath - sem rtk no PATH o rtk-rewrite.sh é pulado
+ * @param {Function} [deps.runHookProcess]
+ * @returns {{check: 'hooks-run', status: 'ok'|'warn'|'error', detail: string}}
+ */
+function checkHooksRun({ wizzDir, projectDir, fileExists, rtkOnPath, runHookProcess = defaultRunHookProcess }) {
+  const hooksDir = path.join(wizzDir, 'hooks');
+  const errors = [];
+  const warnings = [];
+  let ran = 0;
+
+  for (const def of HOOK_DEFS) {
+    if (def.requires === 'rtk' && !rtkOnPath) continue;
+    const file = path.join(hooksDir, def.id);
+    if (!fileExists(file)) continue; // ausência é do check `hooks`
+    ran++;
+    const res = runHookProcess({ file, kind: def.kind, payload: probePayload(def.id, projectDir), cwd: projectDir });
+    const lines = debugLines(res.stderr);
+    if (res.error || res.status !== 0) {
+      const why = res.error || `exit ${res.status}`;
+      const tail = String(res.stderr).trim().split('\n').slice(-2).join(' | ');
+      errors.push(it('hrBroke', { id: def.id, why, tail: tail ? `: ${tail}` : '' }));
+    } else if (lines.some((l) => LOAD_FAILURE_RE.test(l))) {
+      errors.push(it('hrNoLibs', { id: def.id, line: lines.find((l) => LOAD_FAILURE_RE.test(l)) }));
+    } else if (lines.length > 0) {
+      warnings.push(it('hrSwallowed', { id: def.id, line: lines[0].replace('[wizz-debug] ', '') }));
+    }
+  }
+
+  if (errors.length > 0) {
+    return {
+      check: 'hooks-run',
+      status: 'error',
+      detail: `${errors.join('\n')}${warnings.length > 0 ? `\n${warnings.join('\n')}` : ''}\n${it('hrPartialCopy')}`,
+    };
+  }
+  if (warnings.length > 0) return { check: 'hooks-run', status: 'warn', detail: warnings.join('\n') };
+  return { check: 'hooks-run', status: 'ok', detail: it('hrOk', { n: ran }) };
+}
+
+module.exports = { checkHooksRun, probePayload, defaultRunHookProcess, HOOK_TIMEOUT_MS };

package/tools/installer/core/installer.js

@@ -1,3 +1,4 @@
+const { it } = require('../install-text');
 const os = require('node:os');
 const path = require('node:path');
 const fs = require('../fs-native');
@@ -16,7 +17,7 @@ const { WIZZ_FOLDER_NAME } = require('../ide/shared/path-utils');
 const { InstallPaths } = require('./install-paths');
 const { ExternalModuleManager } = require('../modules/external-manager');
 const { resolveModuleVersion } = require('../modules/version-resolver');
-const { buildHookEntries, filterHooksRegisteredGlobally, mergeHooksIntoSettings } = require('./hooks-settings');
+const { buildHookEntries, filterHooksRegisteredGlobally, mergeHooksIntoSettings, removeHooksFromSettings } = require('./hooks-settings');
 
 const { ExistingInstall } = require('./existing-install');
 const { warnPreNativeSkillsLegacy } = require('./legacy-warnings');
@@ -426,7 +427,7 @@ class Installer {
             addResult('Resolved customizations', 'ok', `${resolvedCount} snapshot(s) → _wizz/_resolved/`);
           }
         } catch (error) {
-          await prompts.log.warn(`Falha ao gerar _wizz/_resolved/ (fail-open): ${error.message}`);
+          await prompts.log.warn(it('resolvedFail', { error: error.message }));
           addResult('Resolved customizations', 'warn', error.message);
         }
 
@@ -454,7 +455,7 @@ class Installer {
               await prompts.log.warn(`Skills no registry sem pasta em skills-lib (ignoradas): ${result.skipped.join(', ')}`);
             }
           } catch (error) {
-            await prompts.log.warn(`Falha ao instalar skills globais: ${error.message}`);
+            await prompts.log.warn(it('globalSkillsFail', { error: error.message }));
             addResult('Global skills', 'warn', error.message);
           }
 
@@ -480,12 +481,10 @@ class Installer {
               // network-heavy install/post_install steps.
               let { ready: mcpsReady, failed: mcpsFailed } = await prepareMcps({ mcps: toWrite });
               for (const f of mcpsFailed) {
-                await prompts.log.warn(
-                  `MCP ${f.id} não pôde ser preparado (${f.error}). Config NÃO escrita para evitar ENOENT — instale manualmente e adicione depois com \`claude mcp add\`.`,
-                );
+                await prompts.log.warn(it('mcpPrepareFail', { id: f.id, error: f.error }));
               }
               if (mcpsFailed.length > 0) {
-                addResult('MCP servers', 'warn', `falharam: ${mcpsFailed.map((f) => f.id).join(', ')}`);
+                addResult('MCP servers', 'warn', it('failedList', { list: mcpsFailed.map((f) => f.id).join(', ') }));
               }
 
               // Env var assistance (3.3, design em _audit parte 3 seção E):
@@ -521,14 +520,12 @@ class Installer {
                   const missingIds = new Set(missingEnv.map((m) => m.id));
                   mcpsReady = mcpsReady.filter((m) => !missingIds.has(m.id));
                   for (const m of missingEnv) {
-                    await prompts.log.warn(
-                      `MCP ${m.id} não gravado: faltou ${m.missing.join(', ')}. Rode o installer de novo quando tiver a chave, ou adicione com \`claude mcp add\`.`,
-                    );
+                    await prompts.log.warn(it('mcpNotWritten', { id: m.id, missing: m.missing.join(', ') }));
                   }
-                  addResult('MCP servers', 'warn', `não gravados por falta de env var: ${missingEnv.map((m) => m.id).join(', ')}`);
+                  addResult('MCP servers', 'warn', it('mcpMissingEnv', { list: missingEnv.map((m) => m.id).join(', ') }));
                 }
               } catch (error) {
-                await prompts.log.warn(`Falha ao configurar env vars dos MCPs: ${error.message}`);
+                await prompts.log.warn(it('mcpEnvFail', { error: error.message }));
                 addResult('MCP env vars', 'warn', error.message);
               }
 
@@ -558,34 +555,30 @@ class Installer {
               }
               const pinUpdated = mcpResult.pinUpdated || [];
               if (pinUpdated.length > 0) {
-                await prompts.log.info(
-                  `MCPs com pin atualizado (bloco não havia sido customizado): ${pinUpdated.map((u) => u.id).join(', ')}`,
-                );
-                addResult('MCP servers', 'ok', `pin atualizado: ${pinUpdated.map((u) => u.id).join(', ')}`);
+                await prompts.log.info(it('mcpPinUpdated', { list: pinUpdated.map((u) => u.id).join(', ') }));
+                addResult('MCP servers', 'ok', it('mcpPinUpdatedShort', { list: pinUpdated.map((u) => u.id).join(', ') }));
               }
               const pinCustomized = mcpResult.pinCustomized || [];
               if (pinCustomized.length > 0) {
-                await prompts.log.warn(
-                  `Há atualização de pin disponível para ${pinCustomized.map((c) => c.id).join(', ')}, mas o bloco no .mcp.json foi customizado (diferente do que o installer escreveu) — mantido intacto. Atualize manualmente se quiser o pin novo.`,
-                );
+                await prompts.log.warn(it('mcpPinCustomized', { list: pinCustomized.map((c) => c.id).join(', ') }));
               }
               if (mcpResult.skipped.length > 0) {
-                await prompts.log.info(`MCPs já presentes e atualizados no .mcp.json (mantidos): ${mcpResult.skipped.join(', ')}`);
+                await prompts.log.info(it('mcpKept', { list: mcpResult.skipped.join(', ') }));
               }
             }
             const toRecommend = mcpPlan.toRecommend || [];
             if (toRecommend.length > 0) {
               const lines = toRecommend.map((m) => `  ${renderAddCommand(m)}`).join('\n');
-              await prompts.log.info(`MCPs recomendados (rode quando quiser):\n${lines}`);
+              await prompts.log.info(it('mcpRecommend', { lines }));
             }
             // Remind only when a written server expects secrets the user must fill.
             const needsSecrets = toWrite.filter((m) => m.server && m.server.env && Object.keys(m.server.env).length > 0);
             if (needsSecrets.length > 0) {
               const vars = [...new Set(needsSecrets.flatMap((m) => Object.values(m.server.env)))];
-              await prompts.log.warn(`Defina as variáveis de ambiente dos MCPs antes de usar: ${vars.join(', ')}`);
+              await prompts.log.warn(it('mcpDefineEnv', { list: vars.join(', ') }));
             }
           } catch (error) {
-            await prompts.log.warn(`Falha ao configurar MCPs: ${error.message}`);
+            await prompts.log.warn(it('mcpFail', { error: error.message }));
             addResult('MCP servers', 'warn', error.message);
           }
 
@@ -599,37 +592,41 @@ class Installer {
           try {
             const alreadyInstalled = cliPlan.alreadyInstalled || [];
             if (alreadyInstalled.length > 0) {
-              await prompts.log.info(`CLIs já instalados (mantidos): ${alreadyInstalled.map((c) => c.id).join(', ')}`);
+              await prompts.log.info(it('cliKept', { list: alreadyInstalled.map((c) => c.id).join(', ') }));
             }
             const toInstall = cliPlan.toInstall || [];
             if (toInstall.length > 0) {
               message('Installing CLIs...');
               const cliResult = await installClis({ clis: toInstall });
               if (cliResult.installed.length > 0) {
-                addResult('CLIs', 'ok', `instalados: ${cliResult.installed.join(', ')}`);
+                addResult('CLIs', 'ok', it('installedList', { list: cliResult.installed.join(', ') }));
               }
               for (const f of cliResult.failed) {
                 await prompts.log.warn(
-                  `Falha ao instalar CLI ${f.id}: ${f.error}. Rode manualmente: ${renderInstallCommand(toInstall.find((c) => c.id === f.id) || {})}`,
+                  it('cliInstallFail', {
+                    id: f.id,
+                    error: f.error,
+                    command: renderInstallCommand(toInstall.find((c) => c.id === f.id) || {}),
+                  }),
                 );
               }
               if (cliResult.failed.length > 0) {
-                addResult('CLIs', 'warn', `falharam: ${cliResult.failed.map((f) => f.id).join(', ')}`);
+                addResult('CLIs', 'warn', it('failedList', { list: cliResult.failed.map((f) => f.id).join(', ') }));
               }
               // M14: verify failure never aborts (CLIs are opt-in) — just a
               // clear warning that the tool cloned/installed but a runtime
               // dependency might still be missing.
               for (const w of cliResult.warnings || []) {
-                await prompts.log.warn(`CLI ${w.id} instalado, mas ${w.warning}`);
+                await prompts.log.warn(it('cliInstalledBut', { id: w.id, warning: w.warning }));
               }
             }
             const toRecommend = cliPlan.toRecommend || [];
             if (toRecommend.length > 0) {
               const lines = toRecommend.map((c) => `  ${renderInstallCommand(c)}`).join('\n');
-              await prompts.log.info(`CLIs recomendados (rode quando quiser):\n${lines}`);
+              await prompts.log.info(it('cliRecommend', { lines }));
             }
           } catch (error) {
-            await prompts.log.warn(`Falha ao configurar CLIs: ${error.message}`);
+            await prompts.log.warn(it('cliFail', { error: error.message }));
             addResult('CLIs', 'warn', error.message);
           }
 
@@ -654,7 +651,7 @@ class Installer {
               addResult('Skill deps cache', 'ok', 'skill-deps-cache.json');
             }
           } catch (error) {
-            await prompts.log.warn(`Falha ao gravar cache de dependências: ${error.message}`);
+            await prompts.log.warn(it('depsCacheFail', { error: error.message }));
             addResult('Skill deps cache', 'warn', error.message);
           }
         } else if (config.isQuickUpdate() && (config.modules || []).includes('bmm')) {
@@ -662,9 +659,7 @@ class Installer {
           // preserves settings and skips provisioning entirely, so say it
           // explicitly instead of leaving the user to notice by absence
           // (see project memory: "atualizei e não veio skill").
-          await prompts.log.info(
-            'Quick Update: skills globais, MCPs e CLIs não foram alterados. Rode install e escolha "Modify Wizz Installation" para instalar itens novos.',
-          );
+          await prompts.log.info(it('quickUpdateSkipped'));
         }
 
         // RT-C1 (item 3): registra os hooks copiados acima em
@@ -688,19 +683,15 @@ class Installer {
           const { settings: globalSettings } = await this._readSettingsJson(this._globalSettingsFile());
           const { entries: hookEntries, skipped: skippedGlobalHooks } = filterHooksRegisteredGlobally(allHookEntries, globalSettings);
           if (skippedGlobalHooks.length > 0) {
-            await prompts.log.info(
-              `Hook(s) já registrados no settings.json global (~/.claude/settings.json), pulando no projeto para não rodar 2x: ${skippedGlobalHooks.join(', ')}.`,
-            );
+            await prompts.log.info(it('hooksGlobalSkipped', { list: skippedGlobalHooks.join(', ') }));
           }
 
           if (hookEntries.length > 0) {
             const settingsFile = path.join(paths.projectRoot, '.claude', 'settings.json');
             const { settings: existingSettings, invalidJson } = await this._readSettingsJson(settingsFile);
             if (invalidJson) {
-              await prompts.log.warn(
-                `${settingsFile} existe mas não é JSON válido — hooks copiados para _wizz/hooks/, mas NÃO registrados em settings.json. Corrija o arquivo e rode o install de novo.`,
-              );
-              addResult('Hooks settings', 'warn', 'settings.json inválido, hooks não registrados');
+              await prompts.log.warn(it('hooksSettingsInvalid', { file: settingsFile }));
+              addResult('Hooks settings', 'warn', it('hooksInvalidSettings'));
             } else {
               const newSettings = mergeHooksIntoSettings(existingSettings, hookEntries);
               pendingHooksSettingsWrite = {
@@ -726,14 +717,12 @@ class Installer {
               `0 hook(s) → .claude/settings.json (${skippedGlobalHooks.length} pulado(s) por já estar no global)`,
             );
           }
-          if (!rtkOnPath && installedHookFiles.includes('rtk-rewrite.sh')) {
-            addResult('Hooks settings', 'warn', 'rtk não encontrado no PATH: rtk-rewrite.sh copiado mas não registrado (opcional)');
-            await prompts.log.info(
-              'rtk não encontrado no PATH: rtk-rewrite.sh foi copiado para _wizz/hooks/ mas NÃO registrado em settings.json (rtk é opcional). Instale rtk e rode o install de novo para ativá-lo.',
-            );
+          if (!rtkOnPath && installedHookFiles.includes(require('./hooks-settings').RTK_HOOK_ID)) {
+            addResult('Hooks settings', 'warn', it('hooksRtkMissing'));
+            await prompts.log.info(it('hooksRtkMissingLong'));
           }
         } catch (error) {
-          await prompts.log.warn(`Falha ao registrar hooks em .claude/settings.json: ${error.message}`);
+          await prompts.log.warn(it('hooksFail', { error: error.message }));
           addResult('Hooks settings', 'warn', error.message);
         }
 
@@ -845,7 +834,7 @@ class Installer {
             await prompts.log.warn(`_resolved/_config.json: ${warning}`);
           }
         } catch (error) {
-          await prompts.log.warn(`Falha ao gerar _wizz/_resolved/_config.json (fail-open): ${error.message}`);
+          await prompts.log.warn(it('resolvedConfigFail', { error: error.message }));
         }
 
         message('Generating help catalog...');
@@ -1244,12 +1233,10 @@ class Installer {
       }
       const totalLegacy = results.reduce((n, r) => n + r.findings.length, 0);
       if (totalLegacy > 0) {
-        await prompts.log.warn(
-          `${totalLegacy} regra(s) antiga(s) no CLAUDE.md/AGENTS.md (GSD, superpowers, BMAD puro ou modelo aposentado). O bloco Wizz no topo tem prioridade, mas vale limpar: rode wizz doctor para ver as linhas.`,
-        );
+        await prompts.log.warn(it('legacyRules', { n: totalLegacy }));
       }
     } catch (error) {
-      await prompts.log.warn(`Falha ao gravar o bloco Wizz no CLAUDE.md/AGENTS.md: ${error.message}`);
+      await prompts.log.warn(it('instructionsFail', { error: error.message }));
       addResult('Project instructions', 'warn', error.message);
     }
   }
@@ -1693,12 +1680,34 @@ class Installer {
   async uninstallModules(projectDir) {
     const { wizzDir } = await this.findWizzDir(projectDir);
     if (await fs.pathExists(wizzDir)) {
+      await this._unregisterHooks(projectDir);
       await fs.remove(wizzDir);
       return true;
     }
     return false;
   }
 
+  /**
+   * Tira de .claude/settings.json os hooks que o install registrou (apontam para
+   * _wizz/hooks/, que o uninstall apaga). Hook de terceiro e demais chaves ficam;
+   * settings.json inválido não é tocado; arquivo que sobraria vazio é removido.
+   * @param {string} projectDir - Project directory
+   * @returns {Promise<number>} Quantos hooks foram desregistrados
+   */
+  async _unregisterHooks(projectDir) {
+    const file = path.join(projectDir, '.claude', 'settings.json');
+    const { settings, invalidJson } = await this._readSettingsJson(file);
+    if (invalidJson) return 0;
+    const { settings: cleaned, removed } = removeHooksFromSettings(settings);
+    if (removed === 0) return 0;
+    if (Object.keys(cleaned).length === 0) {
+      await fs.remove(file);
+    } else {
+      await this._writeSettingsJson(file, cleaned);
+    }
+    return removed;
+  }
+
   /**
    * Get installation status
    */

package/tools/installer/core/quick-update.js

@@ -8,6 +8,7 @@
  * `externalModuleManager`, `manifest`, `install`) instead of inheriting from
  * it, so it can be tested/reasoned about independently.
  */
+const { it } = require('../install-text');
 const path = require('node:path');
 const fs = require('../fs-native');
 const { OfficialModules } = require('../modules/official-modules');
@@ -110,9 +111,7 @@ async function quickUpdate(installer, config) {
   // _installAndConfigure); that only happens on a fresh install or
   // Modify. Surfacing this before any work starts avoids the confusion of
   // "I updated and skills didn't come" (see project memory).
-  await prompts.log.info(
-    'Quick Update: atualiza os módulos já instalados com as configurações preservadas. Skills globais, MCPs e CLIs novos não são provisionados neste modo; rode install e escolha "Modify Wizz Installation" para isso.',
-  );
+  await prompts.log.info(it('quickUpdateScope'));
 
   // Detect existing installation
   const existingInstall = await ExistingInstall.detect(wizzDir);

package/tools/installer/install-text.js

@@ -0,0 +1,201 @@
+/**
+ * Text the install/update flow prints OUTSIDE the guided screens: the copy
+ * phase, the `--advanced` prompts and the final summary. The guided screens
+ * use guided/messages.js; both follow the language picked at the start
+ * (`--lang` or the guided question), so English mode never mixes in
+ * Portuguese (pendência de 2026-09-25).
+ *
+ * The language lives here as module state because these strings are printed
+ * deep inside core/installer.js and modules/*, far from where it is chosen.
+ * ui.promptInstall calls setInstallLang once; the default is English.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { normalizeLang } = require('./guided/messages');
+const COMMAND_TEXT = require('./command-text');
+
+const MESSAGES = {
+  en: {
+    resolvedFail: 'Could not generate _wizz/_resolved/ (fail-open): {error}',
+    resolvedConfigFail: 'Could not generate _wizz/_resolved/_config.json (fail-open): {error}',
+    globalSkillsFail: 'Could not install global skills: {error}',
+    failedList: 'failed: {list}',
+    installedList: 'installed: {list}',
+    mcpMissingEnv: 'not written, missing env var: {list}',
+    mcpEnvFail: 'Could not configure the MCP env vars: {error}',
+    mcpPinUpdated: 'MCPs with updated pin (block had not been customized): {list}',
+    mcpPinUpdatedShort: 'pin updated: {list}',
+    mcpPinCustomized:
+      'A pin update is available for {list}, but the block in .mcp.json was customized (differs from what the installer wrote), so it was left as is. Update it by hand if you want the new pin.',
+    mcpKept: 'MCPs already present and up to date in .mcp.json (kept): {list}',
+    mcpRecommend: 'Recommended MCPs (run whenever you want):\n{lines}',
+    mcpDefineEnv: 'Set the MCP environment variables before using them: {list}',
+    mcpFail: 'Could not configure MCPs: {error}',
+    cliKept: 'CLIs already installed (kept): {list}',
+    cliInstallFail: 'Could not install CLI {id}: {error}. Run it by hand: {command}',
+    cliInstalledBut: 'CLI {id} installed, but {warning}',
+    cliRecommend: 'Recommended CLIs (run whenever you want):\n{lines}',
+    cliFail: 'Could not configure CLIs: {error}',
+    depsCacheFail: 'Could not write the dependency cache: {error}',
+    hooksInvalidSettings: 'invalid settings.json, hooks not registered',
+    hooksRtkMissing: 'rtk not found on PATH: rtk-rewrite.sh copied but not registered (optional)',
+    hooksFail: 'Could not register hooks in .claude/settings.json: {error}',
+    instructionsFail: 'Could not write the Wizz block to CLAUDE.md/AGENTS.md: {error}',
+    mcpPrepareFail:
+      'MCP {id} could not be prepared ({error}). Config NOT written to avoid ENOENT: install it by hand and add it later with `claude mcp add`.',
+    mcpNotWritten:
+      'MCP {id} not written: missing {missing}. Run the installer again once you have the key, or add it with `claude mcp add`.',
+    quickUpdateScope:
+      'Quick Update: refreshes the modules already installed, keeping their settings. New global skills, MCPs and CLIs are not provisioned in this mode; run install and choose "Modify Wizz Installation" for that.',
+    quickUpdateSkipped:
+      'Quick Update: global skills, MCPs and CLIs were not changed. Run install and choose "Modify Wizz Installation" to install new items.',
+    hooksGlobalSkipped:
+      'Hook(s) already registered in the global settings.json (~/.claude/settings.json), skipped in the project so they do not run twice: {list}.',
+    hooksSettingsInvalid:
+      '{file} exists but is not valid JSON: hooks were copied to _wizz/hooks/ but NOT registered in settings.json. Fix the file and run install again.',
+    hooksRtkMissingLong:
+      'rtk not found on PATH: rtk-rewrite.sh was copied to _wizz/hooks/ but NOT registered in settings.json (rtk is optional). Install rtk and run install again to turn it on.',
+    legacyRules:
+      '{n} old rule(s) in CLAUDE.md/AGENTS.md (GSD, superpowers, plain BMAD or a retired model). The Wizz block at the top wins, but it is worth cleaning up: run wizz doctor to see the lines.',
+    unknownAreas: 'Unknown areas ignored: {list}',
+    areasQuestion: 'Which global skill areas should be installed? (empty = all)',
+    mcpGlobalSkipped: 'MCPs already configured in your global Claude (~/.claude.json), skipped: {list}',
+    mcpPluginSkipped: 'MCPs already covered by a Claude Code plugin (user scope), skipped: {list}',
+    mcpQuestion: 'Which MCPs should go into .mcp.json? (unticked ones become a command to run later)',
+    unknownClis: 'Unknown or already installed CLIs ignored: {list}',
+    cliQuestion: 'Which CLIs should be installed now? (unticked ones become a command to run later)',
+    traceQuestion: 'Turn on the routing meter? (local, writes only to ~/.claude/wizz-trace.jsonl on your machine, never leaves it)',
+    quickUpdateNoSkills:
+      'Skills/MCPs/CLIs were not changed (Quick Update). To provision them, run install and choose "Modify Wizz Installation".',
+    doneWarnings: 'Finished with {n} warning(s). See the summary above for details.',
+    doneErrors: 'Finished with {n} real failure(s). See the summary above for details.',
+    envValue: 'Value for {name}{usedBy} (Enter to skip):',
+    envUsedBy: ' (used by: {list})',
+    gitignoreAdded: ".claude/settings.local.json was added to the project's .gitignore (it holds API keys and must not go to git).",
+    notGitRepo: 'This folder is not a git repository: make sure .claude/settings.local.json (API keys) is never committed.',
+  },
+  pt: {
+    resolvedFail: 'Falha ao gerar _wizz/_resolved/ (fail-open): {error}',
+    resolvedConfigFail: 'Falha ao gerar _wizz/_resolved/_config.json (fail-open): {error}',
+    globalSkillsFail: 'Falha ao instalar skills globais: {error}',
+    failedList: 'falharam: {list}',
+    installedList: 'instalados: {list}',
+    mcpMissingEnv: 'não gravados por falta de env var: {list}',
+    mcpEnvFail: 'Falha ao configurar env vars dos MCPs: {error}',
+    mcpPinUpdated: 'MCPs com pin atualizado (bloco não havia sido customizado): {list}',
+    mcpPinUpdatedShort: 'pin atualizado: {list}',
+    mcpPinCustomized:
+      'Há atualização de pin disponível para {list}, mas o bloco no .mcp.json foi customizado (diferente do que o installer escreveu), então ficou intacto. Atualize manualmente se quiser o pin novo.',
+    mcpKept: 'MCPs já presentes e atualizados no .mcp.json (mantidos): {list}',
+    mcpRecommend: 'MCPs recomendados (rode quando quiser):\n{lines}',
+    mcpDefineEnv: 'Defina as variáveis de ambiente dos MCPs antes de usar: {list}',
+    mcpFail: 'Falha ao configurar MCPs: {error}',
+    cliKept: 'CLIs já instalados (mantidos): {list}',
+    cliInstallFail: 'Falha ao instalar CLI {id}: {error}. Rode manualmente: {command}',
+    cliInstalledBut: 'CLI {id} instalado, mas {warning}',
+    cliRecommend: 'CLIs recomendados (rode quando quiser):\n{lines}',
+    cliFail: 'Falha ao configurar CLIs: {error}',
+    depsCacheFail: 'Falha ao gravar cache de dependências: {error}',
+    hooksInvalidSettings: 'settings.json inválido, hooks não registrados',
+    hooksRtkMissing: 'rtk não encontrado no PATH: rtk-rewrite.sh copiado mas não registrado (opcional)',
+    hooksFail: 'Falha ao registrar hooks em .claude/settings.json: {error}',
+    instructionsFail: 'Falha ao gravar o bloco Wizz no CLAUDE.md/AGENTS.md: {error}',
+    mcpPrepareFail:
+      'MCP {id} não pôde ser preparado ({error}). Config NÃO escrita para evitar ENOENT: instale manualmente e adicione depois com `claude mcp add`.',
+    mcpNotWritten:
+      'MCP {id} não gravado: faltou {missing}. Rode o installer de novo quando tiver a chave, ou adicione com `claude mcp add`.',
+    quickUpdateScope:
+      'Quick Update: atualiza os módulos já instalados com as configurações preservadas. Skills globais, MCPs e CLIs novos não são provisionados neste modo; rode install e escolha "Modify Wizz Installation" para isso.',
+    quickUpdateSkipped:
+      'Quick Update: skills globais, MCPs e CLIs não foram alterados. Rode install e escolha "Modify Wizz Installation" para instalar itens novos.',
+    hooksGlobalSkipped:
+      'Hook(s) já registrados no settings.json global (~/.claude/settings.json), pulando no projeto para não rodar 2x: {list}.',
+    hooksSettingsInvalid:
+      '{file} existe mas não é JSON válido: hooks copiados para _wizz/hooks/, mas NÃO registrados em settings.json. Corrija o arquivo e rode o install de novo.',
+    hooksRtkMissingLong:
+      'rtk não encontrado no PATH: rtk-rewrite.sh foi copiado para _wizz/hooks/ mas NÃO registrado em settings.json (rtk é opcional). Instale rtk e rode o install de novo para ativá-lo.',
+    legacyRules:
+      '{n} regra(s) antiga(s) no CLAUDE.md/AGENTS.md (GSD, superpowers, BMAD puro ou modelo aposentado). O bloco Wizz no topo tem prioridade, mas vale limpar: rode wizz doctor para ver as linhas.',
+    unknownAreas: 'Áreas desconhecidas ignoradas: {list}',
+    areasQuestion: 'Quais áreas de skills globais instalar? (vazio = todas)',
+    mcpGlobalSkipped: 'MCPs já configurados no seu Claude global (~/.claude.json), pulados: {list}',
+    mcpPluginSkipped: 'MCPs já cobertos por plugin do Claude Code (user scope), pulados: {list}',
+    mcpQuestion: 'Quais MCPs configurar no .mcp.json? (não marcados viram comando pra rodar depois)',
+    unknownClis: 'CLIs desconhecidos/já instalados ignorados: {list}',
+    cliQuestion: 'Quais CLIs instalar agora? (não marcados viram comando pra rodar depois)',
+    traceQuestion: 'Quer ligar o medidor de roteamento? (local, grava só em ~/.claude/wizz-trace.jsonl na sua máquina, nunca sai daqui)',
+    quickUpdateNoSkills:
+      'Skills/MCPs/CLIs não foram alterados (Quick Update). Para provisioná-los, rode install e escolha "Modify Wizz Installation".',
+    doneWarnings: 'Concluído com {n} aviso(s). Veja o resumo acima para detalhes.',
+    doneErrors: 'Concluído com {n} falha(s) real(is). Veja o resumo acima para detalhes.',
+    envValue: 'Valor para {name}{usedBy} (Enter para pular):',
+    envUsedBy: ' (usada por: {list})',
+    gitignoreAdded: '.claude/settings.local.json foi adicionado ao .gitignore do projeto (guarda API keys, não deve ir pro git).',
+    notGitRepo: 'Este diretório não é um repositório git: garanta que .claude/settings.local.json (API keys) nunca seja versionado.',
+  },
+};
+
+// doctor, resolve e trace-report (command-text.js) entram na mesma tabela.
+Object.assign(MESSAGES.en, COMMAND_TEXT.en);
+Object.assign(MESSAGES.pt, COMMAND_TEXT.pt);
+
+let current = 'en';
+
+/**
+ * Set the language for the rest of the run.
+ * @param {string|undefined} raw - "en", "pt", "pt-BR"…; unknown keeps English
+ */
+function setInstallLang(raw) {
+  current = normalizeLang(raw) || 'en';
+}
+
+/**
+ * Language of an existing install, from `communication_language` in
+ * _wizz/core/config.yaml ("Portugues", "Português (Brasil)", "English"…), so
+ * `wizz update` without --lang keeps talking the language picked at install.
+ * @param {string} wizzDir
+ * @returns {'en'|'pt'|null} null when absent or unreadable
+ */
+function langOfInstall(wizzDir) {
+  try {
+    const text = fs.readFileSync(path.join(wizzDir, 'core', 'config.yaml'), 'utf8');
+    const match = text.match(/^communication_language:\s*["']?([^"'\n]+)/m);
+    if (!match) return null;
+    return /^portugu/i.test(match[1].trim()) ? 'pt' : 'en';
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Language for the commands that run on an existing install (doctor,
+ * resolve, trace-report): WIZZ_LANG wins, then `communication_language` of
+ * the install, then English. Sets it for the rest of the run.
+ * @param {string|null} wizzDir - _wizz/ of the project, or null
+ * @returns {'en'|'pt'}
+ */
+function useCommandLang(wizzDir) {
+  const fromEnv = normalizeLang(process.env.WIZZ_LANG);
+  setInstallLang(fromEnv || (wizzDir && langOfInstall(wizzDir)) || 'en');
+  return current;
+}
+
+function getInstallLang() {
+  return current;
+}
+
+/**
+ * Translate a key in the current language, filling {placeholders}.
+ * @param {string} key
+ * @param {Object} [vars]
+ * @returns {string}
+ */
+function it(key, vars = {}) {
+  const table = MESSAGES[current] || MESSAGES.en;
+  const value = key in table ? table[key] : MESSAGES.en[key];
+  if (typeof value !== 'string') throw new Error(`install-text: unknown key "${key}"`);
+  return value.replaceAll(/\{(\w+)\}/g, (match, name) => (name in vars ? String(vars[name]) : match));
+}
+
+module.exports = { MESSAGES, setInstallLang, getInstallLang, langOfInstall, useCommandLang, it };

package/tools/installer/modules/channel-plan.js

@@ -187,12 +187,12 @@ function orphanPinWarnings(channelOptions, selectedCodes) {
  * Warn when --pin / --next targets a bundled module (core, bmm). Those are
  * shipped inside the installer binary — there's no git clone to override, so
  * the flag has no effect. Users who actually want a prerelease core/bmm
- * should use `npx bmad-method@next install`.
+ * should use `npx wizz-method@next install`.
  */
 function bundledTargetWarnings(channelOptions, bundledCodes) {
   const warnings = [];
   const bundled = new Set(bundledCodes || []);
-  const hint = '(bundled module; use `npx bmad-method@next install` for a prerelease)';
+  const hint = '(bundled module; use `npx wizz-method@next install` for a prerelease)';
   for (const code of channelOptions?.pins?.keys() || []) {
     if (bundled.has(code)) {
       warnings.push(`--pin for '${code}' has no effect ${hint}.`);