wizz-method 1.0.2 → 1.1.0

package/tools/installer/project-root.js

@@ -4,21 +4,21 @@ const yaml = require('yaml');
 const fs = require('./fs-native');
 
 /**
- * Find the BMAD project root directory by looking for package.json
- * or specific BMAD markers
+ * Find the WIZZ project root directory by looking for package.json
+ * or specific WIZZ markers
  */
 function findProjectRoot(startPath = __dirname) {
   let currentPath = path.resolve(startPath);
 
-  // Keep going up until we find package.json with bmad-method
+  // Keep going up until we find package.json with wizz-method
   while (currentPath !== path.dirname(currentPath)) {
     const packagePath = path.join(currentPath, 'package.json');
 
     if (fs.existsSync(packagePath)) {
       try {
         const pkg = fs.readJsonSync(packagePath);
-        // Check if this is the BMAD project
-        if (pkg.name === 'bmad-method' || fs.existsSync(path.join(currentPath, 'src', 'core-skills'))) {
+        // Check if this is the WIZZ project
+        if (pkg.name === 'wizz-method' || fs.existsSync(path.join(currentPath, 'src', 'core-skills'))) {
           return currentPath;
         }
       } catch {
@@ -77,7 +77,7 @@ function getModulePath(moduleName, ...segments) {
  * by ExternalModuleManager during install and are not copied into <src>/modules/.
  */
 function getExternalModuleCachePath(moduleName, ...segments) {
-  const base = process.env.BMAD_EXTERNAL_MODULES_CACHE || path.join(os.homedir(), '.bmad', 'cache', 'external-modules');
+  const base = process.env.WIZZ_EXTERNAL_MODULES_CACHE || path.join(os.homedir(), '.wizz', 'cache', 'external-modules');
   return path.join(base, moduleName, ...segments);
 }
 
@@ -85,9 +85,9 @@ function getExternalModuleCachePath(moduleName, ...segments) {
  * Locate an installed module's `module.yaml` by filesystem lookup only.
  *
  * Built-in modules (core, bmm) live under <src>. External official modules are
- * cloned into ~/.bmad/cache/external-modules/<name>/ with varying internal
+ * cloned into ~/.wizz/cache/external-modules/<name>/ with varying internal
  * layouts (some at src/module.yaml, some at skills/module.yaml, some nested).
- * Url-source custom modules are cloned into ~/.bmad/cache/custom-modules/<host>/<owner>/<repo>/
+ * Url-source custom modules are cloned into ~/.wizz/cache/custom-modules/<host>/<owner>/<repo>/
  * and are resolved by walking the cache and matching `code` or `name` from the
  * discovered module.yaml. Local custom-source modules are not cached; their
  * path is read from the CustomModuleManager resolution cache set during the
@@ -155,11 +155,11 @@ async function resolveInstalledModuleYaml(moduleName) {
     if (found) return found;
   }
 
-  // Community modules are cloned to ~/.bmad/cache/community-modules/<name>/
+  // Community modules are cloned to ~/.wizz/cache/community-modules/<name>/
   // (parallel to the external-modules cache used above). Search there too so
   // collectAgentsFromModuleYaml and writeCentralConfig can locate community
   // module.yaml files regardless of how nested the layout is.
-  const communityCacheRoot = path.join(os.homedir(), '.bmad', 'cache', 'community-modules', moduleName);
+  const communityCacheRoot = path.join(os.homedir(), '.wizz', 'cache', 'community-modules', moduleName);
   if (await fs.pathExists(communityCacheRoot)) {
     const found = await searchRoot(communityCacheRoot);
     if (found) return found;
@@ -180,15 +180,15 @@ async function resolveInstalledModuleYaml(moduleName) {
     // Resolution cache unavailable — continue
   }
 
-  // Fallback: url-source custom modules cloned to ~/.bmad/cache/custom-modules/.
+  // Fallback: url-source custom modules cloned to ~/.wizz/cache/custom-modules/.
   // Walk every cached repo, enumerate ALL module.yaml files via searchRootAll
   // (a single repo can host multiple plugins in discovery mode), and match by
   // the yaml's `code` or `name` field. This works on re-install runs where
   // _resolutionCache is empty and covers both discovery-mode (with marketplace.json)
-  // and direct-mode modules, since we identify repo roots by .bmad-source.json
+  // and direct-mode modules, since we identify repo roots by .wizz-source.json
   // (written by cloneRepo) or .claude-plugin/ rather than by marketplace.json.
   try {
-    const customCacheDir = path.join(os.homedir(), '.bmad', 'cache', 'custom-modules');
+    const customCacheDir = path.join(os.homedir(), '.wizz', 'cache', 'custom-modules');
     if (await fs.pathExists(customCacheDir)) {
       const { CustomModuleManager } = require('./modules/custom-module-manager');
       const customMgr = new CustomModuleManager();

package/tools/installer/prompts.js

@@ -1,5 +1,5 @@
 /**
- * @clack/prompts wrapper for BMAD CLI
+ * @clack/prompts wrapper for WIZZ CLI
  *
  * This module provides a unified interface for CLI prompts using @clack/prompts.
  * It replaces Inquirer.js to fix Windows arrow key navigation issues (libuv #852).

package/tools/installer/set-overrides.js

@@ -230,16 +230,16 @@ async function tomlHasKey(filePath, section, key) {
  * (not in either file yet), team scope is the safe default.
  *
  * @param {Object<string, Object<string, string>>} overrides
- * @param {string} bmadDir absolute path to `_wizz/`
+ * @param {string} wizzDir absolute path to `_wizz/`
  * @returns {Promise<Array<{module:string,key:string,scope:'team'|'user',file:string}>>}
  *          a list of applied entries (for caller logging)
  */
-async function applySetOverrides(overrides, bmadDir) {
+async function applySetOverrides(overrides, wizzDir) {
   const applied = [];
   if (!overrides || typeof overrides !== 'object') return applied;
 
-  const teamPath = path.join(bmadDir, 'config.toml');
-  const userPath = path.join(bmadDir, 'config.user.toml');
+  const teamPath = path.join(wizzDir, 'config.toml');
+  const userPath = path.join(wizzDir, 'config.user.toml');
 
   for (const moduleCode of Object.keys(overrides)) {
     // Skip overrides for modules not actually installed. The installer writes
@@ -247,7 +247,7 @@ async function applySetOverrides(overrides, bmadDir) {
     // so its presence is a reliable "is this module here?" signal that works
     // for both fresh installs and quick-updates without coupling to caller-
     // supplied module lists.
-    const moduleConfigYaml = path.join(bmadDir, moduleCode, 'config.yaml');
+    const moduleConfigYaml = path.join(wizzDir, moduleCode, 'config.yaml');
     if (!(await fs.pathExists(moduleConfigYaml))) {
       continue;
     }
@@ -291,7 +291,7 @@ async function applySetOverrides(overrides, bmadDir) {
     // value lives in the per-module yaml but won't be re-emitted into
     // config.toml on the next install (the schema-strict partition drops
     // it); re-pass `--set` if you need it sticky.
-    const moduleYamlPath = path.join(bmadDir, moduleCode, 'config.yaml');
+    const moduleYamlPath = path.join(wizzDir, moduleCode, 'config.yaml');
     if (await fs.pathExists(moduleYamlPath)) {
       try {
         const text = await fs.readFile(moduleYamlPath, 'utf8');

package/tools/installer/ui.js

@@ -1,7 +1,9 @@
 const path = require('node:path');
 const os = require('node:os');
 const semver = require('semver');
+const yaml = require('yaml');
 const fs = require('./fs-native');
+const { getProjectRoot } = require('./project-root');
 const installerPackageJson = require('../../package.json');
 const { CLIUtils } = require('./cli-utils');
 const { ExternalModuleManager } = require('./modules/external-manager');
@@ -15,6 +17,8 @@ const {
   bundledTargetWarnings,
 } = require('./modules/channel-plan');
 const channelResolver = require('./modules/channel-resolver');
+const { resolveMcps } = require('./modules/mcp-config');
+const { resolveClis, detectClis } = require('./modules/cli-config');
 const prompts = require('./prompts');
 const { parseSetEntries } = require('./set-overrides');
 
@@ -110,7 +114,7 @@ async function getModuleVersion(moduleCode, { repoUrl = null, registryDefault =
  * UI utilities for the installer
  */
 class UI {
-  async _retainUnavailableInstalledModules(selectedModules, installedModuleIds, bmadDir, options = {}) {
+  async _retainUnavailableInstalledModules(selectedModules, installedModuleIds, wizzDir, options = {}) {
     const { OfficialModules } = require('./modules/official-modules');
     const officialCodes = new Set(['core']);
 
@@ -135,7 +139,7 @@ class UI {
       if (!selectedSet.has(moduleId) && !options.preserveUnselected) continue;
       if (officialCodes.has(moduleId)) continue;
 
-      const customSource = await customMgr.findModuleSourceByCode(moduleId, { bmadDir });
+      const customSource = await customMgr.findModuleSourceByCode(moduleId, { wizzDir });
       if (!customSource) {
         preserveModules.push(moduleId);
       }
@@ -161,7 +165,7 @@ class UI {
     const messageLoader = new MessageLoader();
     await messageLoader.displayStartMessage();
 
-    // Probe the local Python before any other prompts: several BMAD features
+    // Probe the local Python before any other prompts: several WIZZ features
     // (memlog session memory, TOML config resolution) need Python 3.11+ at
     // runtime. Warn-don't-block, but require an explicit ack so the warning
     // can't scroll past unseen. The installer runs in the destination
@@ -213,10 +217,10 @@ class UI {
 
     const { Installer } = require('./core/installer');
     const installer = new Installer();
-    const { bmadDir } = await installer.findBmadDir(confirmedDirectory);
+    const { wizzDir } = await installer.findWizzDir(confirmedDirectory);
 
-    // Check if there's an existing BMAD installation
-    const hasExistingInstall = await fs.pathExists(bmadDir);
+    // Check if there's an existing WIZZ installation
+    const hasExistingInstall = await fs.pathExists(wizzDir);
 
     // Track action type (only set if there's an existing installation)
     let actionType;
@@ -224,7 +228,7 @@ class UI {
     // Only show action menu if there's an existing installation
     if (hasExistingInstall) {
       // Get version information
-      const { existingInstall, bmadDir } = await this.getExistingInstallation(confirmedDirectory);
+      const { existingInstall, wizzDir } = await this.getExistingInstallation(confirmedDirectory);
 
       // Build menu choices dynamically
       const choices = [];
@@ -321,7 +325,7 @@ class UI {
           selectedModules.unshift('core');
         }
 
-        const retainedModuleResult = await this._retainUnavailableInstalledModules(selectedModules, installedModuleIds, bmadDir, {
+        const retainedModuleResult = await this._retainUnavailableInstalledModules(selectedModules, installedModuleIds, wizzDir, {
           preserveUnselected: options.yes && !options.modules,
         });
         selectedModules = retainedModuleResult.selectedModules;
@@ -339,7 +343,7 @@ class UI {
         // default Y, major default N). Legacy entries with no channel are
         // migrated here too. Mutates channelOptions.pins to lock rejections.
         await this._resolveUpdateChannels({
-          bmadDir,
+          wizzDir,
           selectedModules,
           channelOptions,
           yes: options.yes || false,
@@ -427,6 +431,9 @@ class UI {
     await this._interactiveChannelGate({ options, channelOptions, selectedModules });
 
     let toolSelection = await this.promptToolSelection(confirmedDirectory, options);
+    const selectedAreas = await this.selectSkillAreas(selectedModules, options);
+    const mcpPlan = await this.selectMcps(selectedModules, selectedAreas, options);
+    const cliPlan = await this.selectClis(selectedModules, selectedAreas, options);
     const { moduleConfigs, setOverrides } = await this.collectModuleConfigs(confirmedDirectory, selectedModules, {
       ...options,
       channelOptions,
@@ -451,6 +458,9 @@ class UI {
       modules: selectedModules,
       ides: toolSelection.ides,
       skipIde: toolSelection.skipIde,
+      selectedAreas,
+      mcpPlan,
+      cliPlan,
       coreConfig: moduleConfigs.core || {},
       moduleConfigs: moduleConfigs,
       setOverrides,
@@ -459,6 +469,206 @@ class UI {
     };
   }
 
+  /**
+   * Load and parse skills-registry.yaml from the package root.
+   * @returns {Object|null} Parsed registry, or null when absent/unreadable
+   */
+  _loadSkillsRegistry() {
+    try {
+      const registryPath = path.join(getProjectRoot(), 'skills-registry.yaml');
+      if (!fs.existsSync(registryPath)) return null;
+      return yaml.parse(fs.readFileSync(registryPath, 'utf8'));
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Prompt for which global-skill AREAS to install (designer, copy, seo, ...).
+   * Only relevant when the `wizz` (agency/method) module is selected. Areas come
+   * straight from skills-registry.yaml so this never diverges from the routing.
+   * Returns an empty array to mean "all areas" (the installSkillsLib sentinel).
+   * @param {string[]} selectedModules - Modules chosen for install
+   * @param {Object} options - Command-line options
+   * @returns {Promise<string[]>} Chosen area keys, or [] for all
+   */
+  async selectSkillAreas(selectedModules, options = {}) {
+    if (!selectedModules.includes('wizz')) return [];
+
+    const registry = this._loadSkillsRegistry();
+    if (!registry || !registry.areas) return [];
+    const areaKeys = Object.keys(registry.areas);
+    if (areaKeys.length === 0) return [];
+
+    // CLI: --areas a,b,c (or 'all')
+    if (options.areas !== undefined) {
+      const raw = String(options.areas)
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+      if (raw.includes('all')) return [];
+      const unknown = raw.filter((a) => !areaKeys.includes(a));
+      if (unknown.length > 0) {
+        await prompts.log.warn(`Áreas desconhecidas ignoradas: ${unknown.join(', ')}`);
+      }
+      return raw.filter((a) => areaKeys.includes(a));
+    }
+
+    // Non-interactive (--yes): install every area.
+    if (options.yes) return [];
+
+    const areaOptions = areaKeys.map((key) => {
+      const summary = registry.areas[key].summary || '';
+      return { label: summary ? `${key} (${summary})` : key, value: key };
+    });
+
+    const selected = await prompts.autocompleteMultiselect({
+      message: 'Quais áreas de skills globais instalar? (vazio = todas)',
+      options: areaOptions,
+      initialValues: areaKeys,
+      required: false,
+      maxItems: 12,
+    });
+
+    // Empty or full selection both collapse to the "all areas" sentinel.
+    if (!selected || selected.length === 0 || selected.length === areaKeys.length) return [];
+    return selected;
+  }
+
+  /**
+   * Prompt for which recommended MCP servers to configure for the chosen areas.
+   * Reads the same skills-registry.yaml the installer/maestro use, so the offered
+   * servers never diverge from routing. Returns a split plan:
+   *   - toWrite: entries to MERGE into the project `.mcp.json` (placeholder secrets)
+   *   - toRecommend: entries to merely print as `claude mcp add ...` (nothing lost)
+   * Non-interactive (--yes/CI) writes nothing and recommends everything, so the
+   * install never touches MCP config without an explicit choice.
+   * @param {string[]} selectedModules - Modules chosen for install
+   * @param {string[]} selectedAreas - Areas resolved by selectSkillAreas ([]=all)
+   * @param {Object} options - Command-line options
+   * @returns {Promise<{toWrite: Object[], toRecommend: Object[]}>}
+   */
+  async selectMcps(selectedModules, selectedAreas, options = {}) {
+    if (!selectedModules.includes('wizz')) return { toWrite: [], toRecommend: [] };
+
+    const registry = this._loadSkillsRegistry();
+    const resolved = resolveMcps(registry, selectedAreas);
+    if (resolved.length === 0) return { toWrite: [], toRecommend: [] };
+
+    const byId = new Map(resolved.map((m) => [m.id, m]));
+    const split = (writeIds) => {
+      const writeSet = new Set(writeIds);
+      return {
+        toWrite: resolved.filter((m) => writeSet.has(m.id)),
+        toRecommend: resolved.filter((m) => !writeSet.has(m.id)),
+      };
+    };
+
+    // CLI: --mcps a,b,c | 'all' | 'none'
+    if (options.mcps !== undefined) {
+      const raw = String(options.mcps)
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+      if (raw.includes('none')) return split([]);
+      if (raw.includes('all')) return split(resolved.map((m) => m.id));
+      const unknown = raw.filter((id) => !byId.has(id));
+      if (unknown.length > 0) {
+        await prompts.log.warn(`MCPs desconhecidos ignorados: ${unknown.join(', ')}`);
+      }
+      return split(raw.filter((id) => byId.has(id)));
+    }
+
+    // Non-interactive: don't touch config, just recommend everything.
+    if (options.yes) return { toWrite: [], toRecommend: resolved };
+
+    const selected = await prompts.multiselect({
+      message: 'Quais MCPs configurar no .mcp.json? (não marcados viram comando pra rodar depois)',
+      options: resolved.map((m) => ({
+        label: m.id,
+        value: m.id,
+        hint: m.when,
+      })),
+      initialValues: resolved.map((m) => m.id),
+      required: false,
+    });
+
+    return split(selected || []);
+  }
+
+  /**
+   * Prompt for which recommended CLIs to install for the chosen areas.
+   * Reads the same skills-registry.yaml as the installer/maestro. CLIs are the
+   * tools agents shell out to (agent-browser, rtk), not MCP servers. We DETECT
+   * what's already installed first (never reinstall), then offer the missing
+   * ones. Install runs a system command (npm install -g, curl | sh), so the
+   * default is RECOMMEND-only: nothing is installed without an explicit choice.
+   * Returns a split plan:
+   *   - toInstall: entries whose `install` command we run now
+   *   - toRecommend: entries we merely print as a command to run later
+   * Already-installed CLIs go to neither (reported as present, no action).
+   * @param {string[]} selectedModules - Modules chosen for install
+   * @param {string[]} selectedAreas - Areas resolved by selectSkillAreas ([]=all)
+   * @param {Object} options - Command-line options
+   * @returns {Promise<{toInstall: Object[], toRecommend: Object[], alreadyInstalled: Object[]}>}
+   */
+  async selectClis(selectedModules, selectedAreas, options = {}) {
+    const empty = { toInstall: [], toRecommend: [], alreadyInstalled: [] };
+    if (!selectedModules.includes('wizz')) return empty;
+
+    const registry = this._loadSkillsRegistry();
+    const resolved = resolveClis(registry, selectedAreas);
+    if (resolved.length === 0) return empty;
+
+    // Detect what's already on PATH so we never offer to reinstall it.
+    const detected = await detectClis(resolved);
+    const alreadyInstalled = detected.filter((c) => c.installed);
+    const missing = detected.filter((c) => !c.installed);
+    if (missing.length === 0) return { toInstall: [], toRecommend: [], alreadyInstalled };
+
+    const byId = new Map(missing.map((c) => [c.id, c]));
+    const split = (installIds) => {
+      const installSet = new Set(installIds);
+      return {
+        toInstall: missing.filter((c) => installSet.has(c.id)),
+        toRecommend: missing.filter((c) => !installSet.has(c.id)),
+        alreadyInstalled,
+      };
+    };
+
+    // CLI: --clis a,b,c | 'all' | 'none'
+    if (options.clis !== undefined) {
+      const raw = String(options.clis)
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+      if (raw.includes('none')) return split([]);
+      if (raw.includes('all')) return split(missing.map((c) => c.id));
+      const unknown = raw.filter((id) => !byId.has(id));
+      if (unknown.length > 0) {
+        await prompts.log.warn(`CLIs desconhecidos/já instalados ignorados: ${unknown.join(', ')}`);
+      }
+      return split(raw.filter((id) => byId.has(id)));
+    }
+
+    // Non-interactive: don't run system commands, just recommend everything.
+    if (options.yes) return { toInstall: [], toRecommend: missing, alreadyInstalled };
+
+    // Default UNCHECKED: install runs a system command, so opt-in only.
+    const selected = await prompts.multiselect({
+      message: 'Quais CLIs instalar agora? (não marcados viram comando pra rodar depois)',
+      options: missing.map((c) => ({
+        label: c.id,
+        value: c.id,
+        hint: c.when,
+      })),
+      initialValues: [],
+      required: false,
+    });
+
+    return split(selected || []);
+  }
+
   /**
    * Prompt for tool/IDE selection (called after module configuration)
    * Uses a split prompt approach:
@@ -503,8 +713,8 @@ class UI {
     const { ExistingInstall } = require('./core/existing-install');
     const { Installer } = require('./core/installer');
     const installer = new Installer();
-    const { bmadDir } = await installer.findBmadDir(projectDir || process.cwd());
-    const existingInstall = await ExistingInstall.detect(bmadDir);
+    const { wizzDir } = await installer.findWizzDir(projectDir || process.cwd());
+    const existingInstall = await ExistingInstall.detect(wizzDir);
     const configuredIdes = existingInstall.ides;
 
     // Get IDE manager to fetch available IDEs dynamically
@@ -732,17 +942,17 @@ class UI {
   /**
    * Get existing installation info and installed modules
    * @param {string} directory - Installation directory
-   * @returns {Object} Object with existingInstall, installedModuleIds, installedModuleVersions, and bmadDir
+   * @returns {Object} Object with existingInstall, installedModuleIds, installedModuleVersions, and wizzDir
    */
   async getExistingInstallation(directory) {
     const { ExistingInstall } = require('./core/existing-install');
     const { Installer } = require('./core/installer');
     const installer = new Installer();
-    const { bmadDir } = await installer.findBmadDir(directory);
-    const existingInstall = await ExistingInstall.detect(bmadDir);
+    const { wizzDir } = await installer.findWizzDir(directory);
+    const existingInstall = await ExistingInstall.detect(wizzDir);
     const installedModuleIds = new Set(existingInstall.moduleIds);
     const installedModuleVersions = new Map();
-    const manifestModules = await manifest.getAllModuleVersions(bmadDir);
+    const manifestModules = await manifest.getAllModuleVersions(wizzDir);
 
     for (const module of manifestModules) {
       if (module?.name && module.version) {
@@ -760,7 +970,7 @@ class UI {
       installedModuleVersions.set('core', existingInstall.version);
     }
 
-    return { existingInstall, installedModuleIds, installedModuleVersions, bmadDir };
+    return { existingInstall, installedModuleIds, installedModuleVersions, wizzDir };
   }
 
   /**
@@ -1355,15 +1565,15 @@ class UI {
       if (stats.isDirectory()) {
         const files = await fs.readdir(directory);
         if (files.length > 0) {
-          // Check for any bmad installation (any folder with _config/manifest.yaml)
+          // Check for any wizz installation (any folder with _config/manifest.yaml)
           const { Installer } = require('./core/installer');
           const installer = new Installer();
-          const bmadResult = await installer.findBmadDir(directory);
-          const hasBmadInstall =
-            (await fs.pathExists(bmadResult.bmadDir)) && (await fs.pathExists(path.join(bmadResult.bmadDir, '_config', 'manifest.yaml')));
+          const wizzResult = await installer.findWizzDir(directory);
+          const hasWizzInstall =
+            (await fs.pathExists(wizzResult.wizzDir)) && (await fs.pathExists(path.join(wizzResult.wizzDir, '_config', 'manifest.yaml')));
 
-          const bmadNote = hasBmadInstall ? ` including existing Wizz installation (${path.basename(bmadResult.bmadDir)})` : '';
-          await prompts.log.message(`Directory exists and contains ${files.length} item(s)${bmadNote}`);
+          const wizzNote = hasWizzInstall ? ` including existing Wizz installation (${path.basename(wizzResult.wizzDir)})` : '';
+          await prompts.log.message(`Directory exists and contains ${files.length} item(s)${wizzNote}`);
         } else {
           await prompts.log.message('Directory exists and is empty');
         }
@@ -1601,8 +1811,8 @@ class UI {
     const { ExistingInstall } = require('./core/existing-install');
     const { Installer } = require('./core/installer');
     const installer = new Installer();
-    const { bmadDir } = await installer.findBmadDir(directory);
-    const existingInstall = await ExistingInstall.detect(bmadDir);
+    const { wizzDir } = await installer.findWizzDir(directory);
+    const existingInstall = await ExistingInstall.detect(wizzDir);
     return existingInstall.ides;
   }
 
@@ -1695,12 +1905,12 @@ class UI {
    * @param {Object} statusData - Status data with modules, installation info, and available updates
    */
   async displayStatus(statusData) {
-    const { installation, modules, availableUpdates, bmadDir } = statusData;
+    const { installation, modules, availableUpdates, wizzDir } = statusData;
 
     // Installation info
     const infoLines = [
       `Version:       ${installation.version || 'unknown'}`,
-      `Location:      ${bmadDir}`,
+      `Location:      ${wizzDir}`,
       `Installed:     ${new Date(installation.installDate).toLocaleDateString()}`,
       `Last Updated:  ${installation.lastUpdated ? new Date(installation.lastUpdated).toLocaleDateString() : 'unknown'}`,
     ];
@@ -1855,10 +2065,10 @@ class UI {
    * Decisions that freeze the current version are applied by adding a pin to
    * `channelOptions.pins` so downstream clone logic honors them.
    */
-  async _resolveUpdateChannels({ bmadDir, selectedModules, channelOptions, yes }) {
+  async _resolveUpdateChannels({ wizzDir, selectedModules, channelOptions, yes }) {
     const { Manifest } = require('./core/manifest');
     const manifestObj = new Manifest();
-    const manifest = await manifestObj.read(bmadDir);
+    const manifest = await manifestObj.read(wizzDir);
     const existingByName = new Map();
     for (const m of manifest?.modulesDetailed || []) {
       if (m?.name) existingByName.set(m.name, m);
@@ -1899,7 +2109,7 @@ class UI {
       if (!info) continue;
       // Bundled modules (core/bmm) ship with the installer binary itself —
       // their version is stapled to the CLI version, not a git tag. Skip
-      // tag-API lookups for them; the "upgrade" mechanism is `npx bmad@X install`.
+      // tag-API lookups for them; the "upgrade" mechanism is `npx wizz@X install`.
       if (info.builtIn) continue;
 
       const repoUrl = info.url;

package/tools/installer/yaml-format.js

@@ -14,7 +14,7 @@ async function initializeModules() {
 }
 
 /**
- * YAML Formatter and Linter for BMad-Method
+ * YAML Formatter and Linter for Wizz-Method
  * Formats and validates YAML files and YAML embedded in Markdown
  */
 

package/tools/migrate-custom-module-paths.js

@@ -9,15 +9,15 @@ const yaml = require('yaml');
 const chalk = require('chalk');
 
 /**
- * Find BMAD directory in project
+ * Find WIZZ directory in project
  */
-function findBmadDir(projectDir = process.cwd()) {
+function findWizzDir(projectDir = process.cwd()) {
   const possibleNames = ['_wizz'];
 
   for (const name of possibleNames) {
-    const bmadDir = path.join(projectDir, name);
-    if (fs.existsSync(bmadDir)) {
-      return bmadDir;
+    const wizzDir = path.join(projectDir, name);
+    if (fs.existsSync(wizzDir)) {
+      return wizzDir;
     }
   }
 
@@ -84,18 +84,18 @@ async function updateManifest(manifestPath, projectRoot) {
  */
 async function migrate(directory) {
   const projectRoot = path.resolve(directory || process.cwd());
-  const bmadDir = findBmadDir(projectRoot);
+  const wizzDir = findWizzDir(projectRoot);
 
-  if (!bmadDir) {
-    console.error(chalk.red('✗ No BMAD installation found in directory'));
+  if (!wizzDir) {
+    console.error(chalk.red('✗ No WIZZ installation found in directory'));
     process.exit(1);
   }
 
-  console.log(chalk.blue.bold('🔄 BMAD Custom Module Path Migration'));
+  console.log(chalk.blue.bold('🔄 WIZZ Custom Module Path Migration'));
   console.log(chalk.dim(`Project: ${projectRoot}`));
-  console.log(chalk.dim(`BMAD Directory: ${bmadDir}`));
+  console.log(chalk.dim(`WIZZ Directory: ${wizzDir}`));
 
-  const manifestPath = path.join(bmadDir, '_config', 'manifest.yaml');
+  const manifestPath = path.join(wizzDir, '_config', 'manifest.yaml');
 
   if (!fs.existsSync(manifestPath)) {
     console.error(chalk.red('✗ No manifest.yaml found'));

package/tools/skill-validator.md

@@ -68,9 +68,9 @@ If no findings are generated (from either pass), the skill passes validation.
 
 - **Severity:** HIGH
 - **Applies to:** `SKILL.md`
-- **Rule:** The `name` value must start with `bmad-` (motor) or `wizz-` (camada Wizz), use only lowercase letters, numbers, and single hyphens between segments.
-- **Detection:** Regex test: `^(bmad|wizz)-[a-z0-9]+(-[a-z0-9]+)*$`.
-- **Fix:** Rename to comply with the format (e.g., `wizz-my-skill` ou `bmad-my-skill`).
+- **Rule:** The `name` value must start with `wizz-` (motor) or `wizz-` (camada Wizz), use only lowercase letters, numbers, and single hyphens between segments.
+- **Detection:** Regex test: `^(wizz|wizz)-[a-z0-9]+(-[a-z0-9]+)*$`.
+- **Fix:** Rename to comply with the format (e.g., `wizz-my-skill` ou `wizz-my-skill`).
 
 ### SKILL-05 — `name` Must Match Directory Name
 
@@ -85,8 +85,8 @@ If no findings are generated (from either pass), the skill passes validation.
 - **Severity:** MEDIUM
 - **Applies to:** `SKILL.md`
 - **Rule:** The `description` must state both what the skill does AND when to use it. Max 1024 characters.
-- **Detection:** Check length. Look for trigger phrases like "Use when" or "Use if" — their absence suggests the description only says _what_ but not _when_.
-- **Fix:** Append a "Use when..." clause to the description.
+- **Detection:** Check length. Look for trigger phrases like "Use when", "Use if", "Use para", or "Use quando" — their absence suggests the description only says _what_ but not _when_.
+- **Fix:** Append a "Use when..." or "Use para..." clause to the description.
 
 ### SKILL-07 — SKILL.md Must Have Body Content
 
@@ -281,7 +281,7 @@ If no findings are generated (from either pass), the skill passes validation.
 - **Severity:** HIGH
 - **Applies to:** all files
 - **Rule:** When a skill references another skill by name, the surrounding instruction must use the word "invoke". The canonical form is `Invoke the \`skill-name\` skill`. Phrases like "Read fully and follow", "Execute", "Run", "Load", "Open", or "Follow" are invalid — they imply file-level operations on a document, not skill invocation. A skill is a unit that is invoked, not a file that is read.
-- **Detection:** Find all references to other skills by name (typically backtick-quoted skill names like \`bmad-foo\`). Check the surrounding instruction text (same sentence or directive) for file-oriented verbs: "read", "follow", "load", "execute", "run", "open". Flag any that do not use "invoke" (or a close synonym like "activate" or "launch").
+- **Detection:** Find all references to other skills by name (typically backtick-quoted skill names like \`wizz-foo\`). Check the surrounding instruction text (same sentence or directive) for file-oriented verbs: "read", "follow", "load", "execute", "run", "open". Flag any that do not use "invoke" (or a close synonym like "activate" or "launch").
 - **Fix:** Replace the instruction with `Invoke the \`skill-name\` skill`. Remove any "read fully and follow" or similar file-oriented phrasing. Do NOT add a `skill:` prefix to the name — use natural language.
 
 ---