@the-bearded-bear/claude-craft 8.23.3 → 8.26.0-next.2a54921

package/Dev/i18n/es/Workflow/commands/init.md

@@ -121,7 +121,7 @@ Segun el track, mostrar el flujo de trabajo:
 ║                                                           ║
 ║ Comandos:                                                 ║
 ║ • /qa:tdd    - Corregir con TDD               ║
-║ • /project:add-task      - Registrar el trabajo            ║
+║ • /project:backlog add task      - Registrar el trabajo            ║
 ║                                                           ║
 ╚══════════════════════════════════════════════════════════╝
 ```
@@ -139,14 +139,16 @@ Segun el track, mostrar el flujo de trabajo:
 ║   Comenzar aqui                                           ║
 ║                                                           ║
 ║ Fase 1 - Planificacion:                                   ║
-║ • /project:generate-prd    - Crear/actualizar PRD         ║
-║ • /project:generate-backlog - Crear user stories          ║
+║ • /workflow:plan --only=prd    - Crear/actualizar PRD         ║
+║ • /workflow:plan --only=backlog - Crear user stories          ║
 ║                                                           ║
 ║ Fase 2 - Diseno:                                          ║
-║ • /project:generate-tech-spec - Diseno tecnico            ║
+║ • /workflow:design - Diseno tecnico            ║
 ║                                                           ║
 ║ Fase 3 - Implementacion:                                  ║
-║ • /sprint:dev      - Desarrollo TDD/BDD           ║
+║ • /workflow:start N      - Preparar sprint        ║
+║ • /workflow:implement    - Desarrollo TDD/BDD     ║
+║ • /workflow:auto-sprint N - Sprint completo       ║
 ║                                                           ║
 ╚══════════════════════════════════════════════════════════╝
 ```
@@ -164,18 +166,20 @@ Segun el track, mostrar el flujo de trabajo:
 ║   Comenzar aqui                                           ║
 ║                                                           ║
 ║ Fase 1 - Analisis:                                        ║
-║ • /workflow:analyze        - Investigacion y exploracion  ║
+║ • /workflow:plan --research        - Investigacion y exploracion  ║
 ║                                                           ║
 ║ Fase 2 - Planificacion:                                   ║
-║ • /project:generate-prd    - PRD completo                 ║
-║ • /project:generate-backlog - Backlog completo            ║
+║ • /workflow:plan --only=prd    - PRD completo                 ║
+║ • /workflow:plan --only=backlog - Backlog completo            ║
 ║                                                           ║
 ║ Fase 3 - Diseno:                                          ║
-║ • /project:generate-tech-spec - Tech spec completo        ║
+║ • /workflow:design - Tech spec completo        ║
 ║ • /common:architecture-decision - ADRs                    ║
 ║                                                           ║
 ║ Fase 4 - Implementacion:                                  ║
-║ • /sprint:dev      - Desarrollo sprint a sprint   ║
+║ • /workflow:start N      - Preparar sprint        ║
+║ • /workflow:implement    - Desarrollo TDD/BDD     ║
+║ • /workflow:auto-sprint N - Sprint completo       ║
 ║                                                           ║
 ╚══════════════════════════════════════════════════════════╝
 ```
@@ -210,7 +214,27 @@ phases:
     status: pending
 
 next_action: "Generar o actualizar PRD"
-next_command: "/project:generate-prd"
+next_command: "/workflow:plan --only=prd"
+```
+
+Crear el esqueleto de estado BMAD (fuente única de verdad del estado de las historias, leído por `/gate:*`, `/sprint:*`, `/workflow:auto-sprint` y el Kanban). Omitir si `.bmad/sprint-status.yaml` ya existe; `/workflow:start` completa `metadata` y `stories` más adelante:
+
+```yaml
+# .bmad/sprint-status.yaml
+version: "1.0"
+metadata:
+  sprint_id: "sprint-0"
+  name: "Sin iniciar"
+  start_date: ""
+  end_date: ""
+  goal: ""
+stories: {}
+routing:
+  auto_transitions:
+    enabled: true
+    run_on_session_start: false
+    run_on_task_complete: true
+    rules: []
 ```
 
 ### Paso 6: Indicar siguiente accion
@@ -221,6 +245,7 @@ next_command: "/project:generate-prd"
 ╠══════════════════════════════════════════════════════════╣
 ║ Flujo inicializado: track STANDARD                        ║
 ║ Archivo de estado: project-management/workflow-status.yaml║
+║ Estado del sprint: .bmad/sprint-status.yaml               ║
 ║                                                           ║
 ║ ─────────────────────────────────────────────────────────║
 ║ SIGUIENTE PASO: Fase de planificacion                     ║
@@ -229,9 +254,9 @@ next_command: "/project:generate-prd"
 ║ Comenzar con: /workflow:plan                              ║
 ║                                                           ║
 ║ O ir directamente a tareas especificas:                   ║
-║ • /project:generate-prd     - Crear documento de          ║
+║ • /workflow:plan --only=prd     - Crear documento de          ║
 ║                                requisitos                  ║
-║ • /project:generate-backlog - Crear user stories          ║
+║ • /workflow:plan --only=backlog - Crear user stories          ║
 ║                                                           ║
 ║ Verificar progreso en cualquier momento: /workflow:status  ║
 ╚══════════════════════════════════════════════════════════╝
@@ -257,4 +282,7 @@ next_command: "/project:generate-prd"
 - `/workflow:plan` - Iniciar fase de planificacion
 - `/workflow:design` - Iniciar fase de diseno
 - `/workflow:implement` - Iniciar fase de implementacion
-- `/workflow:analyze` - Iniciar fase de analisis (solo Enterprise)
+- `/workflow:auto-sprint` - Ejecutar un sprint completo de extremo a extremo (inicio → merge)
+- `/workflow:plan --research` - Iniciar fase de analisis (solo Enterprise)
+
+> ¿No sabes qué camino seguir? Consulta la página de decisión: https://github.com/TheBeardedBearSAS/claude-craft/blob/main/docs/guides/es/11-which-path.md

package/Dev/i18n/es/Workflow/commands/plan.md

@@ -1,231 +1,216 @@
 ---
 name: workflow-plan
-description: Ejecutar la fase de Planificacion - creacion del PRD, personas y generacion del backlog
+description: "Ejecutar la fase de Planificación - investigación (--research), PRD (--only=prd) y backlog SCRUM (--only=backlog)"
+argument-hint: "[--research] [--only=prd|backlog] [--continue]"
 arguments:
+  - name: research
+    description: "Ejecutar primero la etapa de investigación (antiguo /workflow:plan --research): dominio, mercado, investigación técnica, restricciones, riesgos"
+    required: false
+  - name: only
+    description: "Ejecutar una sola etapa: prd (PRD + personas) o backlog (personas, DoD, epics, user stories, sprints)"
+    required: false
   - name: continue
-    description: Continuar desde donde se dejo
+    description: Continuar desde donde se quedó
     required: false
 ---
 
 # /workflow:plan
 
-## Mision
+## Misión
 
-Ejecutar la fase de Planificacion del flujo de trabajo de desarrollo. Esta fase se centra en crear el Documento de Requisitos del Producto, definir personas y generar el backlog inicial del producto.
+Ejecutar la fase de Planificación del workflow de desarrollo: investigación opcional, Product Requirements Document (PRD), personas y backlog SCRUM (epics, user stories, carpetas de sprint). Este comando contiene toda la lógica de generación; ya no hay un generador de PRD o de backlog independiente al que llamar.
 
-## Modo Plan
+## Usage
 
-> **El modo plan es recomendado.** Claude activa el modo plan para estructurar el enfoque, identificar dependencias y presentar una estrategia de generación antes de crear artefactos.
+| Invocación | Qué hace | Reemplaza |
+|------------|----------|-----------|
+| `/workflow:plan` | Fase completa: PRD y luego backlog (añadir `--research` para empezar por la investigación) | - |
+| `/workflow:plan --research` | Investigación, exploración, restricciones y riesgos, antes del PRD. Escribe `project-management/analysis/` | `/workflow:plan --research` |
+| `/workflow:plan --only=prd` | Solo PRD + personas. Escribe `project-management/prd.md` | `/workflow:plan --only=prd` |
+| `/workflow:plan --only=backlog` | Solo backlog: lee `project-management/prd.md` (+ `project-management/tech-spec.md` si existe), escribe personas, DoD, epics, user stories con `**Implements**`, carpetas de sprint `sprint-{N}-{slug}`, y registra las stories en `.bmad/sprint-status.yaml` con estado `backlog` | `/workflow:plan --only=backlog` |
+| `/workflow:plan --continue` | Reanudar una ejecución interrumpida | - |
 
-## Cuando usar
+`--research` puede combinarse con `--only=prd` (investigación y luego PRD).
 
-- Flujos **Standard** y **Enterprise**
-- Despues de `/workflow:init` (o `/workflow:analyze` para Enterprise)
-- Al comenzar la planificacion de funcionalidades
+## Orden canónico
 
-## Flujo de trabajo
+Los documentos se producen en este orden: **PRD, luego tech spec, luego backlog, luego sprint**.
 
-### Paso 1: Configuracion de la planificacion
+- **Track Quick**: `/workflow:plan` (sin opciones) genera PRD + backlog de una vez.
+- **Standard / Enterprise (recomendado)**: `/workflow:plan --only=prd`, luego `/workflow:design`, luego `/workflow:plan --only=backlog`. El backlog lee entonces `project-management/prd.md` y `project-management/tech-spec.md`: las stories llevan la arquitectura real y `**Implements**` apunta a los `FR-xxx` del PRD.
+- **Enterprise**: empezar con `/workflow:plan --research --only=prd`.
 
-```
-╔══════════════════════════════════════════════════════════╗
-║             FASE DE PLANIFICACION - INICIANDO              ║
-╠══════════════════════════════════════════════════════════╣
-║ Track: Standard                                           ║
-║ Fase: 2 de 4 - Planificacion                              ║
-║                                                           ║
-║ Objetivos:                                                ║
-║ • Crear o actualizar Documento de Requisitos del Producto ║
-║ • Definir user personas                                   ║
-║ • Generar backlog del producto con user stories            ║
-║   priorizadas                                             ║
-║ • Establecer metricas de exito y KPIs                     ║
-╚══════════════════════════════════════════════════════════╝
-```
+Sin PRD, `--only=backlog` recurre a las especificaciones de `./docs/` (ARCHITECTURE_TECHNIQUE*.md, CAHIER_DES_CHARGES*.md u otro archivo de especificación) y avisa de que la trazabilidad queda degradada.
 
-### Paso 2: Verificar artefactos existentes
+## Cuándo usar
 
-```
-╔══════════════════════════════════════════════════════════╗
-║              VERIFICACION DE ARTEFACTOS EXISTENTES        ║
-╠══════════════════════════════════════════════════════════╣
-║                                                           ║
-║ Verificando project-management/ ...                       ║
-║                                                           ║
-║ PRD:                                                      ║
-║ ├── ❌ prd.md                    No encontrado            ║
-║                                                           ║
-║ Personas:                                                 ║
-║ ├── ❌ personas.md               No encontrado            ║
-║                                                           ║
-║ Backlog:                                                  ║
-║ ├── ❌ backlog/                  No encontrado            ║
-║                                                           ║
-║ Analisis (Enterprise):                                    ║
-║ ├── ✅ analysis/constraints.md   Disponible               ║
-║ └── ✅ analysis/research.md      Disponible               ║
-║                                                           ║
-╚══════════════════════════════════════════════════════════╝
-```
+- Tracks **Standard** y **Enterprise**, después de `/workflow:init`
+- Al empezar la planificación de funcionalidades, o cuando hay que regenerar el PRD o el backlog
 
-### Paso 3: Tareas de planificacion
+## Plan Mode
 
-Ejecutar las tareas de planificacion en orden:
+> **El Plan Mode es obligatorio.** Claude activa el plan mode para estructurar el enfoque, identificar dependencias y presentar una estrategia de generación antes de crear los artefactos.
 
-```
-╔══════════════════════════════════════════════════════════╗
-║               TAREAS DE PLANIFICACION                     ║
-╠══════════════════════════════════════════════════════════╣
-║                                                           ║
-║ □ Tarea 1: Generar PRD                                    ║
-║   Comando: /project:generate-prd                          ║
-║   Salida: project-management/prd.md                       ║
-║                                                           ║
-║ □ Tarea 2: Definir personas                               ║
-║   (Incluido en la generacion del PRD)                     ║
-║   Salida: project-management/personas.md                  ║
-║                                                           ║
-║ □ Tarea 3: Generar backlog                                ║
-║   Comando: /project:generate-backlog                      ║
-║   Salida: project-management/backlog/                     ║
-║                                                           ║
-║ □ Tarea 4: Validar backlog                                ║
-║   Comando: /gate:validate-backlog                      ║
-║   Asegura cumplimiento SCRUM                              ║
-║                                                           ║
-╚══════════════════════════════════════════════════════════╝
-```
+## Workflow
 
-### Paso 4: Ejecutar generacion del PRD
+### Paso 1: Preparación y artefactos existentes
 
-Invocar el comando de generacion del PRD:
+Mostrar el track y la fase (Planificación = fase 2 de 4), y luego revisar `project-management/`: `prd.md`, `personas.md`, `backlog/`, `analysis/` (constraints.md, research-summary.md). Los archivos existentes nunca se sobrescriben en silencio: preguntar si actualizar, fusionar u omitir.
 
-```
-Iniciando /project:generate-prd...
+### Paso 2 (`--research`): Fase de investigación
 
-[Flujo de generacion del PRD se ejecuta]
+Antiguo `/workflow:plan --research`. Investigación, exploración y restricciones antes del PRD.
 
-✅ PRD creado: project-management/prd.md
-✅ Personas extraidas: project-management/personas.md
-```
+**Preguntas guiadas**
 
-### Paso 5: Ejecutar generacion del backlog
+| Área | Preguntas |
+|------|-----------|
+| Dominio | ¿Qué problema? ¿Qué partes interesadas? ¿Motores de negocio? ¿Cómo es el éxito? |
+| Mercado | ¿Soluciones existentes? ¿Competidores? ¿Buenas prácticas del sector? ¿Tendencias emergentes? |
+| Técnica | ¿Tecnologías candidatas? ¿Integraciones? ¿Escalabilidad? ¿Seguridad / cumplimiento? |
 
-Despues de completar el PRD:
+Si el MCP Context7 está configurado, usarlo para documentación técnica actualizada (`/common:research-context7` para una investigación profunda).
+
+**Restricciones**: documentar las restricciones técnicas (backend existente, base de datos), de negocio (presupuesto, plazos, retrocompatibilidad), regulatorias (RGPD, PCI DSS) y de recursos (tamaño del equipo, sin DevOps).
+
+**Riesgos y oportunidades**: tabla de riesgos (riesgo, impacto, probabilidad, mitigación) y oportunidades.
+
+**Artefactos**
 
 ```
-Iniciando /project:generate-backlog...
+project-management/analysis/
+├── research-summary.md      # Hallazgos principales
+├── constraints.md           # Todas las restricciones identificadas
+├── risks-opportunities.md   # Registro de riesgos y oportunidades
+└── technical-options.md     # Evaluación de tecnologías
+```
 
-Usando PRD como entrada:
-• 3 personas identificadas
-• 12 requisitos funcionales extraidos
-• 8 requisitos no funcionales registrados
+Agentes: **research-assistant** (investigación técnica), **product-owner** (contexto de negocio). Siguiente: PRD (el análisis lo alimenta).
 
-Generando estructura del backlog...
+### Paso 3 (`--only=prd` o ejecución completa): Generación del PRD
 
-[Flujo de generacion del backlog se ejecuta]
+Escribe `project-management/prd.md` y `project-management/personas.md`.
 
-✅ Backlog creado con:
-   • 4 EPICs
-   • 18 User Stories
-   • Sprint 1 planificado (Walking Skeleton)
-```
+**Fase 1 - Descubrimiento del contexto**: leer `README.md`, revisar `./docs/` en busca de especificaciones, leer `project-management/personas.md` y `project-management/analysis/` si existen, analizar el código para conocer el stack técnico, revisar la conversación. Listar las fuentes encontradas.
 
-### Paso 6: Validacion
+**Fase 2 - Clarificación interactiva** (preguntar solo lo que falta):
 
-Ejecutar validacion del backlog:
+| Tema | Preguntas |
+|------|-----------|
+| Problema y oportunidad | ¿Qué problema? ¿Quién lo sufre más? ¿Coste de no resolverlo? ¿Oportunidad de negocio? |
+| Usuarios objetivo | ¿Usuarios principales (rol, perfil)? ¿Objetivos? ¿Frustraciones con las soluciones actuales? ¿Usuarios secundarios? |
+| Objetivos y métricas | ¿Objetivos de negocio? ¿KPIs con valores objetivo y plazos? ¿Cómo es el éxito del MVP? |
+| Alcance y restricciones | ¿Funcionalidades imprescindibles (P0)? ¿Qué queda explícitamente fuera? ¿Restricciones técnicas, de presupuesto, plazos, cumplimiento? |
+
+**Fase 3 - Generación**: cargar la plantilla de PRD (`.claude/templates/project/prd.md` si existe), completar todas las secciones, crear personas detalladas, organizar los requisitos en P0/P1/P2 con IDs estables `FR-001`, `FR-002`... (funcionales) y `NFR-001`... (no funcionales) para que las stories puedan trazarse a ellos, identificar riesgos a partir de restricciones y dependencias.
+
+**Fase 4 - Revisión e iteración**: mostrar una checklist de secciones (Executive Summary, Problem Statement, Goals & Metrics, Target Users, Functional Requirements, Non-Functional Requirements, Scope & Constraints, Timeline, Risks & Mitigations), señalar las incompletas y luego ofrecer ampliar una sección, detallar las personas o ajustar la priorización.
 
 ```
-╔══════════════════════════════════════════════════════════╗
-║              VALIDACION DEL BACKLOG                       ║
-╠══════════════════════════════════════════════════════════╣
-║                                                           ║
-║ Verificacion criterios INVEST:                            ║
-║ ├── Independent:    18/18 ✅                              ║
-║ ├── Negotiable:     18/18 ✅                              ║
-║ ├── Valuable:       18/18 ✅                              ║
-║ ├── Estimable:      18/18 ✅                              ║
-║ ├── Sized (≤8pts):  16/18 ⚠️  (2 stories necesitan       ║
-║ │                            division)                    ║
-║ └── Testable:       18/18 ✅                              ║
-║                                                           ║
-║ Verificacion criterios 3C:                                ║
-║ ├── Card:           18/18 ✅                              ║
-║ ├── Conversation:   18/18 ✅                              ║
-║ └── Confirmation:   18/18 ✅                              ║
-║                                                           ║
-║ Criterios de aceptacion (Gherkin):                        ║
-║ └── Formato valido:   18/18 ✅                            ║
-║                                                           ║
-║ ADVERTENCIAS:                                             ║
-║ • US-007: 13 puntos - considerar dividir                  ║
-║ • US-012: 21 puntos - debe dividirse                      ║
-║                                                           ║
-╚══════════════════════════════════════════════════════════╝
+project-management/
+├── prd.md                    # PRD generado (FR-xxx / NFR-xxx)
+├── personas.md               # Personas extraídas/creadas
+└── analysis/discovery-notes.md
 ```
 
-### Paso 7: Finalizacion de la fase
+### Paso 4 (`--only=backlog` o ejecución completa): Generación del backlog
+
+Actúe como un Product Owner y Scrum Master con experiencia. El backlog debe respetar los 3 pilares de Scrum (transparencia, inspección, adaptación) y los valores Agile.
+
+**Entradas, por orden de prioridad**
+
+1. `project-management/prd.md`: fuente principal. Sus IDs `FR-xxx` alimentan el campo `**Implements**` de cada user story.
+2. `project-management/tech-spec.md` si existe (ver `/workflow:design`): arquitectura, entidades, endpoints usados en las notas técnicas.
+3. Alternativa sin PRD: especificaciones en `./docs/`.
+
+**Vertical slicing (obligatorio)**: cada user story atraviesa todas las capas del stack del proyecto (UI, API, persistencia). Ninguna story «solo backend» o «solo frontend». Detectar el stack a partir de la tech spec o del código y adaptar la DoD y los criterios técnicos en consecuencia.
+
+**Estructura creada**
 
 ```
-╔══════════════════════════════════════════════════════════╗
-║             FASE DE PLANIFICACION COMPLETADA               ║
-╠══════════════════════════════════════════════════════════╣
-║                                                           ║
-║ Artefactos creados:                                       ║
-║ ✅ prd.md              Documento de Requisitos del        ║
-║                         Producto                          ║
-║ ✅ personas.md         3 user personas                    ║
-║ ✅ backlog/            Backlog SCRUM completo              ║
-║    ├── epics/          4 EPICs                            ║
-║    └── user-stories/   18 User Stories                    ║
-║                                                           ║
-║ Resumen:                                                  ║
-║ • Total Story Points: 89                                  ║
-║ • Alcance Sprint 1: 21 puntos (Walking Skeleton)          ║
-║ • Sprints estimados: 4-5                                  ║
-║                                                           ║
-║ ─────────────────────────────────────────────────────────║
-║ SIGUIENTE FASE: Diseno (Solucion)                         ║
-║ Comando: /workflow:design                                 ║
-║ ─────────────────────────────────────────────────────────║
-║                                                           ║
-║ El tech spec se basara en los requisitos del PRD.         ║
-╚══════════════════════════════════════════════════════════╝
+project-management/
+├── README.md                 # Visión general, personas, epics, métricas, roadmap
+├── personas.md
+├── definition-of-done.md
+├── dependencies-matrix.md
+├── backlog/
+│   ├── epics/EPIC-XXX-name.md
+│   └── user-stories/US-XXX-name.md
+└── sprints/sprint-{N}-{slug}/   # p. ej. sprint-1-walking_skeleton
+    ├── sprint-goal.md
+    └── sprint-dependencies.md
 ```
 
-## Agentes involucrados
+**personas.md**: mínimo 3 personas (IDs P-001, P-002...; 1 principal, 2+ secundarias). Cada una: identidad, cita representativa, contexto, 3 objetivos, al menos 3 frustraciones, motivaciones, comportamientos, escenarios de uso (Contexto, Necesidad, Acción, Resultado), criterios de decisión. Añadir una matriz personas/funcionalidades (3 estrellas crítico, 2 importante, 1 útil) y anti-personas.
+
+**definition-of-done.md**: código (revisión aprobada, convenciones, SOLID), tests (80 % unitarios, integración, E2E, CI en verde), criterios por capa (UI, API, paridad entre clientes), documentación, calidad (análisis estático nivel máximo, API por debajo de 200 ms), despliegue (migraciones, staging, validación del PO).
+
+**Epics** (`EPIC-XXX-name.md`): descripción (valor de negocio), tabla de stories asociadas (ID, título, puntos, prioridad, depende de), dependencias (prerrequisitos y dependientes), Minimum Marketable Feature (MMF) con las stories incluidas, estimación (tamaño S/M/L/XL, sprints estimados).
+
+**User stories** (`US-XXX-name.md`), a partir de `.claude/templates/project/user-story.md`:
+
+- **INVEST** (obligatorio): Independent, Negotiable, Valuable, Estimable, Sized (8 puntos máx.), Testable.
+- **3 C** (obligatorio): Card («Como [P-XXX]... quiero... para...»), Conversation (preguntas abiertas), Confirmation (criterios de aceptación).
+- **Criterios de aceptación** en Gherkin SMART: 1 escenario nominal, al menos 2 alternativos, al menos 2 escenarios de error.
+- Epic padre, persona asociada, criterios por capa, notas técnicas, estimación (puntos Fibonacci, MoSCoW), dependencias (bloqueantes y bloqueadas), sprint asignado.
+- **Trazabilidad**: completar la sección `## Traceability` con `**Implements**: {FR-001, FR-003}` (IDs de los requisitos del PRD que entrega la story). Una story sin `FR-xxx` se señala.
+
+**dependencies-matrix.md**: grafo Mermaid entre epics, tabla de dependencias, ruta crítica, dependencias entre stories.
+
+**Sprints** (`sprint-{N}-{slug}/`): `sprint-goal.md` (objetivo en una frase, ceremonias, stories seleccionadas y total de puntos, orden de ejecución, grafo de dependencias Mermaid, incremento entregable, directiva de retrospectiva y formato Starfish) y `sprint-dependencies.md`.
 
-- **product-owner**: Creacion del PRD, definicion de personas, priorizacion
-- **tech-lead**: Revision de viabilidad tecnica, guia de estimacion
+**Registro en `.bmad/sprint-status.yaml`**: para cada story, añadir una entrada con `status: backlog` (esquema: `Project/templates/sprint-status.yaml.template`): `title`, `story_points`, `epic_id`, `tasks` (total 0), `acceptance_criteria.total` y una entrada `history` «Story created». `.bmad/sprint-status.yaml` es la fuente única de verdad del estado; los archivos markdown solo contienen contenido, nunca un estado. Crear el archivo desde la plantilla si falta, nunca sobrescribir entradas existentes.
 
-## Archivos de salida
+**Reglas Scrum**: sprints de 2 semanas, velocidad 20-40 puntos, 8 puntos máx. por story (si no, dividir), escala de Fibonacci (1, 2, 3, 5, 8, 13, 21), Sprint 1 = Walking Skeleton (infraestructura + un flujo completo).
 
-| Archivo | Proposito |
+### Paso 5: Validación
+
+Ejecutar `/gate:check backlog` (o comprobar en línea):
+
+| Control | Criterios |
 |---------|-----------|
-| `prd.md` | Documento de Requisitos del Producto |
-| `personas.md` | Definiciones de user personas |
-| `backlog/epics/` | Definiciones de EPICs |
-| `backlog/user-stories/` | Archivos de User Stories |
-| `sprints/sprint-001/` | Estructura del primer sprint |
+| INVEST | Los 6 criterios por story; 8 puntos máx. (13+ debe dividirse) |
+| 3 C | Card, Conversation, Confirmation presentes |
+| Gherkin | Formato válido; 1 nominal + 2 alternativos + 2 errores |
+| Personas | Al menos 3, matriz presente |
+| Epics | MMF identificado, dependencias Mermaid |
+| Sprints | Sprint 1 = Walking Skeleton, objetivo en una frase, grafo de dependencias |
+| Trazabilidad | Cada story tiene `**Implements**`; cada `FR-xxx` P0 está cubierto por al menos una story |
+| Estado | Cada story está registrada en `.bmad/sprint-status.yaml` como `backlog` |
 
-## Opcion de continuacion
+Señalar las advertencias (por ejemplo «US-012: 21 puntos - debe dividirse») y corregirlas antes de terminar.
 
-Si se interrumpe, usar `--continue` para reanudar:
+### Paso 6: Fin de fase
 
-```bash
-/workflow:plan --continue
+Resumir los artefactos (PRD, personas, epics, número de stories, total de puntos, alcance del Sprint 1, sprints estimados) y recomendar el siguiente paso: tras `--only=prd`, `/workflow:design` y luego `/workflow:plan --only=backlog`; tras el backlog, `/workflow:design` (si aún no hay tech spec) o `/workflow:start 1`.
 
-# Detecta:
-# ✅ PRD completado
-# ⏳ Backlog en progreso (12/18 stories)
-# → Continua desde la story 13
-```
+## Agentes involucrados
+
+- **product-owner**: creación del PRD, personas, priorización, backlog
+- **tech-lead**: revisión de viabilidad técnica, ayuda con la estimación
+- **research-assistant**: investigación (`--research`)
+
+## Archivos generados
+
+| Archivo | Propósito | Modo |
+|---------|-----------|------|
+| `analysis/*.md` | Investigación, restricciones, riesgos | `--research` |
+| `prd.md`, `personas.md` | PRD con `FR-xxx` / `NFR-xxx`, personas | `--only=prd` |
+| `definition-of-done.md`, `dependencies-matrix.md`, `README.md` | Marco del backlog | `--only=backlog` |
+| `backlog/epics/`, `backlog/user-stories/` | Epics y stories (`**Implements**`) | `--only=backlog` |
+| `sprints/sprint-{N}-{slug}/` | Carpetas de sprint | `--only=backlog` |
+| `.bmad/sprint-status.yaml` | Stories registradas como `backlog` | `--only=backlog` |
+
+## Opción de reanudación
+
+Si se interrumpe, `/workflow:plan --continue` detecta lo que existe (PRD completo, backlog en 12/18 stories) y reanuda en el siguiente elemento que falta.
 
 ## Comandos relacionados
 
-- `/workflow:init` - Inicializar flujo de trabajo
-- `/workflow:analyze` - Fase anterior (Enterprise)
-- `/workflow:design` - Siguiente fase
-- `/workflow:status` - Verificar progreso
-- `/project:generate-prd` - Generacion directa del PRD
-- `/project:generate-backlog` - Generacion directa del backlog
+- `/workflow:init` - Inicializar el workflow
+- `/workflow:design` - Tech spec (entre el PRD y el backlog)
+- `/workflow:start` - Iniciar un sprint desde el backlog
+- `/workflow:status` - Comprobar el progreso
+- `/project:backlog` - Añadir, listar, editar y mover stories después
+- `/gate:check` - Validar el backlog
+- `/common:research-context7` - Investigación profunda con Context7 MCP

package/Dev/i18n/es/Workflow/commands/retro.md

@@ -340,7 +340,7 @@ Verbatims:
 ║    Iniciar el siguiente sprint                           ║
 ║                                                          ║
 ║  Si el proyecto está completo:                           ║
-║  → /common:release-checklist                             ║
+║  → /gate:check release                             ║
 ║    Preparar el lanzamiento                               ║
 ║  → /common:generate-changelog                            ║
 ║    Generar el changelog                                  ║

package/Dev/i18n/es/Workflow/commands/review.md

@@ -322,7 +322,7 @@ Duración total: 2h
 ║                                                          ║
 ║  Ver también:                                            ║
 ║  • /workflow:status  — Verificar el progreso general     ║
-║  • /sprint:status    — Ver métricas del sprint           ║
+║  • /workflow:status    — Ver métricas del sprint           ║
 ║                                                          ║
 ╚══════════════════════════════════════════════════════════╝
 ```