wizz-method 1.16.0 → 1.17.0

package/tools/installer/commands/trace-report.js

@@ -11,13 +11,137 @@
 
 const os = require('node:os');
 const path = require('node:path');
+const yaml = require('yaml');
 const fs = require('../fs-native');
 const prompts = require('../prompts');
+const { getProjectRoot } = require('../project-root');
 
 function getTraceFile() {
   return process.env.WIZZ_TRACE_FILE || path.join(os.homedir(), '.claude', 'wizz-trace.jsonl');
 }
 
+// `--coverage` (P2 da auditoria 360°, "evals de descoberta"): cruza o
+// catálogo de skills do skills-registry.yaml (fonte única, lido em runtime
+// e nunca hardcoded aqui) contra os marcadores de decisão (`type:
+// "decision"`, escritos por tools/hooks/wizz-decision-trace.js) já
+// agregados no mesmo JSONL. Mede subutilização de roteamento: uma skill
+// pode estar SELECIONADA (`sel`), DESCARTADA COM MOTIVO (`desc`, correto:
+// foi considerada e explicitamente preterida) ou NUNCA CONSIDERADA (não
+// aparece em nenhum dos dois arrays de nenhum trace): esta última é a
+// falha de roteamento silenciosa que o item da auditoria pede pra medir.
+function getRegistryFile() {
+  return path.join(getProjectRoot(), 'skills-registry.yaml');
+}
+
+// Lê e parseia skills-registry.yaml, devolvendo o catálogo de ids de
+// skills em ordem alfabética estável (mesma lista independente da ordem em
+// que as áreas/skills aparecem no YAML). Escopo deliberado: só as skills
+// `areas.*.skills[]` e as cross-cutting `utility[]` (graphify, find-skills,
+// enhance-prompt, wizz-router; também são skills de verdade em
+// src/skills-lib/). CLIs/MCPs/squads ficam de fora: `sel`/`desc` no
+// marcador de decisão podem citar agentes ou skills (ver encerramento.md),
+// mas este comando mede especificamente subutilização de SKILL, não de
+// ferramenta/squad. Lança em vez de devolver `null` em erro: quem chama
+// decide como reportar (fail-clear, não fail-silent: ao contrário do
+// trace, o catálogo é a fonte de verdade e um erro aqui é um bug real).
+function collectSkillCatalog(registryFile) {
+  const raw = fs.readFileSync(registryFile, 'utf8');
+  const registry = yaml.parse(raw);
+  const ids = new Set();
+  for (const area of Object.values(registry.areas || {})) {
+    for (const skill of area.skills || []) {
+      if (skill && typeof skill.id === 'string') ids.add(skill.id);
+    }
+  }
+  for (const item of registry.utility || []) {
+    if (item && typeof item.id === 'string') ids.add(item.id);
+  }
+  return [...ids].sort();
+}
+
+// Agrega os traces `type: "decision"` já parseados contra o catálogo.
+// Função pura (mesmo espírito de `aggregate`/`aggregateLadder`), testável
+// sem tocar em disco. `catalogIds` já deve vir ordenado (saída de
+// `collectSkillCatalog`): a ordem de `neverConsidered` deriva dela, então
+// a saída é estável entre execuções.
+//
+// Ids de `sel`/`desc` que não pertencem ao catálogo (ex.: agente
+// "wizz-designer" em vez de skill) são ignorados aqui, não contados como
+// erro: o marcador aceita os dois tipos (encerramento.md), este comando só
+// mede a fatia de skills.
+//
+// Categorização mutuamente exclusiva por skill (soma sempre = catalogTotal):
+// selecionada (apareceu em algum `sel`) > descartada-só (apareceu só em
+// `desc`, nunca em `sel`) > nunca considerada (nenhum dos dois). Se uma
+// skill foi selecionada numa decisão e descartada noutra, conta como
+// selecionada: "foi de fato usada ao menos uma vez" pesa mais que "também
+// foi preterida uma vez" para o proposito de subutilização.
+function aggregateCoverage(entries, catalogIds) {
+  const catalogSet = new Set(catalogIds);
+  const selected = new Set();
+  const discarded = new Set();
+  let decisionCount = 0;
+
+  for (const entry of entries) {
+    if (!entry || entry.type !== 'decision') continue;
+    const decision = entry.decision;
+    if (!decision || typeof decision !== 'object') continue;
+    decisionCount++;
+
+    if (Array.isArray(decision.sel)) {
+      for (const id of decision.sel) {
+        if (typeof id === 'string' && catalogSet.has(id)) selected.add(id);
+      }
+    }
+    if (Array.isArray(decision.desc)) {
+      for (const pair of decision.desc) {
+        if (Array.isArray(pair) && typeof pair[0] === 'string' && catalogSet.has(pair[0])) {
+          discarded.add(pair[0]);
+        }
+      }
+    }
+  }
+
+  const discardedOnly = [];
+  const neverConsidered = [];
+  for (const id of catalogIds) {
+    if (selected.has(id)) continue;
+    if (discarded.has(id)) discardedOnly.push(id);
+    else neverConsidered.push(id);
+  }
+
+  return {
+    catalogTotal: catalogIds.length,
+    decisionCount,
+    selectedCount: selected.size,
+    discardedOnlyCount: discardedOnly.length,
+    neverConsidered,
+  };
+}
+
+function formatCoverageSummary(stats, registryFile) {
+  const consideredCount = stats.catalogTotal - stats.neverConsidered.length;
+  const lines = [
+    `Catálogo:                ${stats.catalogTotal} skills (${registryFile})`,
+    `Traces de decisão:       ${stats.decisionCount}`,
+    `Selecionadas (sel):      ${stats.selectedCount} (${pct(stats.selectedCount, stats.catalogTotal)})`,
+    `Descartadas c/ motivo:   ${stats.discardedOnlyCount} (${pct(stats.discardedOnlyCount, stats.catalogTotal)})`,
+    `Nunca consideradas:      ${stats.neverConsidered.length} (${pct(stats.neverConsidered.length, stats.catalogTotal)})`,
+    `Cobertura do catálogo:   ${pct(consideredCount, stats.catalogTotal)}`,
+  ];
+
+  if (stats.decisionCount === 0) {
+    lines.push('', '(nenhum trace de decisão encontrado; rode com WIZZ_TRACE=1 e feche pedidos roteados pra gerar dados)');
+  } else if (stats.neverConsidered.length === 0) {
+    lines.push('', 'Nunca consideradas: nenhuma, catálogo 100% coberto.');
+  } else {
+    lines.push('', 'Nunca consideradas:');
+    for (const id of stats.neverConsidered) lines.push(`  ${id}`);
+  }
+
+  return lines.join('\n');
+}
+
 // Faz o parse de 1 linha JSONL. Retorna `null` (em vez de lançar) para
 // linhas corrompidas — fail-open, mesmo espírito do resto do framework: o
 // trace nunca pode quebrar quem o lê.
@@ -31,14 +155,24 @@ function parseLine(line) {
 
 // Agrega as entradas já parseadas em contadores/período. Função pura, sem
 // I/O, para ser testável isoladamente do disco.
+//
+// Linhas tipadas (`type: "decision"` do marcador 🧭 e `type: "ladder"` da
+// escada de modelos, ambas escritas por tools/hooks/wizz-decision-trace.js)
+// são IGNORADAS aqui: são outra granularidade de evento (o fecho de um
+// pedido, não o roteamento em si) e contá-las junto de trivial/mode poluiria
+// as contagens. `type: "ladder"` alimenta só `aggregateLadder`, abaixo.
 function aggregate(entries) {
   const byMode = { wizz: 0, flat: 0, null: 0 };
+  let total = 0;
   let trivialCount = 0;
   let warningsCount = 0;
   let firstTs = null;
   let lastTs = null;
 
   for (const entry of entries) {
+    if (entry.type === 'decision' || entry.type === 'ladder') continue;
+    total++;
+
     if (entry.isTrivial) {
       trivialCount++;
     } else {
@@ -54,9 +188,9 @@ function aggregate(entries) {
   }
 
   return {
-    total: entries.length,
+    total,
     trivialCount,
-    routedCount: entries.length - trivialCount,
+    routedCount: total - trivialCount,
     byMode,
     warningsCount,
     firstTs,
@@ -64,6 +198,53 @@ function aggregate(entries) {
   };
 }
 
+// Bucket de rota pra agregação da escada de modelos: agrupa qualquer
+// "agent:*" (designer, copy, seo, etc.) numa única chave — o que importa
+// pra aderência é "foi delegado a um agente de área", não qual área
+// especificamente. `maestro` e `flat` ficam como buckets próprios; qualquer
+// outro valor (ou ausência) cai em `outro`.
+function ladderBucket(rota) {
+  if (typeof rota !== 'string' || rota.length === 0) return 'outro';
+  if (rota.startsWith('agent:')) return 'agent:*';
+  if (rota === 'maestro') return 'maestro';
+  if (rota === 'flat') return 'flat';
+  return 'outro';
+}
+
+// Agrega as linhas `type: "ladder"` (uma por pedido roteado que fechou com
+// marcador de decisão — ver wizz-decision-trace.js) em aderência à escada
+// de modelos: quantos pedidos invocaram algum subagente wizz-exec-*,
+// quebrado por rota. Função pura, mesmo espírito de `aggregate`.
+function aggregateLadder(entries) {
+  const byRoute = {};
+
+  const bump = (bucket, invoked) => {
+    if (!byRoute[bucket]) byRoute[bucket] = { total: 0, withExec: 0 };
+    byRoute[bucket].total++;
+    if (invoked) byRoute[bucket].withExec++;
+  };
+
+  let total = 0;
+  let withExec = 0;
+
+  for (const entry of entries) {
+    if (!entry || entry.type !== 'ladder') continue;
+    total++;
+    const invoked = Array.isArray(entry.execs) && entry.execs.length > 0;
+    if (invoked) withExec++;
+    bump(ladderBucket(entry.rota), invoked);
+  }
+
+  return { total, withExec, byRoute };
+}
+
+// Percentual formatado, protegido contra divisão por zero (mostra "—" em
+// vez de NaN%/Infinity% quando o denominador é 0).
+function pct(part, total) {
+  if (!total) return '—';
+  return `${Math.round((part / total) * 100)}%`;
+}
+
 function formatSummary(stats, traceFile) {
   const lines = [
     `Arquivo:        ${traceFile}`,
@@ -82,10 +263,34 @@ function formatSummary(stats, traceFile) {
   return lines.join('\n');
 }
 
+// Ordem de exibição fixa das rotas na segunda caixa — independente da ordem
+// em que apareceram no arquivo, pra saída estável entre execuções.
+const ROUTE_DISPLAY_ORDER = ['agent:*', 'maestro', 'flat', 'outro'];
+
+function formatLadderSummary(ladderStats) {
+  const lines = [
+    `Pedidos roteados com dado de escada: ${ladderStats.total}`,
+    `Invocaram algum wizz-exec-*:         ${ladderStats.withExec} (${pct(ladderStats.withExec, ladderStats.total)})`,
+    'Por rota:',
+  ];
+
+  const routes = ROUTE_DISPLAY_ORDER.filter((route) => ladderStats.byRoute[route]);
+  if (routes.length === 0) {
+    lines.push('  (sem dados)');
+  } else {
+    for (const route of routes) {
+      const bucket = ladderStats.byRoute[route];
+      lines.push(`  ${route.padEnd(8)} ${bucket.withExec}/${bucket.total} (${pct(bucket.withExec, bucket.total)})`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
 module.exports = {
   command: 'trace-report',
   description: 'Resume o arquivo local de trace do roteamento (WIZZ_TRACE)',
-  options: [],
+  options: [['--coverage', 'Cruza o catálogo de skills do registry contra os traces: mede skills nunca consideradas no roteamento']],
   action: async (options) => {
     try {
       const traceFile = getTraceFile();
@@ -112,10 +317,37 @@ module.exports = {
         }
       }
 
+      // `--coverage` é um modo alternativo, não aditivo: troca as 2 caixas
+      // base (contagem trivial/mode e escada de modelos) por 1 caixa focada
+      // em subutilização de skills. Motivo: são leituras diferentes do mesmo
+      // JSONL (roteamento agregado vs catálogo x descoberta): misturar as
+      // 3 caixas por padrão poluiria a saída sem ganho pro caso de uso de
+      // cada flag.
+      if (options.coverage) {
+        const registryFile = getRegistryFile();
+        let catalogIds;
+        try {
+          catalogIds = collectSkillCatalog(registryFile);
+        } catch (error) {
+          await prompts.log.error(`Não foi possível ler o catálogo de skills: ${error.message}`);
+          await prompts.log.message(`Esperado em: ${registryFile}`);
+          process.exit(1);
+          return;
+        }
+
+        const coverageStats = aggregateCoverage(entries, catalogIds);
+        await prompts.box(formatCoverageSummary(coverageStats, registryFile), 'Cobertura do Catálogo de Skills');
+        process.exit(0);
+        return;
+      }
+
       const stats = { ...aggregate(entries), corruptedCount };
 
       await prompts.box(formatSummary(stats, traceFile), 'Wizz Trace Report');
 
+      const ladderStats = aggregateLadder(entries);
+      await prompts.box(formatLadderSummary(ladderStats), 'Aderência à Escada de Modelos');
+
       process.exit(0);
     } catch (error) {
       await prompts.log.error(`Trace report failed: ${error.message}`);
@@ -127,5 +359,17 @@ module.exports = {
   },
   // Exportado só para teste unitário direto da agregação, sem precisar
   // spawnar o processo pra cada caso de borda.
-  _internal: { aggregate, parseLine, formatSummary },
+  _internal: {
+    aggregate,
+    parseLine,
+    formatSummary,
+    aggregateLadder,
+    ladderBucket,
+    formatLadderSummary,
+    pct,
+    collectSkillCatalog,
+    aggregateCoverage,
+    formatCoverageSummary,
+    getRegistryFile,
+  },
 };

package/tools/installer/modules/official-modules.js

@@ -292,6 +292,11 @@ class OfficialModules {
    * @param {Object} options.logger - Logger instance for output
    */
   async install(moduleName, wizzDir, fileTrackingCallback = null, options = {}) {
+    // Aliases (ex.: bauto → bmad-loop) chegam crus via --modules e via
+    // moduleIds de instalações antigas; sem normalizar aqui, o cache de
+    // getPluginResolution, o targetPath e o manifest usariam o código legado.
+    moduleName = await this.externalModuleManager.resolveCanonicalCode(moduleName);
+
     // Check if this module has a plugin resolution (custom marketplace install)
     const { CustomModuleManager } = require('./custom-module-manager');
     const customMgr = new CustomModuleManager();

package/wizz-modules.yaml

@@ -81,12 +81,12 @@ modules:
     # .claude-plugin/marketplace.json via plugin resolver (ver external-manager).
     marketplace-plugin: true
     post-install-message: |
-      Wizz Loop installed. To finish setup, run the bmad-loop-setup skill
-      from your agent:
+      Wizz Loop installed. To finish setup, ask your agent to run the setup
+      skill (the command keeps the upstream name):
 
         > use the bmad-loop-setup skill
 
-      It installs the bmad-loop orchestrator tool and wires up the per-project
+      It installs the Wizz Loop orchestrator tool and wires up the per-project
       hooks and policy. The automation skills don't run until setup completes.
 
   bmad-creative-intelligence-suite:

package/src/skills-lib/taste-redesign/SKILL.md

@@ -1,42 +0,0 @@
----
-name: taste-redesign
-description: Upgrades existing websites and apps to premium quality. Audits current design, identifies generic AI patterns, and applies high-end design standards without breaking functionality. Works with any CSS framework or vanilla CSS. Use when the user asks to redesign, upgrade, or audit an existing site or app that looks generic or AI-generated, without rewriting it from scratch.
----
-
-# Redesign Skill
-
-## How This Works (first step)
-
-When applied to an existing project, follow this sequence:
-
-1. **Scan** — Read the codebase. Identify the framework, styling method (Tailwind, vanilla CSS, styled-components, etc.), and current design patterns.
-2. **Diagnose** — Load `references/design-audit.md` and run through the full checklist. List every generic pattern, weak point, and missing state you find.
-3. **Fix** — Load `references/upgrade-techniques.md` for high-impact replacements, then apply targeted upgrades working with the existing stack. Do not rewrite from scratch. Improve what's there. Follow the Fix Priority order below.
-
-## Fix Priority
-
-Apply changes in this order for maximum visual impact with minimum risk:
-
-1. **Font swap** — biggest instant improvement, lowest risk
-2. **Color palette cleanup** — remove clashing or oversaturated colors
-3. **Hover and active states** — makes the interface feel alive
-4. **Layout and spacing** — proper grid, max-width, consistent padding
-5. **Replace generic components** — swap cliche patterns for modern alternatives
-6. **Add loading, empty, and error states** — makes it feel finished
-7. **Polish typography scale and spacing** — the premium final touch
-
-## Rules
-
-- Work with the existing tech stack. Do not migrate frameworks or styling libraries.
-- Do not break existing functionality. Test after every change.
-- Before importing any new library, check the project's dependency file first.
-- If the project uses Tailwind, check the version (v3 vs v4) before modifying config.
-- If the project has no framework, use vanilla CSS.
-- Keep changes reviewable and focused. Small, targeted improvements over big rewrites.
-
-## Reference map — load each file when you reach that step
-
-- `references/design-audit.md` — the full audit checklist across 9 categories (Typography, Color and Surfaces, Layout, Interactivity and States, Content, Component Patterns, Iconography, Code Quality, Strategic Omissions). **Load during the Diagnose step.**
-- `references/upgrade-techniques.md` — high-impact techniques (Typography, Layout, Motion, Surface upgrades) to replace generic patterns found in the audit. **Load during the Fix step.**
-
-Zero content was cut when this skill was split — every audit item and technique above lives verbatim in its `references/` file.

package/src/skills-lib/taste-redesign/references/upgrade-techniques.md

@@ -1,31 +0,0 @@
-# Upgrade techniques
-
-Load this file during the Fix step, once the audit has identified which categories need work. High-impact techniques to replace generic patterns, grouped by Typography, Layout, Motion, and Surface upgrades.
-
-## Upgrade Techniques
-
-When upgrading a project, pull from these high-impact techniques to replace generic patterns:
-
-### Typography Upgrades
-- **Variable font animation.** Interpolate weight or width on scroll or hover for text that feels alive.
-- **Outlined-to-fill transitions.** Text starts as a stroke outline and fills with color on scroll entry or interaction.
-- **Text mask reveals.** Large typography acting as a window to video or animated imagery behind it.
-
-### Layout Upgrades
-- **Broken grid / asymmetry.** Elements that deliberately ignore column structure — overlapping, bleeding off-screen, or offset with calculated randomness.
-- **Whitespace maximization.** Aggressive use of negative space to force focus on a single element.
-- **Parallax card stacks.** Sections that stick and physically stack over each other during scroll.
-- **Split-screen scroll.** Two halves of the screen sliding in opposite directions.
-
-### Motion Upgrades
-- **Smooth scroll with inertia.** Decouple scrolling from browser defaults for a heavier, cinematic feel.
-- **Staggered entry.** Elements cascade in with slight delays, combining Y-axis translation with opacity fade. Never mount everything at once.
-- **Spring physics.** Replace linear easing with spring-based motion for a natural, weighty feel on all interactive elements.
-- **Scroll-driven reveals.** Content entering through expanding masks, wipes, or draw-on SVG paths tied to scroll progress.
-
-### Surface Upgrades
-- **True glassmorphism.** Go beyond `backdrop-filter: blur`. Add a 1px inner border and a subtle inner shadow to simulate edge refraction.
-- **Spotlight borders.** Card borders that illuminate dynamically under the cursor.
-- **Grain and noise overlays.** A fixed, pointer-events-none overlay with subtle noise to break digital flatness.
-- **Colored, tinted shadows.** Shadows that carry the hue of the background rather than using generic black.
-