@spec-wave/cli 0.21.0 → 0.23.0

package/bin/spec-wave.mjs

@@ -263,8 +263,8 @@ program
 
 program
   .command('order')
-  .description('Ordena as Stories de uma Feature pelas dependências (topológica)')
-  .argument('<feature>', 'Número da issue da Feature, ex.: 12 ou #12')
+  .description('Ordena as Stories pelas dependências (topológica). Sem argumento, o mapa de todas as Features com trabalho')
+  .argument('[feature]', 'Número da issue da Feature, ex.: 12 ou #12. Omitido: todas as Features abertas fora de 🎉 Done')
   .action(async (feature) => {
     const { order } = await import('../src/commands/order.mjs');
     await order({ feature }).catch(err => { console.error(err.message); process.exit(1); });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spec-wave/cli",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "Setup spec-driven GitHub workflow with Projects v2, labels, issue templates, and AI-powered Actions",
   "type": "module",
   "bin": {

package/src/agent/anthropic-agent.mjs

@@ -25,7 +25,7 @@
 import path from 'node:path';
 import { withTrace, startObservation, updateSpan, endObservation } from './tracing.mjs';
 import { ENV_FILE_PATTERN } from './tools.mjs';
-import { summarizeToolCalls } from './errors.mjs';
+import { summarizeToolCalls, toolSignature } from './errors.mjs';
 import { TruncatedOutputError } from './errors.mjs';
 
 const DEFAULT_TOOLS = ['Read', 'Glob', 'Grep'];
@@ -72,6 +72,7 @@ export async function runAnthropicAgent(prompt, options) {
     // Simétrico ao backend openrouter: sem isto, um run que estoura o teto de
     // turnos não deixa registro do que o modelo esteve fazendo.
     toolCalls: [],
+    toolSignatures: [],
   };
   const quiet = options.quiet !== false;
 
@@ -159,6 +160,7 @@ export async function runAnthropicAgent(prompt, options) {
               }
 
               runResult.toolCalls.push(input.tool_name);
+              runResult.toolSignatures.push(toolSignature(input.tool_name, input.tool_input));
               if (options.verbose) {
                 console.log(`\n[Tool] ${input.tool_name}(${JSON.stringify(input.tool_input)})`);
               }

package/src/agent/errors.mjs

@@ -45,34 +45,80 @@ export class TruncatedOutputError extends Error {
   }
 }
 
+/**
+ * Assinatura de uma tool call: nome + ALVO (função PURA).
+ *
+ * `Read×59` não distingue "leu 59 arquivos diferentes" de "leu o mesmo arquivo
+ * 59 vezes", e essas duas situações pedem remédios opostos. O alvo é o que
+ * separa as duas, e é o único dado do input que entra aqui — nada de conteúdo.
+ */
+export function toolSignature(name, input) {
+  const alvo = input && typeof input === 'object'
+    ? input.file_path ?? input.path ?? input.pattern ?? input.query ?? input.command ?? null
+    : null;
+  return alvo ? `${name}:${String(alvo)}` : String(name);
+}
+
+/**
+ * O modelo estava EXPLORANDO (e não preso num loop)? (função PURA)
+ *
+ * Explorar = chamadas majoritariamente distintas: leu muitos arquivos, varreu
+ * muitos padrões e o orçamento acabou antes de escrever. Isso VARIA entre
+ * execuções — repetir a mesma requisição costuma passar. Loop degenerado é o
+ * contrário: a mesma chamada repetida, que repetir só encarece.
+ *
+ * Amostra pequena não sustenta nenhuma das duas conclusões, e o default é o
+ * conservador (não repetir).
+ */
+export function looksLikeExploration(signatures = []) {
+  if (!Array.isArray(signatures) || signatures.length < 4) return false;
+  const distintas = new Set(signatures).size;
+  return distintas / signatures.length >= 0.5;
+}
+
 // Teto de turnos esgotado: o modelo respondeu com tool calls em TODOS os turnos
-// e nunca produziu o documento. Como o truncamento acima, NÃO é transitório —
-// repetir a mesma requisição dá a mesma perambulação, só que mais cara.
+// e nunca produziu o documento.
+//
+// NÃO é uma falha só, são duas, e a distinção é o que decide se repetir vale:
+//
+//  • LOOP DEGENERADO (a mesma chamada de novo e de novo) é determinístico —
+//    repetir custou 55 minutos de Action num caso real: três tentativas de 25
+//    turnos (4min → 19min → 32min) para a mesma falha, que devia ter aparecido
+//    na primeira. Aqui não se repete: troca-se o modelo ou sobe-se o teto.
 //
-// Marcá-lo como transitório custou 55 minutos de Action num caso real: três
-// tentativas de 25 turnos (4min → 19min → 32min) para a mesma falha
-// determinística, que devia ter aparecido na primeira.
+//  • EXPLORAÇÃO (chamadas distintas: Read×59 em 59 arquivos, Glob×20) é
+//    VARIÂNCIA, não limite estrutural — o orçamento acabou antes de escrever.
+//    Tratar isso como determinístico mandava trocar de modelo por nada: em
+//    quatro ocorrências reais, três reaplicações da MESMA label no MESMO modelo
+//    passaram na segunda tentativa, uma delas depois de um run de 20min46s que
+//    uma repetição de ~2min teria evitado.
 export class MaxTurnsError extends Error {
-  constructor({ provider, model, turns, action, toolCalls = [] }) {
-    // O que o modelo ficou fazendo é a informação que decide o remédio: muitas
-    // leituras distintas sugerem teto baixo; a mesma chamada repetida é loop
-    // degenerado, e aí subir o teto só encarece.
+  constructor({ provider, model, turns, action, toolCalls = [], toolSignatures = [] }) {
     const resumo = toolCalls.length > 0
       ? ` Ferramentas mais chamadas: ${summarizeToolCalls(toolCalls)}.`
       : '';
+    const exploracao = looksLikeExploration(toolSignatures);
+    const remedio = exploracao
+      ? 'As chamadas são majoritariamente DISTINTAS — o modelo gastou o orçamento explorando, ' +
+        'o que varia entre execuções. Uma repetição costuma bastar (a CLI já faz UMA, ' +
+        'automaticamente); se insistir, suba `maxTurns` no prompt em vez de trocar o modelo.'
+      : 'As chamadas se REPETEM — é loop degenerado, e repetir reproduz a mesma perambulação ' +
+        'mais cara. Troque o modelo (por `ai.models` ou pela label ' +
+        '`spec-wave:model:<apelido>`) ou suba o teto de turnos.';
     super(
       `O modelo esgotou o teto de ${turns} turnos sem produzir o documento ` +
       `(${provider} · ${model}${action ? ` · ação=${action}` : ''}): respondeu com chamadas de ` +
-      `ferramenta em todos eles.${resumo} ` +
-      'Repetir não ajuda — o erro é determinístico. Ou o modelo não fecha o loop de ' +
-      'ferramentas nesta tarefa (troque-o, por `ai.models` ou pela label ' +
-      '`spec-wave:model:<apelido>`), ou a exploração precisa de mais turnos.'
+      `ferramenta em todos eles.${resumo} ${remedio}`
     );
     this.name = 'MaxTurnsError';
     this.maxTurns = true;
+    // Quem decide o retry (lib/claude.mjs) lê esta flag — a classificação mora
+    // aqui, junto dos dados que a sustentam.
+    this.exploration = exploracao;
     this.turns = turns;
     this.action = action || null;
     this.toolCalls = toolCalls;
+    this.toolSignatures = toolSignatures;
   }
 }
 

package/src/agent/openrouter-agent.mjs

@@ -22,7 +22,7 @@ import {
   toolDefinitionsFor,
 } from './tools.mjs';
 import { withTrace, startObservation, updateSpan, endObservation } from './tracing.mjs';
-import { TruncatedOutputError, isTruncationReason, summarizeToolCalls } from './errors.mjs';
+import { TruncatedOutputError, isTruncationReason, summarizeToolCalls, toolSignature } from './errors.mjs';
 
 const DEFAULT_BASE_URL = 'https://openrouter.ai/api/v1';
 const DEFAULT_TOOLS = ['Read', 'Glob', 'Grep'];
@@ -184,6 +184,7 @@ export async function runOpenRouterAgent(prompt, options) {
     // turnos sem escrever nada, o log não dizia no que ele se perdeu, e o
     // diagnóstico exigiu reconstruir o run à mão.
     toolCalls: [],
+    toolSignatures: [],
   };
   const quiet = options.quiet !== false;
 
@@ -333,6 +334,9 @@ export async function runOpenRouterAgent(prompt, options) {
             }
 
             runResult.toolCalls.push(call.function.name);
+            // Assinatura (nome + alvo) separa exploração de loop degenerado —
+            // é o que decide se o teto de turnos merece uma repetição.
+            runResult.toolSignatures.push(toolSignature(call.function.name, parsedInput));
             if (options.verbose) console.log(`\n[Tool] ${call.function.name}(${call.function.arguments})`);
 
             const observation = startObservation(

package/src/api/github-graphql.mjs

@@ -249,6 +249,69 @@ export function isAlreadyInProjectError(err) {
     || /content already exists/i.test(msg);
 }
 
+/**
+ * Todos os itens do Project, com os campos SINGLE_SELECT resolvidos por NOME.
+ *
+ * Uma query paginada no lugar de duas chamadas POR ITEM
+ * (`addProjectItem` + `getItemSingleSelectValue`), que é como o `order` lia a
+ * Etapa de cada Story. Com nove Features na tela isso passava de cem chamadas
+ * para montar um mapa que cabe em duas.
+ *
+ * Só itens cujo conteúdo é Issue entram (draft e PR ficam de fora).
+ *
+ * @returns {Promise<Array<{number, title, state, nodeId, itemId, fields: Record<string,string>}>>}
+ */
+export async function listProjectItems(token, projectId) {
+  const client = makeClient(token);
+  const itens = [];
+  let after = null;
+  do {
+    const result = await client(`
+      query ProjectItems($id: ID!, $after: String) {
+        node(id: $id) {
+          ... on ProjectV2 {
+            items(first: 100, after: $after) {
+              pageInfo { hasNextPage endCursor }
+              nodes {
+                id
+                fieldValues(first: 20) {
+                  nodes {
+                    ... on ProjectV2ItemFieldSingleSelectValue {
+                      name
+                      field { ... on ProjectV2SingleSelectField { name } }
+                    }
+                  }
+                }
+                content { ... on Issue { number title state id } }
+              }
+            }
+          }
+        }
+      }
+    `, { id: projectId, after });
+    const page = result.node?.items;
+    for (const node of page?.nodes || []) {
+      const issue = node?.content;
+      if (!issue?.number) continue;
+      const fields = {};
+      for (const fv of node.fieldValues?.nodes || []) {
+        const nome = fv?.field?.name;
+        if (nome && fv.name) fields[nome] = fv.name;
+      }
+      itens.push({
+        number: issue.number,
+        title: issue.title,
+        state: issue.state,
+        nodeId: issue.id,
+        itemId: node.id,
+        fields,
+      });
+    }
+    after = page?.pageInfo?.hasNextPage ? page.pageInfo.endCursor : null;
+  } while (after);
+  return itens;
+}
+
 // Cria a relação de sub-issue nativa do GitHub (parent → child). Ambos os IDs
 // são node ids de Issue. Faz com que o filho exiba o pai e vice-versa na UI.
 export async function addSubIssue(token, parentIssueId, childIssueId) {

package/src/api/github-rest.mjs

@@ -281,9 +281,16 @@ export async function ensurePullRequest(
 
 // `id` é o database id da issue — exigido pela API de dependências
 // (blocked_by), que não aceita number nem node id.
-export async function createIssue(token, owner, repo, title, body, labels) {
+//
+// `milestone` é o NÚMERO do milestone no repo (não o título nem o node id) e só
+// entra no payload quando existe: a API rejeita `milestone: null` com 422 em vez
+// de tratar como "sem milestone".
+export async function createIssue(token, owner, repo, title, body, labels, { milestone } = {}) {
   const octokit = makeOctokit(token);
-  const res = await octokit.rest.issues.create({ owner, repo, title, body, labels });
+  const res = await octokit.rest.issues.create({
+    owner, repo, title, body, labels,
+    ...(milestone ? { milestone } : {}),
+  });
   return { number: res.data.number, nodeId: res.data.node_id, url: res.data.html_url, id: res.data.id };
 }
 

package/src/commands/decompose.mjs

@@ -203,6 +203,25 @@ export function shouldSkipDecompose({ labels = [], subIssues = [], type } = {})
   return { skip: false, reason: '' };
 }
 
+/**
+ * Milestone que os filhos herdam do pai (função PURA — testável).
+ *
+ * Uma Story/Task nasce para entregar a Feature que a gerou: separá-las da release
+ * do pai faria a mesma entrega aparecer em dois grupos — e o milestone é o que o
+ * fluxo usa como release (é o milestone fechado que sinaliza o deploy). Mesma
+ * regra que a reprovação de QA já aplica ao registrar um bug filho.
+ *
+ * Devolve o NÚMERO (o que `createIssue` aceita) ou `undefined` quando o pai não
+ * tem milestone — aí não há release a herdar, e o filho nasce sem, como antes.
+ *
+ * @param {{ milestone?: { number?: number, title?: string } | null }} [issue]
+ * @returns {number|undefined}
+ */
+export function resolveInheritedMilestone(issue) {
+  const number = issue?.milestone?.number;
+  return Number.isInteger(number) && number > 0 ? number : undefined;
+}
+
 // Diretório do documento por tipo. Feature usa o mesmo docs/features/<slug> da
 // spec/plan; RFC ganha o seu, já que não passa por spec/plan.
 function resolveDocDir(root, issue, type) {
@@ -560,10 +579,59 @@ function failIfBoardIncomplete(failures) {
   throw err;
 }
 
+// Linha do comentário registrando o milestone herdado ('' quando não há).
+function milestoneLine(issue, milestone) {
+  if (!milestone) return '';
+  return `🏁 Milestone herdado do pai: **${issue.milestone?.title ?? `#${milestone}`}**.\n\n`;
+}
+
+/**
+ * Resolve as dependências externas do rascunho ANTES de criar qualquer issue.
+ *
+ * `#N` só entra no documento se a issue JÁ existe (fase 1 da proposta), e é
+ * aqui que isso é cobrado. Falhar cedo é a única opção honesta: descobrir no
+ * meio do laço que a #412 não existe deixaria metade das Stories criadas e a
+ * outra metade não — o estado que o apply inteiro foi desenhado para evitar.
+ *
+ * `addBlockedBy` exige o DATABASE id da bloqueadora (não aceita number nem node
+ * id), e é por isso que resolver custa uma leitura por issue distinta.
+ *
+ * @returns {Promise<Map<number, {number:number, id:number, title:string}>>}
+ */
+async function resolveExternalDeps({ token, owner, repo }, doc) {
+  const numeros = [...new Set(
+    (doc.stories || []).flatMap(s => s.dependsOnIssues || [])
+  )].sort((a, b) => a - b);
+  const resolvidas = new Map();
+  const faltando = [];
+  for (const n of numeros) {
+    try {
+      const issue = await getIssue(token, owner, repo, n);
+      resolvidas.set(n, { number: issue.number, id: issue.id, title: issue.title });
+    } catch (err) {
+      faltando.push(`#${n} (${err.status === 404 ? 'não existe' : err.message})`);
+    }
+  }
+  if (faltando.length > 0) {
+    throw new Error(
+      `o rascunho depende de issue(s) que não consegui ler: ${faltando.join(', ')}. ` +
+      'Em "**Depende de:**", `#N` precisa ser uma issue que JÁ existe — corrija o ' +
+      'decomposition.md (ou aplique antes a Feature que cria essa Story).'
+    );
+  }
+  return resolvidas;
+}
+
 async function createStoriesFromDoc(ctx, doc) {
   const { token, projectToken, owner, repo, issue, issueNumber, project, docRel } = ctx;
   const fields = { etapaField: ctx.etapaField, statusField: ctx.statusField, typeField: ctx.typeField };
   const featureNodeId = issue.node_id;
+  // Herdado uma vez e reusado por todas as Stories e Tasks deste apply.
+  const milestone = resolveInheritedMilestone(issue);
+  if (milestone) console.log(`Milestone herdado da ${ctx.type}: ${issue.milestone?.title ?? `#${milestone}`}.`);
+  // Antes da primeira criação: rascunho que aponta para issue inexistente é
+  // erro de escrita, e o lugar de reprovar é aqui.
+  const externas = await resolveExternalDeps(ctx, doc);
   const created = [];
   const createdStories = []; // issues criadas, na ordem dos índices das stories
   const generatedTexts = []; // títulos+corpos para o lint de idioma final
@@ -580,12 +648,17 @@ async function createStoriesFromDoc(ctx, doc) {
       .filter(Boolean)
       .join('\n\n') || '_(sem descrição)_';
 
-    // dependsOn já vem validado pelo parser (0-based, só para trás).
-    const depIssues = story.dependsOn.map(idx => createdStories[idx]).filter(Boolean);
+    // Irmãs (índices já validados pelo parser, sempre para trás) + externas (já
+    // resolvidas acima). As duas viram a MESMA linha no corpo e a mesma relação
+    // blocked_by: para quem lê a issue, a fronteira da Feature não existe.
+    const depIssues = [
+      ...story.dependsOn.map(idx => createdStories[idx]),
+      ...(story.dependsOnIssues || []).map(n => externas.get(n)),
+    ].filter(Boolean);
     const depLine = formatDependencyLine(depIssues.map(d => d.number));
     if (depLine) storyBody += `\n\n${depLine}`;
 
-    const createdStory = await createIssue(token, owner, repo, storyTitle, storyBody, ['[STORY]']);
+    const createdStory = await createIssue(token, owner, repo, storyTitle, storyBody, ['[STORY]'], { milestone });
     ctx.createdItems.push(createdStory.number);
     // Anota no doc em memória: é daqui que sai o `**Issue:** #N` gravado no
     // arquivo no fim do apply.
@@ -619,7 +692,7 @@ async function createStoriesFromDoc(ctx, doc) {
       console.log(`  Criando task: ${task.title}`);
       const taskTitle = `[TASK] ${task.title}`;
       const taskBody = `${task.body}\n\n_Story pai: ${createdStory.url}_`;
-      const createdTask = await createIssue(token, owner, repo, taskTitle, taskBody, ['[TASK]']);
+      const createdTask = await createIssue(token, owner, repo, taskTitle, taskBody, ['[TASK]'], { milestone });
       ctx.createdItems.push(createdTask.number);
       task.issue = createdTask.number;
       generatedTexts.push(taskTitle, taskBody);
@@ -652,6 +725,7 @@ async function createStoriesFromDoc(ctx, doc) {
   await commentOnIssue(token, owner, repo, parseInt(issueNumber, 10),
     `🔀 **Decomposição aplicada!**\n\n` +
     `A partir de \`${docRel}\` foram criados ${created.length} stories e suas tasks:\n\n${list}\n\n` +
+    milestoneLine(issue, milestone) +
     posicionamento +
     formatItemsLintWarning(generatedTexts)
   ).catch(err => console.warn(`Falha ao comentar a decomposição: ${err.message}`));
@@ -710,6 +784,8 @@ async function createTasksFromDoc(ctx, doc) {
   const { token, projectToken, owner, repo, issue, issueNumber, project, docRel } = ctx;
   const fields = { etapaField: ctx.etapaField, statusField: ctx.statusField, typeField: ctx.typeField };
   const parentNodeId = issue.node_id;
+  const milestone = resolveInheritedMilestone(issue);
+  if (milestone) console.log(`Milestone herdado do RFC: ${issue.milestone?.title ?? `#${milestone}`}.`);
   const created = [];
   const generatedTexts = [];
   const boardFailures = [];
@@ -718,7 +794,7 @@ async function createTasksFromDoc(ctx, doc) {
     console.log(`Criando task: ${task.title}`);
     const taskTitle = `[TASK] ${task.title}`;
     const taskBody = `${task.body}\n\n_RFC pai: ${issue.html_url || `#${issueNumber}`}_`;
-    const createdTask = await createIssue(token, owner, repo, taskTitle, taskBody, ['[TASK]']);
+    const createdTask = await createIssue(token, owner, repo, taskTitle, taskBody, ['[TASK]'], { milestone });
     ctx.createdItems.push(createdTask.number);
     task.issue = createdTask.number;
     created.push({ title: taskTitle, url: createdTask.url });
@@ -744,6 +820,7 @@ async function createTasksFromDoc(ctx, doc) {
   await commentOnIssue(token, owner, repo, parseInt(issueNumber, 10),
     `🔀 **Decomposição do RFC aplicada!**\n\n` +
     `A partir de \`${docRel}\` foram criadas ${created.length} tasks:\n\n${list}\n\n` +
+    milestoneLine(issue, milestone) +
     posicionamento +
     formatItemsLintWarning(generatedTexts)
   ).catch(err => console.warn(`Falha ao comentar a decomposição: ${err.message}`));

package/src/commands/move.mjs

@@ -21,6 +21,8 @@ import { loadConfig } from '../lib/project-root.mjs';
 import {
   CONFIG_FILE, PROGRESS_TODO, PROGRESS_IN_PROGRESS, PROGRESS_DONE,
   isManualStageType, MANUAL_STAGE_TYPES, isStageInTrack, STAGE_TRACKS,
+  STAGE_READY, LABEL_PLAN_APPROVED, LABEL_SPEC, LABEL_PLAN, LABEL_CRITIQUE_FAILED,
+  LABEL_NEEDS_HUMAN, allowsSpecPlan, labelNames,
 } from '../config.mjs';
 
 const PROGRESS_VALUES = [PROGRESS_TODO, PROGRESS_IN_PROGRESS, PROGRESS_DONE];
@@ -49,6 +51,51 @@ export function resolveProgressName(input) {
       };
 }
 
+/**
+ * O que o board sabe e quem move à mão pode não saber (função PURA).
+ *
+ * `advanceToStage` já protege a ORDEM das etapas ("a Etapa nunca retrocede"),
+ * mas nada olhava os PORTÕES: mover uma Feature para ✅ Ready sem
+ * `spec-wave:plan-approved` põe na fila do time um item cuja validação não
+ * passou — e com `spec-wave:spec` ainda na issue, que é o rastro de uma reprova
+ * recente. Foi o que aconteceu com a #43.
+ *
+ * AVISA, não bloqueia: a decisão pode ser deliberada (documentos corrigidos à
+ * mão, validação que não se quer rodar de novo), e o comando existe justamente
+ * para os casos que o fluxo não cobre. O que não pode é ser silencioso.
+ *
+ * @param {object} params
+ * @param {string|null} params.type tipo do work item
+ * @param {string} params.stage etapa de destino
+ * @param {Array<string|{name:string}>} [params.labels] labels da issue
+ * @returns {string[]} avisos, na ordem de gravidade
+ */
+export function readinessWarnings({ type, stage, labels = [] } = {}) {
+  if (stage !== STAGE_READY) return [];
+  const nomes = labelNames(labels);
+  const avisos = [];
+
+  // Bug, RFC e Spike não passam por spec/plan — cobrar plan-approved deles
+  // seria inventar um portão que o fluxo não tem.
+  if (allowsSpecPlan(type) && !nomes.includes(LABEL_PLAN_APPROVED)) {
+    avisos.push(
+      `não tem \`${LABEL_PLAN_APPROVED}\`: spec+plan não passaram pelo \`validate\`. ` +
+      `Para validar, aplique \`spec-wave:ready\` na issue.`
+    );
+  }
+  for (const gatilho of [LABEL_SPEC, LABEL_PLAN]) {
+    if (nomes.includes(gatilho)) {
+      avisos.push(`ainda tem \`${gatilho}\` — há geração de documento pendente ou uma reprova recente.`);
+    }
+  }
+  for (const portao of [LABEL_CRITIQUE_FAILED, LABEL_NEEDS_HUMAN]) {
+    if (nomes.includes(portao)) {
+      avisos.push(`tem \`${portao}\` — a crítica reprovou e ninguém liberou.`);
+    }
+  }
+  return avisos;
+}
+
 export async function move({ issue: issueArg, stage: stageArg, status: statusArg }) {
   const issueNumber = parseInt(String(issueArg).replace('#', ''), 10);
   if (!Number.isInteger(issueNumber) || issueNumber <= 0) {
@@ -126,6 +173,11 @@ export async function move({ issue: issueArg, stage: stageArg, status: statusArg
     );
   }
 
+  // Portões do fluxo: aviso antes de escrever, com a issue já em mãos.
+  for (const aviso of readinessWarnings({ type, stage, labels: issue.labels })) {
+    p.log.warn(`#${issueNumber} ${aviso}`);
+  }
+
   const { project, error: projectError } = loadProjectConfig({ cwd: root || process.cwd() });
   if (projectError) {
     p.log.error(`${projectError} — board não atualizado. Rode \`spec-wave init\` (ou \`spec-wave refresh --config\`).`);