wizz-method 1.16.1 → 1.18.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[]` (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/tools/installer/modules/skills-lib.js

@@ -29,7 +29,7 @@ const { resolveAreaEntries } = require('./registry-resolve');
 /**
  * Resolve which skill ids to install from the registry for the chosen areas.
  * Empty / undefined / containing 'all' means every area. Utility skills
- * (graphify, find-skills, ...) are cross-cutting and always included.
+ * (find-skills, wizz-router, ...) are cross-cutting and always included.
  *
  * Wrapper fino sobre `resolveAreaEntries` (A16): a resolução por área vive em
  * `registry-resolve.js`; aqui só sobra reduzir as entradas resolvidas ao
@@ -43,6 +43,12 @@ function resolveSkillIds(registry, selectedAreas) {
   const entries = resolveAreaEntries(registry, selectedAreas, {
     listKey: 'skills',
     utilityKey: 'utility',
+    // Uma entrada com `module:` vem de src/modules/<module>/skills/, não de
+    // src/skills-lib/ — ela é instalada junto do módulo. Sem este gate o
+    // installer procuraria src/skills-lib/<id>/SKILL.md, não acharia, e
+    // reportaria a skill como "skipped" em toda instalação. Ela continua no
+    // registry porque o router/maestro precisa enxergá-la para rotear.
+    isActionable: (raw) => !raw.module,
   });
   return entries.map((entry) => entry.id);
 }

package/wizz-modules.yaml

@@ -40,6 +40,23 @@
 # aliases (optional) — prior `code` values this module was registered under.
 # An existing install recorded under an alias resolves to this entry instead of
 # being orphaned as "no source available" when the code changes.
+#
+# ─────────────────────────────────────────────────────────────────────────────
+# NOT LISTED HERE: bundled local modules.
+# ─────────────────────────────────────────────────────────────────────────────
+# This file registers modules that live in ANOTHER repository and are fetched
+# at install time. Modules that ship inside this repo under src/modules/<code>/
+# are auto-discovered by the installer (OfficialModules.listAvailable scans
+# src/modules/ for a module.yaml) and must NOT get an entry here — an entry
+# without a real upstream `url` would break resolution.
+#
+# Bundled local modules today:
+#   wizz       src/modules/wizz/       default_selected: true
+#   lowticket  src/modules/lowticket/  default_selected: false
+#
+# Their installable skills are declared in skills-registry.yaml with a
+# `module:` field, which keeps the router aware of them while telling the
+# skills-lib copier to leave them alone (see tools/installer/modules/skills-lib.js).
 
 modules:
   bmad-method-test-architecture-enterprise:
@@ -81,12 +98,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/cerebro/references/comandos-pesquisa-e-sync.md

@@ -1,44 +0,0 @@
-# Comandos de Pesquisa e Sync: /prospect, /sync
-
-Carregue este arquivo ao executar `/prospect` ou `/sync`. Antes de tudo, releia a REGRA DE OURO e a seção Vault no SKILL.md principal — esses comandos dependem delas.
-
-## /prospect
-
-**Objetivo:** pesquisar e registrar prospect.
-
-**Passos:**
-1. Receber nome/empresa + objetivo (tudo de uma vez)
-2. Pesquisar via web search (setor, presença digital, dores, oportunidades)
-3. Write direto em `_prospects/YYYY-MM-DD-[slug].md`
-4. Resumo executivo para o usuário (não precisa estar no arquivo)
-
-**Template `_prospects/YYYY-MM-DD-[slug].md`:**
-```markdown
-# [Nome / Empresa]
-> Data: [data] | Objetivo: [tipo] | Status: pesquisado
-
-## Perfil
-- Setor / Tamanho / Produto / Público-alvo
-
-## Presença digital
-- Site / Redes / Ads ativos
-
-## Oportunidade e ângulo de abordagem
-[o que oferecer e como entrar]
-
-## Próximo passo
-- [ ] [ação]
-```
-
-## /sync
-
-**Objetivo:** espelhar CONTEXT.md → vault após sessão no Codex.
-
-**Passos:**
-1. Read `CONTEXT.md` no diretório atual (arquivo pequeno — OK ler completo)
-2. `wc -l "$VAULT/projetos/$PROJ.md"` → tail Read das últimas 60 linhas
-3. Identificar diferenças em: estado atual, pendências, decisões
-4. Edit cirúrgico em `projetos/[nome].md` (só seções alteradas)
-5. `grep -n "Última sessão\|Pendente" "$VAULT/CEREBRO.md" | grep -i "$PROJ"` → Edit linha
-6. Append linha em `_index/sessions.md`
-7. Confirmar em 2 linhas

package/src/skills-lib/graphify/.graphify_version

@@ -1 +0,0 @@
-0.3.19