@spec-wave/cli 0.21.0 → 0.24.0

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/doctor.mjs

@@ -14,7 +14,7 @@ import {
 } from '../api/auth.mjs';
 import { getProjectSnapshot, listSubIssues } from '../api/github-graphql.mjs';
 import {
-  CONFIG_FILE, WORKFLOW_FILES, getProvider, DEFAULT_PROVIDER, STATUS_OPTIONS,
+  CONFIG_FILE, WORKFLOW_FILES, getProvider, DEFAULT_PROVIDER, AI_PROVIDERS, STATUS_OPTIONS,
   RETIRED_STAGES, ALL_LABELS, allLabelsFor, LABEL_NEEDS_HUMAN, MODEL_LABEL_PREFIX,
   DEFAULT_MAX_CRITIQUE_ATTEMPTS, STAGE_TRACKS, AI_ACTIONS, recommendedModelAliases,
   modelLabels,
@@ -679,8 +679,9 @@ async function checkAi(ctx) {
       `${Object.entries(aliases).map(([a, m]) => `${a}=${m}`).join(', ')}.`
     );
     // Slug da OpenRouter tem "/" (anthropic/claude-…); id da Anthropic, não.
+    // O critério é o BACKEND: `claude-oauth` fala com a mesma API do `anthropic`.
     const wrongShape = Object.entries(aliases).filter(([, m]) => (
-      provider.value === 'openrouter' ? !String(m).includes('/') : String(m).includes('/')
+      provider.backend === 'openrouter' ? !String(m).includes('/') : String(m).includes('/')
     ));
     if (wrongShape.length > 0) {
       status = 'warn';
@@ -700,7 +701,7 @@ async function checkAi(ctx) {
 
   // Saída estruturada da crítica: sem structured output confiável, a validação
   // do schema queima os retries antes de falhar.
-  if (provider.value === 'openrouter' && !fileAi.models?.critique) {
+  if (provider.backend === 'openrouter' && !fileAi.models?.critique) {
     status = 'warn';
     notes.push(
       `Saída estruturada da crítica: o provider é openrouter e \`ai.models.critique\` não está ` +
@@ -708,21 +709,27 @@ async function checkAi(ctx) {
       'e a crítica falha na primeira execução. Aponte `ai.models.critique` para um modelo com ' +
       'saída estruturada.'
     );
+  } else if (provider.backend === 'anthropic') {
+    // No backend anthropic quem garante o schema é o próprio Claude Code
+    // (`outputFormat: json_schema`), repetindo o turno até casar — não há
+    // tool call forçado nem `strict` de endpoint para reportar.
+    notes.push(
+      `Saída estruturada da crítica: json_schema do Claude Code (${provider.value}) ` +
+      '— o CLI repete o turno até a resposta casar com o schema.'
+    );
   } else {
     notes.push(
       `Saída estruturada da crítica: tool call forçado (${provider.value}) ` +
       `· strict=${supportsStrictSchema(critiqueModel) ? 'sim' : 'não'} neste modelo.`
     );
   }
-  // O backend anthropic não chama a API — sobe o Claude Code CLI como
-  // subprocesso, que não existe no runner dos workflows (só há setup-node).
-  if (provider.value === 'anthropic') {
-    problems.push(
-      'O provider `anthropic` NÃO roda nos GitHub Actions: ele sobe o Claude Code CLI como ' +
-      'subprocesso, ausente no runner. As Actions de spec/plan/decompose vão falhar. ' +
-      'Troque para `"provider": "openrouter"` no .spec-wave.json (e adicione o secret ' +
-      'OPENROUTER_API_KEY), ou instale o Claude Code no workflow e defina ' +
-      'SPEC_WAVE_ALLOW_ANTHROPIC_IN_CI=1. Localmente o anthropic funciona.'
+  // O backend anthropic sobe o Claude Code CLI como subprocesso — e o binário
+  // vem embarcado no SDK, então o runner não precisa de instalação extra.
+  if (provider.backend === 'anthropic') {
+    notes.push(
+      `Backend anthropic (${provider.value}): o Claude Code sobe como subprocesso a partir do ` +
+      'binário embarcado no @anthropic-ai/claude-agent-sdk — nada a instalar no runner além do ' +
+      'próprio CLI. Só falha se o pacote for instalado com `--omit=optional`.'
     );
   }
 
@@ -955,10 +962,19 @@ async function checkWorkflows(ctx) {
   // comportamento de pipelines já em andamento.
   const unpinned = [];
   const otherVersion = [];
+  // O secret do provider escolhido chega ao runner? A YAML é que decide: um
+  // repo configurado com um provider cujo secret o workflow não encaminha morre
+  // com "Faltam credenciais" no meio do fluxo, e o único conserto é `update`.
+  const provider = getProvider(ctx.cfg?.ai?.provider) || getProvider(DEFAULT_PROVIDER);
+  const missingSecret = [];
   for (const file of WORKFLOW_FILES) {
     const content = readFileSync(path.join(dir, file), 'utf-8');
     if (/@spec-wave\/cli@latest/.test(content)) unpinned.push(file);
     else if (!content.includes(`@spec-wave/cli@${CLI_VERSION}`)) otherVersion.push(file);
+    // Identifica os workflows de IA pelo que eles próprios declaram, em vez de
+    // manter uma segunda lista para sair de sincronia com WORKFLOW_FILES.
+    const usesAi = AI_PROVIDERS.some(pr => content.includes(`secrets.${pr.secret}`));
+    if (usesAi && !content.includes(`secrets.${provider.secret}`)) missingSecret.push(file);
   }
   const notes = [`Os ${WORKFLOW_FILES.length} workflows do spec-wave estão presentes.`];
   let status = 'ok';
@@ -976,6 +992,16 @@ async function checkWorkflows(ctx) {
       'para fazer o bump explícito.'
     );
   }
+  if (missingSecret.length > 0) {
+    status = 'fail';
+    notes.push(
+      `Não encaminham \`${provider.secret}\` (secret do provider ${provider.value}): ` +
+      `${missingSecret.join(', ')}. Esses workflows vão falhar com "Faltam credenciais" — ` +
+      'rode `npx @spec-wave/cli@latest update`.'
+    );
+  } else {
+    notes.push(`Todos encaminham \`${provider.secret}\` (provider ${provider.value}).`);
+  }
   return { name, status, detail: notes.join('\n') };
 }
 

package/src/commands/init.mjs

@@ -220,6 +220,11 @@ export async function init(options) {
       ? `  1. Commite o ${CONFIG_FILE} quando quiser (git add ${CONFIG_FILE} && git commit)\n`
       : '') +
     `  ${configWritten ? '2' : '1'}. Adicione ${providerMeta.secret} como secret no repositório (provider: ${providerMeta.label})\n` +
+    // O valor do token da assinatura não é copiável de lugar nenhum: só existe
+    // depois de rodar o comando que o gera.
+    (providerMeta.secret === 'CLAUDE_CODE_OAUTH_TOKEN'
+      ? `     ${chalk.dim('Gere o valor com: claude setup-token')}\n`
+      : '') +
     `  ${configWritten ? '3' : '2'}. Configure o board view para agrupar por "Etapa"\n` +
     `  ${configWritten ? '4' : '3'}. Crie uma Feature com o prefixo [FEATURE] no título\n` +
     `  ${configWritten ? '5' : '4'}. Use a skill spec-wave para guiar o fluxo\n\n` +

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\`).`);

package/src/commands/order.mjs

@@ -1,24 +1,176 @@
-// Ordena as Stories de uma Feature pelas dependências (topológica, Kahn —
+// Ordena as Stories pelas dependências (topológica, Kahn —
 // ver orderStories em src/lib/dependencies.mjs). As dependências vêm de duas
 // fontes, mescladas: a linha "Depende de: #N" no corpo da Story e a relação
 // nativa blocked_by do GitHub.
 //
+// Dependência para FORA da Feature não entra na ordenação (não há como saber
+// onde a Story de outra Feature entra nesta sequência), mas é EXIBIDA: era lida,
+// descartada em silêncio por orderStories e ignorada de novo no aviso de
+// fora-de-ordem. Quem montava o mapa de trabalho de dois devs tinha que
+// reconstruir isso à mão, lendo os decomposition.md.
+//
+// Dois escopos: `order <feature>` (uma Feature) e `order` sem argumento — o
+// mapa de TODAS as Features com trabalho no board, onde as dependências entre
+// Features deixam de ser "externas" e entram no mesmo grafo.
+//
 // Comando LOCAL — rodado pelo dev no terminal. owner/repo vêm da env
 // GITHUB_REPOSITORY quando existir, senão do .spec-wave.json (gravado pelo init).
 import * as p from '@clack/prompts';
 import chalk from 'chalk';
 import { resolveToken } from '../api/auth.mjs';
 import { getIssue, listBlockedBy } from '../api/github-rest.mjs';
-import { addProjectItem, listSubIssues, getItemSingleSelectValue } from '../api/github-graphql.mjs';
+import {
+  addProjectItem, listSubIssues, getItemSingleSelectValue, listProjectItems,
+} from '../api/github-graphql.mjs';
 import { detectIssueType } from '../lib/issue-type.mjs';
 import { parseDependencies, orderStories } from '../lib/dependencies.mjs';
-import { loadProjectConfig, resolveField } from '../lib/board.mjs';
+import {
+  loadProjectConfig, resolveField, indexBoardItems, selectOpenFeatures,
+} from '../lib/board.mjs';
 import { resolveRepoContext } from '../lib/project-root.mjs';
 import { CONFIG_FILE, STAGE_ORDER, STAGE_DEVELOPMENT, STAGE_DONE } from '../config.mjs';
 
-export async function order({ feature: featureArg }) {
+/**
+ * Rótulo curto de uma Feature para a coluna do mapa (função PURA).
+ */
+export function featureLabel(feature) {
+  const titulo = String(feature?.title || '').replace(/^\s*\[FEATURE\]\s*/i, '').trim();
+  const curto = titulo.length > 28 ? `${titulo.slice(0, 27)}…` : titulo;
+  return `#${feature?.number} ${curto}`.trim();
+}
+
+/**
+ * O mapa de execução de várias Features (função PURA).
+ *
+ * Uma ordem SÓ, não uma lista por Feature: é isso que responde "o que os dois
+ * devs pegam agora" — a pergunta que obrigava a abrir nove decomposition.md e
+ * reconstruir o grafo à mão. A coluna da Feature vem junto porque, num grafo de
+ * várias, saber a que Feature cada Story pertence é metade da informação.
+ *
+ * @param {object} params
+ * @param {number[]} params.sorted ordem topológica (números de Story)
+ * @param {Map<number, {title:string, dependsOn:number[]}>} params.byNumber
+ * @param {Map<number, object>} params.featureOf Story → Feature dona
+ * @param {Map<number, string|null>} params.stageOf Story → Etapa
+ * @returns {string}
+ */
+export function renderBoardOrder({ sorted, byNumber, featureOf, stageOf }) {
+  return (sorted || []).map((n, i) => {
+    const s = byNumber.get(n);
+    const etapa = stageOf.get(n) || '—';
+    const deps = (s?.dependsOn || []).filter(d => byNumber.has(d));
+    const dep = deps.length > 0 ? `  ← depende de ${deps.map(d => `#${d}`).join(', ')}` : '';
+    return `${String(i + 1).padStart(2)}. #${n} ${s?.title || ''}\n` +
+      `    ${featureLabel(featureOf.get(n))} · Etapa: ${etapa}${dep}`;
+  }).join('\n');
+}
+
+/**
+ * `spec-wave order` sem argumento: o grafo de TODAS as Features com trabalho.
+ *
+ * Fonte do conjunto é o BOARD, não os arquivos — `decomposition.md` registra o
+ * que foi proposto, a issue é o que existe. Uma query paginada de itens do
+ * project resolve Etapa e tipo de todo mundo de uma vez, no lugar do laço de
+ * duas chamadas por Story que o modo de uma Feature ainda usa.
+ */
+async function orderBoard({ token, owner, repo }) {
+  const { project, error: projectError } = loadProjectConfig();
+  if (projectError) {
+    p.log.error(
+      `${projectError} — sem board não há como saber quais Features têm trabalho. ` +
+      'Use `spec-wave order <feature>` para ordenar uma Feature específica.'
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  let itens;
+  try {
+    itens = await listProjectItems(token, project.id);
+  } catch (err) {
+    p.log.error(`Não foi possível ler os itens do Project: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  const indice = indexBoardItems(itens);
+  const features = selectOpenFeatures(itens);
+  if (features.length === 0) {
+    p.log.info(`Nenhuma Feature aberta fora de "${STAGE_DONE}" no board — nada a ordenar.`);
+    p.outro('Nada a fazer.');
+    return;
+  }
+
+  const enriched = [];
+  const featureOf = new Map();
+  const stageOf = new Map();
+  const semStories = [];
+  for (const feature of features) {
+    const subs = await listSubIssues(token, feature.nodeId).catch(() => []);
+    const stories = subs.filter(sub =>
+      detectIssueType({ title: sub.title, labels: sub.labels }) === 'Story');
+    if (stories.length === 0) { semStories.push(feature); continue; }
+    for (const story of stories) {
+      // Story concluída não entra: o mapa é do que falta fazer.
+      if (indice.get(story.number)?.fields?.Etapa === STAGE_DONE) continue;
+      const fromBody = parseDependencies(story.body);
+      const fromBlockedBy = (await listBlockedBy(token, owner, repo, story.number).catch(() => []))
+        .map(b => b.number);
+      enriched.push({
+        number: story.number,
+        title: story.title,
+        dependsOn: [...new Set([...fromBody, ...fromBlockedBy])],
+      });
+      featureOf.set(story.number, feature);
+      stageOf.set(story.number, indice.get(story.number)?.fields?.Etapa || null);
+    }
+  }
+
+  if (enriched.length === 0) {
+    p.log.info(`${features.length} Feature(s) aberta(s), nenhuma com Story pendente.`);
+    p.outro('Nada a fazer.');
+    return;
+  }
+
+  const byNumber = new Map(enriched.map(s => [s.number, s]));
+  const { order: sorted, cycle, external } = orderStories(
+    enriched.map(({ number, dependsOn }) => ({ number, dependsOn })));
+
+  if (cycle.length > 0) {
+    p.log.warn(
+      chalk.yellow.bold('⚠ CICLO DE DEPENDÊNCIAS detectado!') + '\n' +
+      `Stories envolvidas (ou bloqueadas pelo ciclo): ${cycle.map(n => `#${n}`).join(', ')}.\n` +
+      'Elas ficaram fora da ordem abaixo. Num grafo de várias Features o ciclo pode ' +
+      'ATRAVESSAR a fronteira delas — confira as linhas "Depende de" dos dois lados.'
+    );
+  }
+
+  p.note(
+    renderBoardOrder({ sorted, byNumber, featureOf, stageOf }),
+    `Ordem de execução — ${sorted.length} Story(ies) de ${features.length} Feature(s)`
+  );
+
+  // Aqui "fora do conjunto" não é mais "de outra Feature" (essas agora estão
+  // DENTRO): é Story já concluída, Feature em Done ou issue de outro board.
+  if (external.size > 0) {
+    const linhas = [...external.entries()].map(([n, deps]) =>
+      `  #${n} ← ${deps.map(d => `#${d}`).join(', ')}`);
+    p.note(
+      linhas.join('\n'),
+      'Dependências fora do conjunto (concluídas, de Feature em Done ou de outro board)'
+    );
+  }
+
+  if (semStories.length > 0) {
+    p.log.info(`Sem Stories (ainda não decompostas): ${semStories.map(f => `#${f.number}`).join(', ')}.`);
+  }
+  p.outro(`${chalk.green('✓')} ${sorted.length} de ${enriched.length} story(ies) ordenada(s).`);
+}
+
+export async function order({ feature: featureArg } = {}) {
+  const semArgumento = featureArg === undefined || featureArg === null
+    || String(featureArg).trim() === '';
   const featureNumber = parseInt(String(featureArg).replace('#', ''), 10);
-  if (!Number.isInteger(featureNumber) || featureNumber <= 0) {
+  if (!semArgumento && (!Number.isInteger(featureNumber) || featureNumber <= 0)) {
     p.log.error(`Feature inválida: "${featureArg}". Use o número da issue, ex.: 12 ou #12.`);
     process.exitCode = 1;
     return;
@@ -43,6 +195,11 @@ export async function order({ feature: featureArg }) {
     return;
   }
 
+  if (semArgumento) {
+    p.intro(chalk.bold('spec-wave order — todas as Features com trabalho'));
+    return await orderBoard({ token, owner, repo });
+  }
+
   p.intro(chalk.bold(`spec-wave order #${featureNumber}`));
 
   // 1. Lê a Feature e valida o tipo.
@@ -116,7 +273,19 @@ export async function order({ feature: featureArg }) {
 
   // 5. Ordenação topológica (nunca lança; ciclo vem em `cycle`).
   const byNumber = new Map(enriched.map(s => [s.number, s]));
-  const { order: sorted, cycle } = orderStories(enriched.map(({ number, dependsOn }) => ({ number, dependsOn })));
+  const { order: sorted, cycle, external } = orderStories(
+    enriched.map(({ number, dependsOn }) => ({ number, dependsOn })));
+
+  // Uma leitura por issue externa DISTINTA — o estado dela é o que diz se o
+  // bloqueio ainda vale.
+  const foraDoConjunto = [...new Set([...external.values()].flat())];
+  const externasInfo = new Map();
+  await Promise.all(foraDoConjunto.map(async (n) => {
+    const issue = await getIssue(token, owner, repo, n).catch(() => null);
+    externasInfo.set(n, issue
+      ? { title: issue.title, state: issue.state, aberta: issue.state === 'open' }
+      : { title: '(não foi possível ler)', state: null, aberta: true });
+  }));
 
   if (cycle.length > 0) {
     p.log.warn(
@@ -136,6 +305,18 @@ export async function order({ feature: featureArg }) {
   };
   p.note(sorted.map(line).join('\n'), `Ordem de execução das Stories da Feature #${featureNumber}`);
 
+  if (external.size > 0) {
+    const linhas = [...external.entries()].map(([n, deps]) => {
+      const detalhe = deps.map(d => {
+        const info = externasInfo.get(d);
+        const marca = info?.aberta ? chalk.yellow('aberta') : chalk.green('fechada');
+        return `#${d} (${marca}) ${info?.title || ''}`.trim();
+      }).join('\n      ');
+      return `  #${n} ${byNumber.get(n)?.title || ''}\n    ← ${detalhe}`;
+    });
+    p.note(linhas.join('\n'), 'Bloqueadas por fora desta Feature');
+  }
+
   // 6. Aviso final: dependente já em Desenvolvimento+ com dependência não-Done.
   const devIdx = STAGE_ORDER.indexOf(STAGE_DEVELOPMENT);
   const outOfOrder = [];
@@ -144,7 +325,19 @@ export async function order({ feature: featureArg }) {
     const idx = stage ? STAGE_ORDER.indexOf(stage) : -1;
     if (idx === -1 || idx < devIdx) continue; // ainda não chegou em Desenvolvimento
     for (const d of s.dependsOn) {
-      if (!byNumber.has(d)) continue; // dependência externa ao conjunto — sem Etapa conhecida
+      if (!byNumber.has(d)) {
+        // Externa: não tem Etapa neste conjunto, mas tem ESTADO — e uma issue
+        // aberta bloqueando quem já está em Desenvolvimento é a mesma falha que
+        // o aviso abaixo denuncia, só que atravessando a fronteira.
+        const info = externasInfo.get(d);
+        if (info?.aberta) {
+          outOfOrder.push(
+            `#${s.number} já está em "${stage}", mas depende de #${d}, de outra Feature, ` +
+            'que continua ABERTA.'
+          );
+        }
+        continue;
+      }
       const depStage = stageOf.get(d);
       if (depStage !== STAGE_DONE) {
         outOfOrder.push(