wizz-method 1.0.2 → 1.1.0

package/tools/installer/ide/shared/installed-skills.js

@@ -4,18 +4,18 @@ const csv = require('csv-parse/sync');
 
 /**
  * Read the global skill-manifest.csv and return the set of canonicalIds.
- * These define which directory entries in a target_dir are BMAD-owned, regardless
- * of whether they happen to start with "bmad-" (custom modules can ship skills
+ * These define which directory entries in a target_dir are WIZZ-owned, regardless
+ * of whether they happen to start with "wizz-" (custom modules can ship skills
  * with any prefix, e.g. "fred-cool-skill").
  *
- * @param {string} bmadDir - Path to the _wizz install directory
+ * @param {string} wizzDir - Path to the _wizz install directory
  * @returns {Promise<Set<string>>} Set of canonicalIds, or empty set if manifest missing
  */
-async function getInstalledCanonicalIds(bmadDir) {
+async function getInstalledCanonicalIds(wizzDir) {
   const ids = new Set();
-  if (!bmadDir) return ids;
+  if (!wizzDir) return ids;
 
-  const csvPath = path.join(bmadDir, '_config', 'skill-manifest.csv');
+  const csvPath = path.join(wizzDir, '_config', 'skill-manifest.csv');
   if (!(await fs.pathExists(csvPath))) return ids;
 
   try {
@@ -32,19 +32,19 @@ async function getInstalledCanonicalIds(bmadDir) {
 }
 
 /**
- * Test whether a directory entry is BMAD-owned.
- * Prefers the manifest's canonicalIds; falls back to the legacy "bmad" prefix
- * when no manifest is available (early install, ancestor lookup with no bmad dir).
+ * Test whether a directory entry is WIZZ-owned.
+ * Prefers the manifest's canonicalIds; falls back to the legacy "wizz" prefix
+ * when no manifest is available (early install, ancestor lookup with no wizz dir).
  *
  * @param {string} entry - Directory entry name
  * @param {Set<string>|null} canonicalIds - From getInstalledCanonicalIds, or null
  * @returns {boolean}
  */
-function isBmadOwnedEntry(entry, canonicalIds) {
+function isWizzOwnedEntry(entry, canonicalIds) {
   if (!entry || typeof entry !== 'string') return false;
-  if (entry.toLowerCase().startsWith('bmad-os-')) return false;
+  if (entry.toLowerCase().startsWith('wizz-os-')) return false;
   if (canonicalIds && canonicalIds.size > 0) return canonicalIds.has(entry);
-  return entry.toLowerCase().startsWith('bmad');
+  return entry.toLowerCase().startsWith('wizz');
 }
 
-module.exports = { getInstalledCanonicalIds, isBmadOwnedEntry };
+module.exports = { getInstalledCanonicalIds, isWizzOwnedEntry };

package/tools/installer/ide/shared/path-utils.js

@@ -4,66 +4,66 @@
  * Provides utilities to convert hierarchical paths to flat naming conventions.
  *
  * DASH-BASED NAMING (new standard):
- * - Agents: bmad-agent-module-name.md (with bmad-agent- prefix)
- * - Workflows/Tasks/Tools: bmad-module-name.md
+ * - Agents: wizz-agent-module-name.md (with wizz-agent- prefix)
+ * - Workflows/Tasks/Tools: wizz-module-name.md
  *
  * Example outputs:
- * - cis/agents/storymaster.md → bmad-agent-cis-storymaster.md
- * - bmm/workflows/plan-project.md → bmad-bmm-plan-project.md
- * - bmm/tasks/create-story.md → bmad-bmm-create-story.md
- * - core/agents/brainstorming.md → bmad-agent-brainstorming.md (core agents skip module name)
- * - standalone/agents/fred.md → bmad-agent-standalone-fred.md
+ * - cis/agents/storymaster.md → wizz-agent-cis-storymaster.md
+ * - bmm/workflows/plan-project.md → wizz-bmm-plan-project.md
+ * - bmm/tasks/create-story.md → wizz-bmm-create-story.md
+ * - core/agents/brainstorming.md → wizz-agent-brainstorming.md (core agents skip module name)
+ * - standalone/agents/fred.md → wizz-agent-standalone-fred.md
  */
 
 const AGENT_SEGMENT = 'agents';
 
-// BMAD installation folder name - centralized constant for all installers
-const BMAD_FOLDER_NAME = '_wizz';
+// WIZZ installation folder name - centralized constant for all installers
+const WIZZ_FOLDER_NAME = '_wizz';
 
 /**
  * Convert hierarchical path to flat dash-separated name (NEW STANDARD)
- * Converts: 'bmm', 'agents', 'pm' → 'bmad-agent-bmm-pm.md'
- * Converts: 'bmm', 'workflows', 'correct-course' → 'bmad-bmm-correct-course.md'
- * Converts: 'core', 'agents', 'brainstorming' → 'bmad-agent-brainstorming.md' (core agents skip module name)
- * Converts: 'standalone', 'agents', 'fred' → 'bmad-agent-standalone-fred.md'
+ * Converts: 'bmm', 'agents', 'pm' → 'wizz-agent-bmm-pm.md'
+ * Converts: 'bmm', 'workflows', 'correct-course' → 'wizz-bmm-correct-course.md'
+ * Converts: 'core', 'agents', 'brainstorming' → 'wizz-agent-brainstorming.md' (core agents skip module name)
+ * Converts: 'standalone', 'agents', 'fred' → 'wizz-agent-standalone-fred.md'
  *
  * @param {string} module - Module name (e.g., 'bmm', 'core', 'standalone')
  * @param {string} type - Artifact type ('agents', 'workflows', 'tasks', 'tools')
  * @param {string} name - Artifact name (e.g., 'pm', 'brainstorming')
- * @returns {string} Flat filename like 'bmad-agent-bmm-pm.md' or 'bmad-bmm-correct-course.md'
+ * @returns {string} Flat filename like 'wizz-agent-bmm-pm.md' or 'wizz-bmm-correct-course.md'
  */
 function toDashName(module, type, name) {
   const isAgent = type === AGENT_SEGMENT;
 
-  // For core module, skip the module name: use 'bmad-agent-name.md' instead of 'bmad-agent-core-name.md'
+  // For core module, skip the module name: use 'wizz-agent-name.md' instead of 'wizz-agent-core-name.md'
   if (module === 'core') {
-    return isAgent ? `bmad-agent-${name}.md` : `bmad-${name}.md`;
+    return isAgent ? `wizz-agent-${name}.md` : `wizz-${name}.md`;
   }
   // For standalone module, include 'standalone' in the name
   if (module === 'standalone') {
-    return isAgent ? `bmad-agent-standalone-${name}.md` : `bmad-standalone-${name}.md`;
+    return isAgent ? `wizz-agent-standalone-${name}.md` : `wizz-standalone-${name}.md`;
   }
 
-  // Module artifacts: bmad-module-name.md or bmad-agent-module-name.md
+  // Module artifacts: wizz-module-name.md or wizz-agent-module-name.md
   // eslint-disable-next-line unicorn/prefer-string-replace-all -- regex replace is intentional here
   const dashName = name.replace(/\//g, '-'); // Flatten nested paths
-  return isAgent ? `bmad-agent-${module}-${dashName}.md` : `bmad-${module}-${dashName}.md`;
+  return isAgent ? `wizz-agent-${module}-${dashName}.md` : `wizz-${module}-${dashName}.md`;
 }
 
 /**
  * Convert relative path to flat dash-separated name
- * Converts: 'bmm/agents/pm.md' → 'bmad-agent-bmm-pm.md'
- * Converts: 'bmm/agents/tech-writer/tech-writer.md' → 'bmad-agent-bmm-tech-writer.md' (uses folder name)
- * Converts: 'bmm/workflows/correct-course.md' → 'bmad-bmm-correct-course.md'
- * Converts: 'core/agents/brainstorming.md' → 'bmad-agent-brainstorming.md' (core agents skip module name)
+ * Converts: 'bmm/agents/pm.md' → 'wizz-agent-bmm-pm.md'
+ * Converts: 'bmm/agents/tech-writer/tech-writer.md' → 'wizz-agent-bmm-tech-writer.md' (uses folder name)
+ * Converts: 'bmm/workflows/correct-course.md' → 'wizz-bmm-correct-course.md'
+ * Converts: 'core/agents/brainstorming.md' → 'wizz-agent-brainstorming.md' (core agents skip module name)
  *
  * @param {string} relativePath - Path like 'bmm/agents/pm.md'
- * @returns {string} Flat filename like 'bmad-agent-bmm-pm.md' or 'wizz-brainstorming.md'
+ * @returns {string} Flat filename like 'wizz-agent-bmm-pm.md' or 'wizz-brainstorming.md'
  */
 function toDashPath(relativePath) {
   if (!relativePath || typeof relativePath !== 'string') {
     // Return a safe default for invalid input
-    return 'bmad-unknown.md';
+    return 'wizz-unknown.md';
   }
 
   // Strip common file extensions to avoid double extensions in generated filenames
@@ -90,13 +90,13 @@ function toDashPath(relativePath) {
 
 /**
  * Create custom agent dash name
- * Creates: 'bmad-custom-agent-fred-commit-poet.md'
+ * Creates: 'wizz-custom-agent-fred-commit-poet.md'
  *
  * @param {string} agentName - Custom agent name
- * @returns {string} Flat filename like 'bmad-custom-agent-fred-commit-poet.md'
+ * @returns {string} Flat filename like 'wizz-custom-agent-fred-commit-poet.md'
  */
 function customAgentDashName(agentName) {
-  return `bmad-custom-agent-${agentName}.md`;
+  return `wizz-custom-agent-${agentName}.md`;
 }
 
 /**
@@ -105,17 +105,17 @@ function customAgentDashName(agentName) {
  * @returns {boolean} True if filename uses dash format
  */
 function isDashFormat(filename) {
-  return filename.startsWith('bmad-') && filename.includes('-');
+  return filename.startsWith('wizz-') && filename.includes('-');
 }
 
 /**
  * Extract parts from a dash-formatted filename
- * Parses: 'bmad-agent-bmm-pm.md' → { prefix: 'bmad', module: 'bmm', type: 'agents', name: 'pm' }
- * Parses: 'bmad-bmm-correct-course.md' → { prefix: 'bmad', module: 'bmm', type: 'workflows', name: 'correct-course' }
- * Parses: 'bmad-agent-brainstorming.md' → { prefix: 'bmad', module: 'core', type: 'agents', name: 'brainstorming' } (core agents)
- * Parses: 'wizz-brainstorming.md' → { prefix: 'bmad', module: 'core', type: 'workflows', name: 'brainstorming' } (core workflows)
- * Parses: 'bmad-agent-standalone-fred.md' → { prefix: 'bmad', module: 'standalone', type: 'agents', name: 'fred' }
- * Parses: 'bmad-standalone-foo.md' → { prefix: 'bmad', module: 'standalone', type: 'workflows', name: 'foo' }
+ * Parses: 'wizz-agent-bmm-pm.md' → { prefix: 'wizz', module: 'bmm', type: 'agents', name: 'pm' }
+ * Parses: 'wizz-bmm-correct-course.md' → { prefix: 'wizz', module: 'bmm', type: 'workflows', name: 'correct-course' }
+ * Parses: 'wizz-agent-brainstorming.md' → { prefix: 'wizz', module: 'core', type: 'agents', name: 'brainstorming' } (core agents)
+ * Parses: 'wizz-brainstorming.md' → { prefix: 'wizz', module: 'core', type: 'workflows', name: 'brainstorming' } (core workflows)
+ * Parses: 'wizz-agent-standalone-fred.md' → { prefix: 'wizz', module: 'standalone', type: 'agents', name: 'fred' }
+ * Parses: 'wizz-standalone-foo.md' → { prefix: 'wizz', module: 'standalone', type: 'workflows', name: 'foo' }
  *
  * @param {string} filename - Dash-formatted filename
  * @returns {Object|null} Parsed parts or null if invalid format
@@ -124,7 +124,7 @@ function parseDashName(filename) {
   const withoutExt = filename.replace('.md', '');
   const parts = withoutExt.split('-');
 
-  if (parts.length < 2 || parts[0] !== 'bmad') {
+  if (parts.length < 2 || parts[0] !== 'wizz') {
     return null;
   }
 
@@ -133,9 +133,9 @@ function parseDashName(filename) {
 
   if (isAgent) {
     // This is an agent file
-    // Format: bmad-agent-name (core) or bmad-agent-standalone-name or bmad-agent-module-name
+    // Format: wizz-agent-name (core) or wizz-agent-standalone-name or wizz-agent-module-name
     if (parts.length >= 4 && parts[2] === 'standalone') {
-      // Standalone agent: bmad-agent-standalone-name
+      // Standalone agent: wizz-agent-standalone-name
       return {
         prefix: parts[0],
         module: 'standalone',
@@ -144,7 +144,7 @@ function parseDashName(filename) {
       };
     }
     if (parts.length === 3) {
-      // Core agent: bmad-agent-name
+      // Core agent: wizz-agent-name
       return {
         prefix: parts[0],
         module: 'core',
@@ -152,7 +152,7 @@ function parseDashName(filename) {
         name: parts[2],
       };
     } else {
-      // Module agent: bmad-agent-module-name
+      // Module agent: wizz-agent-module-name
       return {
         prefix: parts[0],
         module: parts[2],
@@ -163,7 +163,7 @@ function parseDashName(filename) {
   }
 
   // Not an agent file - must be a workflow/tool/task
-  // If only 2 parts (bmad-name), it's a core workflow/tool/task
+  // If only 2 parts (wizz-name), it's a core workflow/tool/task
   if (parts.length === 2) {
     return {
       prefix: parts[0],
@@ -173,7 +173,7 @@ function parseDashName(filename) {
     };
   }
 
-  // Check for standalone non-agent: bmad-standalone-name
+  // Check for standalone non-agent: wizz-standalone-name
   if (parts[1] === 'standalone') {
     return {
       prefix: parts[0],
@@ -183,7 +183,7 @@ function parseDashName(filename) {
     };
   }
 
-  // Otherwise, it's a module workflow/tool/task (bmad-module-name)
+  // Otherwise, it's a module workflow/tool/task (wizz-module-name)
   return {
     prefix: parts[0],
     module: parts[1],
@@ -194,11 +194,11 @@ function parseDashName(filename) {
 
 /**
  * Resolve the skill name for an artifact.
- * Prefers canonicalId from a bmad-skill-manifest.yaml sidecar when available,
+ * Prefers canonicalId from a wizz-skill-manifest.yaml sidecar when available,
  * falling back to the path-derived name from toDashPath().
  *
  * @param {Object} artifact - Artifact object (must have relativePath; may have canonicalId)
- * @returns {string} Filename like 'wizz-create-prd.md' or 'bmad-agent-bmm-pm.md'
+ * @returns {string} Filename like 'wizz-create-prd.md' or 'wizz-agent-bmm-pm.md'
  */
 function resolveSkillName(artifact) {
   if (artifact.canonicalId) {
@@ -215,5 +215,5 @@ module.exports = {
   isDashFormat,
   parseDashName,
   AGENT_SEGMENT,
-  BMAD_FOLDER_NAME,
+  WIZZ_FOLDER_NAME,
 };

package/tools/installer/ide/shared/skill-manifest.js

@@ -3,14 +3,14 @@ const fs = require('../../fs-native');
 const yaml = require('yaml');
 
 /**
- * Load bmad-skill-manifest.yaml from a directory.
+ * Load wizz-skill-manifest.yaml from a directory.
  * Single-entry manifests (canonicalId at top level) apply to all files in the directory.
  * Multi-entry manifests are keyed by source filename.
- * @param {string} dirPath - Directory to check for bmad-skill-manifest.yaml
+ * @param {string} dirPath - Directory to check for wizz-skill-manifest.yaml
  * @returns {Object|null} Parsed manifest or null
  */
 async function loadSkillManifest(dirPath) {
-  const manifestPath = path.join(dirPath, 'bmad-skill-manifest.yaml');
+  const manifestPath = path.join(dirPath, 'wizz-skill-manifest.yaml');
   try {
     if (!(await fs.pathExists(manifestPath))) return null;
     const content = await fs.readFile(manifestPath, 'utf8');
@@ -19,7 +19,7 @@ async function loadSkillManifest(dirPath) {
     if (parsed.canonicalId || parsed.type) return { __single: parsed };
     return parsed;
   } catch (error) {
-    console.warn(`Warning: Failed to parse bmad-skill-manifest.yaml in ${dirPath}: ${error.message}`);
+    console.warn(`Warning: Failed to parse wizz-skill-manifest.yaml in ${dirPath}: ${error.message}`);
     return null;
   }
 }

package/tools/installer/install-messages.yaml

@@ -18,7 +18,7 @@ startMessage: |
   ⭐ SUPPORT THE PROJECT:
     Star us:   https://github.com/wizzcomms/wizz-method/
 
-  Built on BMAD Core (MIT) by BMad Code — https://github.com/bmad-code-org/BMAD-METHOD
+  Built on BMAD Core (MIT) by Wizz Code — https://github.com/bmad-code-org/WIZZ-METHOD
 
   Docs, and latest updates: https://method.wizzcomms.com/
 

package/tools/installer/list-options.js

@@ -21,7 +21,7 @@ async function readModuleCode(yamlPath) {
 /**
  * Discover module.yaml files for officials we can read locally:
  *   - core, bmm: bundled in src/ (always present)
- *   - external officials: only if previously cloned to ~/.bmad/cache/external-modules/
+ *   - external officials: only if previously cloned to ~/.wizz/cache/external-modules/
  *
  * Each result's `code` is the `code:` field from the module.yaml when present;
  * that's the value `--set <module>.<key>=<value>` matches against.
@@ -77,7 +77,7 @@ async function discoverOfficialModuleYamls() {
     }
   }
 
-  // External cache (~/.bmad/cache/external-modules/<code>/...).
+  // External cache (~/.wizz/cache/external-modules/<code>/...).
   const cacheRoot = getExternalModuleCachePath('').replace(/\/$/, '');
   if (await fs.pathExists(cacheRoot)) {
     const rawEntries = await fs.readdir(cacheRoot, { withFileTypes: true });
@@ -164,7 +164,7 @@ async function formatOptionsList(moduleCode) {
         '',
         'Built-in modules (core, bmm) are always available. External officials',
         'appear here after they have been installed at least once on this machine',
-        '(they are cached under ~/.bmad/cache/external-modules/).',
+        '(they are cached under ~/.wizz/cache/external-modules/).',
         '',
         'For community or custom modules, read the module.yaml file in that',
         "module's source repository directly.",

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

@@ -7,7 +7,7 @@
  * We build the plan from:
  *   1. CLI flags (--channel / --all-* / --next=CODE / --pin CODE=TAG)
  *   2. Interactive answers (the "all stable?" gate + per-module picker)
- *   3. Registry defaults (default_channel from bmad-modules.yaml)
+ *   3. Registry defaults (default_channel from wizz-modules.yaml)
  *   4. Hardcoded fallback 'stable'
  *
  * Precedence: --pin > --next=CODE > --channel (global) > registry default > 'stable'.

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

@@ -17,7 +17,7 @@ const semver = require('semver');
 
 const GITHUB_API_BASE = 'https://api.github.com';
 const DEFAULT_TIMEOUT_MS = 10_000;
-const USER_AGENT = 'bmad-method-installer';
+const USER_AGENT = 'wizz-method-installer';
 
 // Per-process cache: { 'owner/repo' => string[] sorted desc } of pure-semver tags.
 const tagCache = new Map();

package/tools/installer/modules/cli-config.js

@@ -0,0 +1,145 @@
+// Resolves + installs the command-line tools the agents shell out to.
+//
+// Sibling of modules/mcp-config.js. Where MCPs are *servers* merged into the
+// project's .mcp.json, CLIs are *binaries* the agents call directly (e.g.
+// `agent-browser` for browser verification, `rtk` for token economy). The
+// skills-registry.yaml is the single source of truth for both: each AREA may
+// declare a `clis:` list, plus a top-level `cli_utility:` for cross-cutting
+// tools. Each entry has:
+//   id      — the command name (used to detect + label)
+//   when    — when this CLI helps (same disambiguation role as skills' `when`)
+//   check   — command run to detect if it is ALREADY installed (e.g. `x --version`)
+//   install — command run to install it (e.g. `npm install -g x`, `curl … | sh`)
+//
+// Design rules (deliberately conservative, mirroring mcp-config):
+//   - DETECT FIRST: never reinstall something already on PATH. `check` decides.
+//   - INSTALL IS OPT-IN: the caller (the interactive multiselect / --clis flag)
+//     decides what to actually install; everything else is merely recommended
+//     by printing its `install` command. Nothing runs without an explicit choice.
+//   - NO-OP WHEN ABSENT: missing registry / no CLIs => empty, runs nothing.
+//   - FAILURE NEVER THROWS UPSTREAM: installClis collects failures and returns
+//     them so a bad network / EACCES never aborts the whole install.
+//
+// The install/check commands come from our own registry (not user input), and
+// running them (npm install -g, curl | sh) is inherently a trust-the-source
+// operation — hence install is opt-in and recommend-only by default.
+
+const { exec } = require('node:child_process');
+const { promisify } = require('node:util');
+
+const execAsync = promisify(exec);
+
+/**
+ * Default command runner: runs a shell command, never throws. A non-zero exit
+ * resolves to `{ ok: false, ... }` so callers branch on `ok`, not exceptions.
+ * Uses a shell so registry commands with pipes (`curl … | sh`) work as written.
+ * @param {string} command - Full shell command to run
+ * @param {{timeoutMs?: number}} [opts]
+ * @returns {Promise<{ok: boolean, stdout: string, stderr: string}>}
+ */
+async function defaultExec(command, { timeoutMs = 300_000 } = {}) {
+  try {
+    const { stdout, stderr } = await execAsync(command, { timeout: timeoutMs });
+    return { ok: true, stdout: stdout || '', stderr: stderr || '' };
+  } catch (error) {
+    return { ok: false, stdout: error.stdout || '', stderr: error.stderr || error.message || '' };
+  }
+}
+
+/**
+ * Resolve the recommended CLI entries for the chosen areas, deduped by id.
+ * Empty / undefined / containing 'all' means every area. The cross-cutting
+ * `cli_utility:` tools are always included. Entries missing `id` or `install`
+ * are dropped — a CLI we cannot install is not actionable.
+ *
+ * @param {Object} registry - Parsed skills-registry.yaml
+ * @param {string[]} [selectedAreas] - Area keys to resolve
+ * @returns {Array<{id: string, when: string, check: string, install: string, areas: string[]}>}
+ */
+function resolveClis(registry, selectedAreas) {
+  const byId = new Map();
+  const areas = (registry && registry.areas) || {};
+  const wantAll = !selectedAreas || selectedAreas.length === 0 || selectedAreas.includes('all');
+  const chosen = wantAll ? Object.keys(areas) : selectedAreas;
+
+  const add = (cli, areaKey) => {
+    if (!cli || !cli.id || !cli.install) return; // not actionable without an install command
+    const existing = byId.get(cli.id);
+    if (existing) {
+      if (areaKey && !existing.areas.includes(areaKey)) existing.areas.push(areaKey);
+      return;
+    }
+    byId.set(cli.id, {
+      id: cli.id,
+      when: cli.when || '',
+      check: cli.check || '',
+      install: cli.install,
+      areas: areaKey ? [areaKey] : [],
+    });
+  };
+
+  for (const area of chosen) {
+    for (const cli of (areas[area] && areas[area].clis) || []) add(cli, area);
+  }
+  // Cross-cutting tools are offered regardless of area selection.
+  for (const cli of (registry && registry.cli_utility) || []) add(cli, null);
+
+  return [...byId.values()];
+}
+
+/**
+ * The copy-pasteable install command for a CLI entry — used to recommend the
+ * tools the user chose NOT to install (nothing is lost; they run it later).
+ * @param {{install?: string}} cli - Resolved CLI entry
+ * @returns {string} The install command, or '' if none.
+ */
+function renderInstallCommand(cli) {
+  return (cli && cli.install) || '';
+}
+
+/**
+ * Annotate each CLI with `installed: boolean` by running its `check` command.
+ * Immutable: returns new objects, never mutates the input. An entry without a
+ * `check` cannot be verified, so it is reported as not installed (we offer it
+ * rather than silently assume it is present).
+ *
+ * @param {Array<Object>} clis - Resolved CLI entries
+ * @param {Function} [exec] - Injected runner (command, opts) => {ok,...}
+ * @returns {Promise<Array<Object>>} Copies with an added `installed` flag.
+ */
+async function detectClis(clis, exec = defaultExec) {
+  return Promise.all(
+    (clis || []).map(async (cli) => {
+      if (!cli.check) return { ...cli, installed: false };
+      const res = await exec(cli.check, { timeoutMs: 5000 });
+      return { ...cli, installed: !!res.ok };
+    }),
+  );
+}
+
+/**
+ * Run the install command for each CLI, collecting outcomes. Never throws:
+ * a failed install (network, EACCES, missing command) lands in `failed` with
+ * its error so the caller can warn and continue the broader install.
+ *
+ * @param {Object} args
+ * @param {Array<{id: string, install?: string}>} args.clis - Entries to install
+ * @param {Function} [args.exec] - Injected runner (command, opts) => {ok,...}
+ * @returns {Promise<{installed: string[], failed: Array<{id: string, error: string}>}>}
+ */
+async function installClis({ clis, exec = defaultExec }) {
+  const installed = [];
+  const failed = [];
+  for (const cli of clis || []) {
+    if (!cli.install) {
+      failed.push({ id: cli.id, error: 'sem comando de instalação no registry' });
+      continue;
+    }
+    const res = await exec(cli.install, { timeoutMs: 300_000 });
+    if (res.ok) installed.push(cli.id);
+    else failed.push({ id: cli.id, error: (res.stderr || 'falha desconhecida').trim() });
+  }
+  return { installed, failed };
+}
+
+module.exports = { resolveClis, renderInstallCommand, detectClis, installClis, defaultExec };

package/tools/installer/modules/custom-module-manager.js

@@ -354,7 +354,7 @@ class CustomModuleManager {
    * @returns {string} Path to the custom modules cache directory
    */
   getCacheDir() {
-    return path.join(os.homedir(), '.bmad', 'cache', 'custom-modules');
+    return path.join(os.homedir(), '.wizz', 'cache', 'custom-modules');
   }
 
   /**
@@ -390,11 +390,11 @@ class CustomModuleManager {
     };
 
     // If an existing cache exists but was cloned at a different version, re-clone.
-    // Tracked via .bmad-source.json's recorded version.
+    // Tracked via .wizz-source.json's recorded version.
     if (await fs.pathExists(repoCacheDir)) {
       let cachedVersion = null;
       try {
-        const existing = await fs.readJson(path.join(repoCacheDir, '.bmad-source.json'));
+        const existing = await fs.readJson(path.join(repoCacheDir, '.wizz-source.json'));
         cachedVersion = existing?.version || null;
       } catch {
         // no metadata; treat as mismatched to be safe if a version was requested
@@ -511,7 +511,7 @@ class CustomModuleManager {
       } catch {
         // Fallback to previous marker value when symbolic ref is unavailable.
         try {
-          const existingMarker = await fs.readJson(path.join(repoCacheDir, '.bmad-channel.json'));
+          const existingMarker = await fs.readJson(path.join(repoCacheDir, '.wizz-channel.json'));
           if (existingMarker?.channel === 'next' && typeof existingMarker.version === 'string' && existingMarker.version.trim()) {
             defaultRef = existingMarker.version.trim();
           }
@@ -522,7 +522,7 @@ class CustomModuleManager {
     }
 
     // Write source metadata for later URL reconstruction
-    const metadataPath = path.join(repoCacheDir, '.bmad-source.json');
+    const metadataPath = path.join(repoCacheDir, '.wizz-source.json');
     await fs.writeJson(metadataPath, {
       cloneUrl: parsed.cloneUrl,
       cacheKey: parsed.cacheKey,
@@ -535,7 +535,7 @@ class CustomModuleManager {
     // Keep a channel marker in custom cache too so update paths that rely on
     // channel metadata (same as official-module cache) can treat this clone as
     // refreshable. URL + no explicit ref => next, explicit ref => pinned.
-    await fs.writeJson(path.join(repoCacheDir, '.bmad-channel.json'), {
+    await fs.writeJson(path.join(repoCacheDir, '.wizz-channel.json'), {
       channel: effectiveVersion ? 'pinned' : 'next',
       version: effectiveVersion || defaultRef,
       sha: resolvedSha,
@@ -584,7 +584,7 @@ class CustomModuleManager {
     let cloneMetadata = null;
     if (sourceUrl) {
       try {
-        cloneMetadata = await fs.readJson(path.join(repoPath, '.bmad-source.json'));
+        cloneMetadata = await fs.readJson(path.join(repoPath, '.wizz-source.json'));
       } catch {
         // no metadata — local-source or legacy cache
       }
@@ -708,7 +708,7 @@ class CustomModuleManager {
         // Quick-update path: refresh URL-backed cached repos before reading
         // files from them so re-deploy uses latest commits for `next` and
         // the pinned ref for `pinned`.
-        if (options.bmadDir && metadata?.rawInput) {
+        if (options.wizzDir && metadata?.rawInput) {
           await this._refreshRepoCacheOnce(repoPath, metadata);
         }
 
@@ -766,7 +766,7 @@ class CustomModuleManager {
    * Refresh one cached repo at most once per process with in-flight dedupe.
    * Prevents concurrent quick-update callers from racing the same cache path.
    * @param {string} repoPath - Absolute cache repo path
-   * @param {Object} metadata - Parsed .bmad-source.json metadata
+   * @param {Object} metadata - Parsed .wizz-source.json metadata
    */
   async _refreshRepoCacheOnce(repoPath, metadata) {
     if (CustomModuleManager._refreshedRepoPaths.has(repoPath)) return;
@@ -806,7 +806,7 @@ class CustomModuleManager {
    * Used as fallback when the module was installed from a local source (no cache entry).
    * Returns the path only if it still exists on disk; never removes installed files.
    * @param {string} moduleCode - Module code to search for
-   * @param {Object} [options] - Options (must include bmadDir or will search common locations)
+   * @param {Object} [options] - Options (must include wizzDir or will search common locations)
    * @returns {string|null} Path to the local module source or null
    */
   async _findLocalSourceFromManifest(moduleCode, options = {}) {
@@ -814,11 +814,11 @@ class CustomModuleManager {
       const { Manifest } = require('../core/manifest');
       const manifestObj = new Manifest();
 
-      // Try to find bmadDir from options or common locations
-      const bmadDir = options.bmadDir;
-      if (!bmadDir) return null;
+      // Try to find wizzDir from options or common locations
+      const wizzDir = options.wizzDir;
+      if (!wizzDir) return null;
 
-      const manifestData = await manifestObj.read(bmadDir);
+      const manifestData = await manifestObj.read(wizzDir);
       if (!manifestData?.modulesDetailed) return null;
 
       const moduleEntry = manifestData.modulesDetailed.find((m) => m.name === moduleCode);
@@ -837,7 +837,7 @@ class CustomModuleManager {
 
   /**
    * Recursively find repo root directories within the cache.
-   * A repo root is identified by containing .bmad-source.json (new) or .claude-plugin/ (legacy).
+   * A repo root is identified by containing .wizz-source.json (new) or .claude-plugin/ (legacy).
    * Handles both 3-level (host/owner/repo) and legacy 2-level (owner/repo) cache layouts.
    * @param {string} dir - Directory to search
    * @param {number} [depth=0] - Current recursion depth
@@ -848,7 +848,7 @@ class CustomModuleManager {
     const results = [];
 
     // Check if this directory is a repo root
-    const metadataPath = path.join(dir, '.bmad-source.json');
+    const metadataPath = path.join(dir, '.wizz-source.json');
     const claudePluginDir = path.join(dir, '.claude-plugin');
 
     if (await fs.pathExists(metadataPath)) {