@spec-wave/cli 0.5.10 → 0.6.0

package/package.json

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

package/src/commands/code-review.mjs

@@ -4,11 +4,14 @@ import { resolveToken } from '../api/auth.mjs';
 import { getIssue, getPR, commentOnIssue } from '../api/github-rest.mjs';
 import { addProjectItem, setItemSingleSelect, getSingleSelectField, getIssueParent, listSubIssues, getItemSingleSelectValue } from '../api/github-graphql.mjs';
 import { detectIssueType } from '../lib/issue-type.mjs';
-import { CONFIG_FILE, STATUS_OPTIONS, STAGE_ORDER, PROGRESS_TODO } from '../config.mjs';
+import { CONFIG_FILE, STATUS_OPTIONS, STAGE_ORDER, STAGE_DONE, PROGRESS_TODO, PROGRESS_DONE } from '../config.mjs';
 
-// Campo "Etapa" (custom) → "👀 Code Review". Campo "Status" (nativo) → "Todo".
+// Ao abrir o PR: Stories/Feature → Etapa "👀 Code Review" (Status "Todo");
+// Tasks → Etapa "🎉 Done" (Status "Done"), pois a implementação da task terminou.
 const CODE_REVIEW_STAGE = STATUS_OPTIONS.find(s => s.name.includes('Code Review'))?.name;
+const DONE_STAGE = STAGE_DONE;
 const TODO_STATUS = PROGRESS_TODO;
+const DONE_STATUS = PROGRESS_DONE;
 
 // Extrai números de issues referenciadas no corpo do PR (Closes #N, Fixes #N, #N solto).
 function extractIssueNumbers(body) {
@@ -54,66 +57,86 @@ async function resolveFeatureIssue(token, owner, repo, issueNumber) {
   return null;
 }
 
-// Coleta a "unidade de review" de uma issue referenciada no PR: a Feature
-// ancestral + a Story + as Tasks dessa Story — tudo anda junto com a Feature.
-// Retorna Map number -> { nodeId, title }.
+// Coleta a "unidade de review" de uma issue referenciada no PR, separando por
+// tipo porque cada um tem destino próprio: Tasks → Done, Stories → Code Review,
+// Feature → Code Review (só quando todas as Stories estiverem prontas). Retorna
+// { feature:{number,nodeId,title}|null, stories:Map, tasks:Map }.
 async function collectReviewUnit(token, owner, repo, issueNumber) {
-  const unit = new Map();
-  const add = (n, nodeId, title) => { if (n && nodeId && !unit.has(n)) unit.set(n, { nodeId, title }); };
+  const stories = new Map();
+  const tasks = new Map();
+  const addStory = (n, nodeId, title) => { if (n && nodeId && !stories.has(n)) stories.set(n, { nodeId, title }); };
+  const addTask = (n, nodeId, title) => { if (n && nodeId && !tasks.has(n)) tasks.set(n, { nodeId, title }); };
 
   let issue;
-  try { issue = await getIssue(token, owner, repo, issueNumber); } catch { return unit; }
+  try { issue = await getIssue(token, owner, repo, issueNumber); } catch { return { feature: null, stories, tasks }; }
   const type = detectIssueType(issue);
-  if (type !== 'Feature' && type !== 'Story' && type !== 'Task') return unit;
+  if (type !== 'Feature' && type !== 'Story' && type !== 'Task') return { feature: null, stories, tasks };
 
-  // Feature ancestral (ou a própria).
-  const feature = await resolveFeatureIssue(token, owner, repo, issueNumber);
-  if (feature) add(feature.number, feature.node_id, feature.title);
+  const featureIssue = await resolveFeatureIssue(token, owner, repo, issueNumber);
+  const feature = featureIssue
+    ? { number: featureIssue.number, nodeId: featureIssue.node_id, title: featureIssue.title }
+    : null;
 
   if (type === 'Feature') {
-    // Toda a subárvore da Feature: Stories + Tasks.
-    const stories = await listSubIssues(token, issue.node_id).catch(() => []);
-    for (const st of stories) {
-      add(st.number, st.nodeId, st.title);
-      const tasks = await listSubIssues(token, st.nodeId).catch(() => []);
-      for (const t of tasks) add(t.number, t.nodeId, t.title);
+    // Referência direta à Feature: toda a subárvore (Stories + Tasks).
+    const subs = await listSubIssues(token, issue.node_id).catch(() => []);
+    for (const st of subs) {
+      addStory(st.number, st.nodeId, st.title);
+      const tks = await listSubIssues(token, st.nodeId).catch(() => []);
+      for (const t of tks) addTask(t.number, t.nodeId, t.title);
     }
   } else if (type === 'Story') {
-    add(issue.number, issue.node_id, issue.title);
-    const tasks = await listSubIssues(token, issue.node_id).catch(() => []);
-    for (const t of tasks) add(t.number, t.nodeId, t.title);
+    addStory(issue.number, issue.node_id, issue.title);
+    const tks = await listSubIssues(token, issue.node_id).catch(() => []);
+    for (const t of tks) addTask(t.number, t.nodeId, t.title);
   } else { // Task → inclui a Story pai e as Tasks irmãs.
-    add(issue.number, issue.node_id, issue.title);
+    addTask(issue.number, issue.node_id, issue.title);
     const parent = await getIssueParent(token, issue.node_id).catch(() => null);
     if (parent && detectIssueType({ title: parent.title }) === 'Story') {
-      add(parent.number, parent.nodeId, parent.title);
-      const tasks = await listSubIssues(token, parent.nodeId).catch(() => []);
-      for (const t of tasks) add(t.number, t.nodeId, t.title);
+      addStory(parent.number, parent.nodeId, parent.title);
+      const tks = await listSubIssues(token, parent.nodeId).catch(() => []);
+      for (const t of tks) addTask(t.number, t.nodeId, t.title);
     }
   }
-  return unit;
+  return { feature, stories, tasks };
 }
 
-// Avança um item do board para a Etapa "👀 Code Review" e reinicia o Status
-// (nativo) para "Todo". Uma issue só AVANÇA: se já estiver em Code Review ou em
-// uma etapa posterior, não é tocada (retorna false). Retorna true se avançou.
-async function setCodeReview(token, project, etapaField, statusField, nodeId) {
+// A Feature só avança quando TODAS as suas Stories já estiverem em Code Review
+// (ou etapa posterior). readToken lê as issues; projToken opera no Project.
+async function allStoriesReadyForReview(readToken, projToken, project, etapaField, featureNodeId) {
+  if (!etapaField?.id) return true; // sem campo Etapa não há como checar — assume ok
+  const subs = await listSubIssues(readToken, featureNodeId).catch(() => []);
+  const stories = subs.filter(s => detectIssueType({ title: s.title }) === 'Story');
+  if (stories.length === 0) return true;
+  const tgtIdx = STAGE_ORDER.indexOf(CODE_REVIEW_STAGE);
+  for (const st of stories) {
+    const itemId = await addProjectItem(projToken, project.id, st.nodeId);
+    const current = await getItemSingleSelectValue(projToken, itemId, etapaField.id).catch(() => null);
+    const idx = current ? STAGE_ORDER.indexOf(current) : -1;
+    if (idx === -1 || idx < tgtIdx) return false; // há Story pendente
+  }
+  return true;
+}
+
+// Avança um item do board para `targetStage` (Etapa) e define o Status para
+// `targetStatus`. Uma issue só AVANÇA: se já estiver em `targetStage` ou em uma
+// etapa posterior, não é tocada (retorna false). Retorna true se avançou.
+async function advanceToStage(token, project, etapaField, statusField, nodeId, targetStage, targetStatus) {
   const itemId = await addProjectItem(token, project.id, nodeId);
 
-  if (etapaField?.id && CODE_REVIEW_STAGE) {
+  if (etapaField?.id && targetStage) {
     // Nunca retroceder: compara a etapa atual com a de destino na ordem canônica.
     const current = await getItemSingleSelectValue(token, itemId, etapaField.id).catch(() => null);
     const curIdx = current ? STAGE_ORDER.indexOf(current) : -1;
-    const tgtIdx = STAGE_ORDER.indexOf(CODE_REVIEW_STAGE);
+    const tgtIdx = STAGE_ORDER.indexOf(targetStage);
     if (curIdx !== -1 && tgtIdx !== -1 && curIdx >= tgtIdx) {
-      return false; // já está em Code Review ou adiante — não retrocede
+      return false; // já está nessa etapa ou adiante — não retrocede
     }
-    const optionId = etapaField.options?.[CODE_REVIEW_STAGE];
+    const optionId = etapaField.options?.[targetStage];
     if (optionId) await setItemSingleSelect(token, project.id, itemId, etapaField.id, optionId);
   }
-  // Ao avançar de etapa, o Status reinicia em "Todo".
-  if (statusField?.id) {
-    const optionId = statusField.options?.[TODO_STATUS];
+  if (statusField?.id && targetStatus) {
+    const optionId = statusField.options?.[targetStatus];
     if (optionId) await setItemSingleSelect(token, project.id, itemId, statusField.id, optionId);
   }
   return true;
@@ -168,18 +191,39 @@ export async function codeReview({ prNumber }) {
 
   const seen = new Set();
   const updated = [];
+  const featuresChecked = new Set();
 
-  // Para cada issue referenciada, move a unidade inteira (Feature + Story +
-  // Tasks) para Code Review — tudo anda junto com a Feature.
+  // Regras ao abrir o PR: Tasks → 🎉 Done (implementação concluída);
+  // Stories → 👀 Code Review; Feature → Code Review só quando TODAS as suas
+  // Stories já estiverem em Code Review.
   for (const num of issueNums) {
-    const unit = await collectReviewUnit(token, owner, repo, num);
-    for (const [n, info] of unit) {
+    const { feature, stories, tasks } = await collectReviewUnit(token, owner, repo, num);
+
+    // Tasks → Done (Status Done).
+    for (const [n, info] of tasks) {
+      if (seen.has(n)) continue;
+      seen.add(n);
+      try {
+        const moved = await advanceToStage(projectToken, project, etapaField, statusField, info.nodeId, DONE_STAGE, DONE_STATUS);
+        if (moved) {
+          updated.push(`#${n} ${info.title} → ${DONE_STAGE}`);
+          console.log(`#${n} → "${DONE_STAGE}" / Status "${DONE_STATUS}".`);
+        } else {
+          console.log(`#${n} já está em "${DONE_STAGE}" ou etapa posterior — mantido (não retrocede).`);
+        }
+      } catch (err) {
+        console.warn(`Falha ao atualizar #${n}: ${err.message}`);
+      }
+    }
+
+    // Stories → Code Review (Status Todo).
+    for (const [n, info] of stories) {
       if (seen.has(n)) continue;
       seen.add(n);
       try {
-        const moved = await setCodeReview(projectToken, project, etapaField, statusField, info.nodeId);
+        const moved = await advanceToStage(projectToken, project, etapaField, statusField, info.nodeId, CODE_REVIEW_STAGE, TODO_STATUS);
         if (moved) {
-          updated.push(`#${n} ${info.title}`);
+          updated.push(`#${n} ${info.title} → ${CODE_REVIEW_STAGE}`);
           console.log(`#${n} → "${CODE_REVIEW_STAGE}" / Status "${TODO_STATUS}".`);
         } else {
           console.log(`#${n} já está em "${CODE_REVIEW_STAGE}" ou etapa posterior — mantido (não retrocede).`);
@@ -188,16 +232,38 @@ export async function codeReview({ prNumber }) {
         console.warn(`Falha ao atualizar #${n}: ${err.message}`);
       }
     }
+
+    // Feature: só avança se todas as suas Stories já estão em Code Review+.
+    if (feature && !featuresChecked.has(feature.number)) {
+      featuresChecked.add(feature.number);
+      try {
+        const ready = await allStoriesReadyForReview(token, projectToken, project, etapaField, feature.nodeId);
+        if (!ready) {
+          console.log(`Feature #${feature.number} mantida em desenvolvimento — ainda há Stories pendentes (fora de "${CODE_REVIEW_STAGE}").`);
+        } else if (!seen.has(feature.number)) {
+          seen.add(feature.number);
+          const moved = await advanceToStage(projectToken, project, etapaField, statusField, feature.nodeId, CODE_REVIEW_STAGE, TODO_STATUS);
+          if (moved) {
+            updated.push(`#${feature.number} ${feature.title} (Feature) → ${CODE_REVIEW_STAGE}`);
+            console.log(`Feature #${feature.number} → "${CODE_REVIEW_STAGE}" (todas as Stories concluídas).`);
+          } else {
+            console.log(`Feature #${feature.number} já está em "${CODE_REVIEW_STAGE}" ou etapa posterior.`);
+          }
+        }
+      } catch (err) {
+        console.warn(`Falha ao avaliar a Feature #${feature.number}: ${err.message}`);
+      }
+    }
   }
 
   if (updated.length > 0) {
     await commentOnIssue(
       token, owner, repo, parseInt(prNumber, 10),
       `🔍 **Code Review iniciado**\n\n` +
-      `Movidos para **${CODE_REVIEW_STAGE}** (Feature + Story + Tasks):\n\n` +
+      `Board atualizado (Tasks → **${DONE_STAGE}**; Story → **${CODE_REVIEW_STAGE}**; Feature só avança quando todas as Stories concluírem):\n\n` +
       updated.map(f => `- ${f}`).join('\n')
     ).catch(() => {});
   }
 
-  console.log(`code-review: ${updated.length} item(ns) movido(s) para "${CODE_REVIEW_STAGE}".`);
+  console.log(`code-review: ${updated.length} item(ns) atualizado(s) no board.`);
 }

package/src/commands/implement.mjs

@@ -5,7 +5,7 @@ import { execSync } from 'node:child_process';
 import path from 'node:path';
 import { resolveToken } from '../api/auth.mjs';
 import {
-  CONFIG_FILE, STAGE_DEVELOPMENT, STAGE_CODE_REVIEW,
+  CONFIG_FILE, STAGE_DEVELOPMENT, STAGE_CODE_REVIEW, STAGE_DONE,
   PROGRESS_TODO, PROGRESS_IN_PROGRESS, PROGRESS_DONE,
 } from '../config.mjs';
 import { getIssue } from '../api/github-rest.mjs';
@@ -26,7 +26,7 @@ async function resolveFeature(token, startNodeId) {
     const parent = await getIssueParent(token, current);
     if (!parent) return null;
     if (detectIssueType({ title: parent.title }) === 'Feature') {
-      return { number: parent.number, title: parent.title };
+      return { number: parent.number, title: parent.title, nodeId: parent.nodeId };
     }
     current = parent.nodeId;
   }
@@ -46,7 +46,7 @@ function readSpecPlan(featureDir) {
 }
 
 // Monta o markdown de contexto que será entregue ao spec-kit implement.
-function buildContext({ type, issue, tasks, feature, spec, plan, specPath, planPath }) {
+function buildContext({ type, issue, tasks, feature, siblingStories = [], spec, plan, specPath, planPath }) {
   const lines = [];
   lines.push(`# Contexto de implementação — ${type} #${issue.number}`);
   lines.push('');
@@ -57,56 +57,59 @@ function buildContext({ type, issue, tasks, feature, spec, plan, specPath, planP
   }
 
   // Modelo do board: "Etapa" (coluna do kanban) = DIREÇÃO, só avança; "Status"
-  // (Todo/In Progress/Done) = PROGRESSO dentro da etapa, reinicia a cada avanço.
-  // O desenvolvimento acontece na Etapa 🚧 Desenvolvimento; o progresso por task
-  // é registrado no STATUS. Ao final, a Etapa avança para Code Review.
+  // (Todo/In Progress/Done) = PROGRESSO dentro da etapa. O desenvolvimento de
+  // cada Task acontece na Etapa Desenvolvimento (Status In Progress); ao concluir,
+  // a Task avança para a Etapa Done (Status Done). A Story avança para Code Review.
   lines.push('');
   lines.push('## Instruções de execução (uma task por vez, sequencial)');
   lines.push('');
   lines.push(
     'Há **dois campos** no board com papéis diferentes — não os confunda:\n' +
-    `- **Etapa** (Backlog → … → ${STAGE_DEVELOPMENT} → ${STAGE_CODE_REVIEW} → …): a DIREÇÃO no kanban. Uma issue só **avança**, **nunca** volta para uma etapa anterior.\n` +
-    `- **Status** (${PROGRESS_TODO} → ${PROGRESS_IN_PROGRESS} → ${PROGRESS_DONE}): o **progresso dentro da etapa atual**. Ao avançar de etapa, o Status **reinicia em ${PROGRESS_TODO}**.`
+    `- **Etapa** (Backlog → … → ${STAGE_DEVELOPMENT} → ${STAGE_CODE_REVIEW} → … → ${STAGE_DONE}): a DIREÇÃO no kanban. Uma issue só **avança**, **nunca** volta para uma etapa anterior.\n` +
+    `- **Status** (${PROGRESS_TODO} → ${PROGRESS_IN_PROGRESS} → ${PROGRESS_DONE}): o **progresso dentro da etapa atual**. Ao avançar de etapa, o Status reinicia em ${PROGRESS_TODO} — exceto ao chegar na Etapa ${STAGE_DONE}, onde o Status fica **${PROGRESS_DONE}**.`
   );
   lines.push('');
   if (type === 'Story') {
     lines.push(
       `Nesta fase, a Story #${issue.number} e suas Tasks estão na Etapa **${STAGE_DEVELOPMENT}**. ` +
-      'Durante a implementação, mexa **apenas no Status** das Tasks — **não** mude a Etapa delas.'
+      `Durante o desenvolvimento de cada Task, mexa no **Status**; ao **concluir** a Task, ela ` +
+      `**avança para a Etapa ${STAGE_DONE}** (com Status ${PROGRESS_DONE}).`
     );
     lines.push('');
     lines.push(`1. Garanta que a Story #${issue.number} está na Etapa **${STAGE_DEVELOPMENT}** com Status **${PROGRESS_IN_PROGRESS}**, e que as Tasks estão nessa Etapa com Status **${PROGRESS_TODO}**.`);
     lines.push(`2. Implemente as ${tasks.length} task(s) **uma de cada vez, na ordem abaixo**. É PROIBIDO ter mais de uma Task com Status **${PROGRESS_IN_PROGRESS}** ao mesmo tempo. Para **cada Task**, na ordem:`);
     lines.push(`   1. **Ao começar:** Status da Task → **${PROGRESS_IN_PROGRESS}** (a Etapa continua ${STAGE_DEVELOPMENT}).`);
     lines.push('   2. **Implemente** a Task por completo.');
-    lines.push(`   3. **Ao concluir:** Status da Task → **${PROGRESS_DONE}** (ainda na Etapa ${STAGE_DEVELOPMENT}).`);
+    lines.push(`   3. **Ao concluir:** **avance a Task para a Etapa ${STAGE_DONE}** com Status **${PROGRESS_DONE}**.`);
     lines.push('   4. Só então avance para a próxima Task.');
     lines.push('');
-    lines.push(`3. **Ao concluir TODA a Story** (todas as Tasks com Status ${PROGRESS_DONE}):`);
+    lines.push(`3. **Ao concluir TODA a Story** (todas as Tasks na Etapa ${STAGE_DONE}):`);
     lines.push('   1. Faça o **commit** de todas as mudanças da implementação.');
     lines.push(`   2. Abra o **Pull Request** da Story #${issue.number}.`);
     lines.push(
-      `   3. **Avance a Etapa — em conjunto — ${feature ? `da Feature #${feature.number}` : 'da Feature (issue pai da Story)'}, ` +
-      `a Story #${issue.number} e todas as ${tasks.length} Task(s) (${tasks.map(t => `#${t.number}`).join(', ')}) ` +
-      `para ${STAGE_CODE_REVIEW}**, e **reinicie o Status de cada um para ${PROGRESS_TODO}**. ` +
-      'Tudo anda junto com a Feature e sempre para frente.'
+      `   3. **Avance a Etapa da Story #${issue.number} para ${STAGE_CODE_REVIEW}** ` +
+      `(reinicie o Status para ${PROGRESS_TODO}). As Tasks já estão em ${STAGE_DONE}.`
     );
+    // A Feature só avança quando TODAS as suas Stories estiverem implementadas.
+    lines.push(`   4. **A Feature${feature ? ` #${feature.number}` : ' (issue pai da Story)'} só avança para ${STAGE_CODE_REVIEW} quando TODAS as suas Stories estiverem implementadas:**`);
+    if (siblingStories.length === 0) {
+      lines.push(`      - Esta é a **única Story** da Feature → avance também a Feature${feature ? ` #${feature.number}` : ''} para ${STAGE_CODE_REVIEW} (Status → ${PROGRESS_TODO}).`);
+    } else {
+      lines.push(`      - Outras Stories desta Feature: ${siblingStories.map(s => `#${s.number}`).join(', ')}.`);
+      lines.push(`      - Verifique a Etapa de cada uma. Avance a Feature para ${STAGE_CODE_REVIEW} **somente se TODAS** já estiverem em ${STAGE_CODE_REVIEW} (ou etapa posterior).`);
+      lines.push(`      - Se **qualquer** Story ainda estiver pendente (antes de ${STAGE_CODE_REVIEW}), **NÃO mova a Feature** — deixe-a em ${STAGE_DEVELOPMENT} até a última Story ser concluída.`);
+    }
   } else {
-    lines.push(
-      `Esta Task #${issue.number} está na Etapa **${STAGE_DEVELOPMENT}**. Acompanhe o progresso pelo ` +
-      '**Status** — **não** mude a Etapa aqui:'
-    );
+    lines.push(`Esta Task #${issue.number} está na Etapa **${STAGE_DEVELOPMENT}**:`);
     lines.push('');
-    lines.push(`1. **Ao começar:** Status da Task #${issue.number} → **${PROGRESS_IN_PROGRESS}**.`);
+    lines.push(`1. **Ao começar:** Status da Task #${issue.number} → **${PROGRESS_IN_PROGRESS}** (Etapa continua ${STAGE_DEVELOPMENT}).`);
     lines.push('2. **Implemente** a Task por completo.');
-    lines.push(`3. **Ao concluir:** Status da Task #${issue.number} → **${PROGRESS_DONE}**.`);
-    lines.push('');
-    lines.push(`> A Etapa avança para **${STAGE_CODE_REVIEW}** (Status reinicia em ${PROGRESS_TODO}) junto com a Story/Feature quando o PR é aberto — nunca volta para uma etapa anterior.`);
+    lines.push(`3. **Ao concluir:** **avance a Task #${issue.number} para a Etapa ${STAGE_DONE}** com Status **${PROGRESS_DONE}**.`);
   }
   lines.push('');
   lines.push(
     `> **Regra do board:** a **Etapa** só avança (nunca retrocede); o **Status** (${PROGRESS_TODO}/${PROGRESS_IN_PROGRESS}/${PROGRESS_DONE}) ` +
-    'só mede o progresso dentro da etapa atual e reinicia a cada avanço de etapa.'
+    `mede o progresso dentro da etapa atual e reinicia a cada avanço (na Etapa ${STAGE_DONE}, o Status fica ${PROGRESS_DONE}).`
   );
 
   lines.push('');
@@ -212,7 +215,7 @@ export async function implement({ issue: issueArg, featureDir: featureDirOpt, dr
   }
 
   // 4. Resolve a Feature (pai na cadeia) — para spec.md/plan.md e para as
-  // instruções de fim de Story (mover Feature + Story para Code Review).
+  // instruções de fim de Story (avançar a Etapa para Code Review).
   const feature = await resolveFeature(token, issue.node_id);
   let featureDir = featureDirOpt;
   if (!featureDir && feature?.title) {
@@ -227,8 +230,19 @@ export async function implement({ issue: issueArg, featureDir: featureDirOpt, dr
     p.log.warn('Não foi possível resolver a Feature; seguindo só com as tasks (use --feature-dir).');
   }
 
+  // 4b. Stories irmãs da Feature — a Feature só avança para Code Review quando
+  // TODAS as suas Stories estiverem implementadas. Lista as outras para o agente
+  // verificar antes de mover a Feature.
+  let siblingStories = [];
+  if (type === 'Story' && feature?.nodeId) {
+    const featureSubs = await listSubIssues(token, feature.nodeId).catch(() => []);
+    siblingStories = featureSubs
+      .filter(s => detectIssueType({ title: s.title }) === 'Story' && s.number !== issue.number)
+      .map(s => ({ number: s.number, title: s.title }));
+  }
+
   // 5. Monta e grava o arquivo de contexto.
-  const context = buildContext({ type, issue, tasks, feature, ...specPlan });
+  const context = buildContext({ type, issue, tasks, feature, siblingStories, ...specPlan });
   mkdirSync(WORK_DIR, { recursive: true });
   const tasksFile = path.join(WORK_DIR, `implement-${issueNumber}.md`);
   writeFileSync(tasksFile, context);

package/src/config.mjs

@@ -60,6 +60,7 @@ export const STATUS_OPTIONS = [
 // Etapas (campo Etapa) referenciadas pelo fluxo de implementação.
 export const STAGE_DEVELOPMENT = STATUS_OPTIONS.find(s => s.name.includes('Desenvolvimento')).name;
 export const STAGE_CODE_REVIEW = STATUS_OPTIONS.find(s => s.name.includes('Code Review')).name;
+export const STAGE_DONE = STATUS_OPTIONS.find(s => s.name.includes('Done')).name;
 // Ordem canônica das etapas — usada para garantir que uma issue só AVANÇA.
 export const STAGE_ORDER = STATUS_OPTIONS.map(s => s.name);
 

package/src/templates/skill/SKILL.md

@@ -166,7 +166,7 @@ Mesmas flags do `issue` (exceto `--type`, fixo em `feature`). Mantido para o flu
 | `--feature-dir <path>` | string | Caminho `docs/features/<slug>` para anexar `spec.md`/`plan.md` como contexto (sobrescreve a resolução automática). |
 | `--dry-run` | flag | Monta o contexto e imprime o comando do spec-kit **sem executar**. |
 
-> Diferente dos quatro acima, `implement` roda **localmente** (lê `.spec-wave.json`, como `issue`), não por Action. Detecta o tipo da issue: **Story** → coleta todas as Tasks (sub-issues) e aciona o spec-kit uma única vez; **Task** → só aquela task. Monta o contexto em `.spec-wave/implement-<n>.md` e chama o comando configurado em `specKit.command` (no `.spec-wave.json`) ou na env `SPEC_WAVE_IMPLEMENT_CMD`. Placeholders disponíveis no template: `{tasksFile} {specFile} {planFile} {issue} {type} {title}`. Se nada estiver configurado, ele apenas monta o contexto e mostra como configurar (não executa). O contexto inclui instruções para o agente implementar as Tasks **sequencialmente, uma por vez**, usando o campo **Status** (Todo → In Progress → Done) para o progresso *dentro* da Etapa 🚧 Desenvolvimento — sem trocar a Etapa das tasks (nunca duas com Status "In Progress" ao mesmo tempo). **Ao concluir toda a Story**: fazer o commit, abrir o PR e **avançar a Etapa** da **Feature, Story e todas as Tasks juntas** para **👀 Code Review**, reiniciando o **Status** de cada uma para **Todo**. Etapa só avança (nunca volta); Status mede o progresso dentro da etapa.
+> Diferente dos quatro acima, `implement` roda **localmente** (lê `.spec-wave.json`, como `issue`), não por Action. Detecta o tipo da issue: **Story** → coleta todas as Tasks (sub-issues) e aciona o spec-kit uma única vez; **Task** → só aquela task. Monta o contexto em `.spec-wave/implement-<n>.md` e chama o comando configurado em `specKit.command` (no `.spec-wave.json`) ou na env `SPEC_WAVE_IMPLEMENT_CMD`. Placeholders disponíveis no template: `{tasksFile} {specFile} {planFile} {issue} {type} {title}`. Se nada estiver configurado, ele apenas monta o contexto e mostra como configurar (não executa). O contexto inclui instruções para o agente implementar as Tasks **sequencialmente, uma por vez** (nunca duas com Status "In Progress" ao mesmo tempo): cada Task usa o **Status** (In Progress) *dentro* da Etapa 🚧 Desenvolvimento e, **ao concluir, avança para a Etapa 🎉 Done com Status Done**. **Ao concluir toda a Story**: fazer o commit, abrir o PR e **avançar a Etapa da Story para 👀 Code Review** (Status → Todo) — as Tasks já estão em 🎉 Done. A **Feature só avança** para Code Review quando **TODAS as suas Stories** já estiverem em Code Review — enquanto houver Story pendente, a Feature fica em 🚧 Desenvolvimento. Etapa só avança (nunca volta); Status mede o progresso dentro da etapa.
 
 ---
 
@@ -396,7 +396,7 @@ Aciona o spec-kit para implementar uma **Story** (todas as suas Tasks) ou uma **
    npx @spec-wave/cli implement <número> --dry-run
    ```
 3. Mostre ao usuário o contexto montado em `.spec-wave/implement-<número>.md` e o comando. Esse arquivo contém as **instruções de execução sequencial**: implemente as Tasks **uma por vez** — mova a task para **🚧 Desenvolvimento** só ao iniciá-la e para **🎉 Done** ao concluí-la, antes de passar para a próxima. **Nunca** coloque várias tasks em "in progress" ao mesmo tempo.
-4. **Se você (agente) for implementar diretamente** (sem `specKit.command`): siga o contexto task por task. Para cada task, use o campo **Status** (In Progress ao começar → Done ao concluir) *dentro* da Etapa 🚧 Desenvolvimento — não troque a Etapa da task. Atualize os campos via `gh`. **Ao concluir toda a Story**: faça o commit, abra o PR e **avance a Etapa** da **Feature, Story e todas as Tasks juntas** para **👀 Code Review**, reiniciando o **Status** de cada uma para **Todo**. Lembre: Etapa só avança (nunca volta); Status é o progresso dentro da etapa.
+4. **Se você (agente) for implementar diretamente** (sem `specKit.command`): siga o contexto task por task. Para cada task: Status → In Progress *dentro* da Etapa 🚧 Desenvolvimento e, **ao concluir, avance a task para a Etapa 🎉 Done com Status Done**. Atualize os campos via `gh`. **Ao concluir toda a Story**: faça o commit, abra o PR e **avance a Etapa da Story para 👀 Code Review** (Status → Todo) — as Tasks já estão em 🎉 Done. A **Feature só avança** quando **TODAS as suas Stories** já estiverem em Code Review — se houver Story pendente, deixe a Feature em 🚧 Desenvolvimento. Lembre: Etapa só avança (nunca volta); Status é o progresso dentro da etapa.
 5. Se o usuário aprovar e o spec-kit estiver configurado, rode sem `--dry-run`:
    ```bash
    npx @spec-wave/cli implement <número>
@@ -404,7 +404,7 @@ Aciona o spec-kit para implementar uma **Story** (todas as suas Tasks) ou uma **
    - Se o spec-kit **não** estiver configurado, o comando só monta o contexto e mostra como configurar (`specKit.command` / `SPEC_WAVE_IMPLEMENT_CMD`). Ajude o usuário a definir o template (placeholders: `{tasksFile} {specFile} {planFile} {issue} {type} {title}`).
    - Use `--feature-dir docs/features/<slug>` se a resolução automática da Feature falhar (a skill avisa com warning) e você quiser anexar `spec.md`/`plan.md` como contexto.
 6. Se a issue **não** for Story nem Task (ex.: Feature, Bug), o comando recusa — oriente o usuário: Features se decompõem (`/spec-wave decompose`); implemente as Stories/Tasks resultantes.
-7. Ao final (Story implementada, commit feito, PR aberto e Feature + Story + Tasks em **👀 Code Review**): confirme o resultado com o usuário e oriente a revisão do PR.
+7. Ao final (Tasks em **🎉 Done**, Story em **👀 Code Review**; a Feature só vai para Code Review quando a última Story concluir): confirme o resultado com o usuário e oriente a revisão do PR.
 
 ---