elsabro 4.2.1 → 5.0.0

package/agents/elsabro-analyst.md

@@ -75,6 +75,31 @@ Analizar proyecto existente para generar documentación.
 2. Identificar tecnologías usadas
 3. Mapear funcionalidades existentes
 4. Generar resumen en lenguaje simple
+
+### [PRD] Create PRD (BMAD Profile)
+Generar un Product Requirements Document completo con user stories y acceptance criteria.
+Activado por el perfil `bmad` en el flow engine.
+
+**Proceso:**
+1. Si existe `.planning/BRIEF.md`, usarlo como base
+2. Si no existe, ejecutar `[CB]` primero para crear el brief
+3. Convertir features del BRIEF en User Stories con formato:
+   - **As a** [persona], **I want to** [action], **So that** [benefit]
+   - Acceptance Criteria en formato **Given/When/Then**
+4. Identificar Non-Functional Requirements (performance, security, accessibility)
+5. Documentar Out of Scope explícitamente (mínimo 2 exclusiones)
+6. Definir Success Metrics medibles
+
+**Input:** BRIEF.md (opcional), user description
+**Output:** `.planning/PRD.md` (basado en `templates/PRD.md.template`)
+
+**Reglas:**
+- Cada story DEBE tener al menos 2 acceptance criteria
+- Cada acceptance criteria DEBE ser verificable por un test automatizado
+- Prioridades DEBEN ser P0 (must-have) / P1 (should-have) / P2 (nice-to-have)
+- Out of Scope DEBE listar al menos 2 exclusiones explícitas
+- NO inventar requisitos — preguntar al usuario si hay ambigüedad
+- Usar `AskUserQuestion` para clarificar personas, prioridades, y métricas
 </commands>
 
 <questioning_technique>

package/agents/elsabro-planner.md

@@ -276,3 +276,36 @@ wave: 1  # Número de wave
 9. Ejecutar plan-checker (si habilitado)
 ```
 </execution_flow>
+
+<bmad_commands>
+## Comandos BMAD (Perfil bmad)
+
+### [SOL] Create Solution Design (BMAD Profile)
+Diseñar la solución técnica detallada para cada story del PRD.
+Activado por el perfil `bmad` en el flow engine.
+
+**Proceso:**
+1. Leer `.planning/PRD.md` y `.planning/CONTROL-MANIFEST.md`
+2. Para cada story en el PRD:
+   a. Definir approach técnico específico
+   b. Listar archivos a crear/modificar
+   c. Especificar pasos de implementación (con código de Context7)
+   d. Definir comando de verificación ejecutable
+   e. Mapear acceptance criteria → implementación → test
+3. Crear Architecture Decision Records (ADRs) para decisiones no triviales
+4. Verificar compliance con CADA constraint del Control Manifest
+5. Documentar data flows y API contracts
+6. Estimar esfuerzo por story y asignar a waves
+
+**Input:** PRD.md, CONTROL-MANIFEST.md, codebase context
+**Output:** `.planning/SOLUTION.md` (basado en `templates/SOLUTION.md.template`)
+
+**Reglas:**
+- Cada story DEBE tener implementation steps concretos
+- Cada ADR DEBE listar al menos 2 alternativas consideradas con razón de rechazo
+- Compliance con Control Manifest DEBE ser explícita por cada constraint
+- Si una constraint del manifest no se puede cumplir → marcar como **BLOCKED** con razón
+- NO asumir tecnologías que no están en el manifest — preguntar si hay ambigüedad
+- Usar Context7 para TODOS los patrones de código (no pseudo-código)
+- Cada story debe poder verificarse independientemente con un comando bash
+</bmad_commands>

package/commands/elsabro/party.md

@@ -0,0 +1,253 @@
+---
+name: party
+description: Party Mode - Discusion multi-agente colaborativa donde 2-3 agentes debaten un tema desde diferentes perspectivas
+sync:
+  reads: [".elsabro/state.json"]
+  writes: [".elsabro/state.json"]
+---
+
+# /elsabro:party
+
+<command-name>party</command-name>
+
+<state_sync>
+## SINCRONIZACION DE ESTADO
+
+**IMPORTAR**: Ver `/references/state-sync.md` para protocolo completo.
+
+### Al Iniciar
+- Leer `.elsabro/state.json`
+- Verificar contexto actual
+- Activar persistent mode: `state.elsabro_mode = true`
+
+### Al Completar
+- Registrar en `history`
+- Guardar resumen en `state.context.party_summary`
+- Establecer `state.suggested_next = "discuss-phase"`
+</state_sync>
+
+## Proposito
+
+Facilitar una discusion colaborativa donde 2-3 agentes ELSABRO debaten un tema desde diferentes perspectivas. A diferencia de Agent Teams (ejecucion paralela de tareas separadas), Party Mode es **deliberacion** sobre el mismo tema.
+
+## Uso
+
+```bash
+# Party Mode automatico (selecciona agentes por relevancia)
+/elsabro:party "debemos usar microservicios o monolito?"
+
+# Party Mode con agentes especificos
+/elsabro:party "estrategia de testing" --agents=qa,executor,debugger
+
+# Party Mode con rounds limitados
+/elsabro:party "arquitectura del backend" --rounds=2
+```
+
+## Agent Personality Cards
+
+Cada agente tiene una personalidad distinta que guia sus contribuciones:
+
+### Executor (Pragmatico)
+- **Perspectiva:** "Esto funciona en la practica?"
+- **Enfoque:** Factibilidad, velocidad, complejidad real
+- **Pregunta tipica:** "Cuantas horas lleva implementar esto?"
+
+### QA (Esceptico constructivo)
+- **Perspectiva:** "Que puede salir mal?"
+- **Enfoque:** Edge cases, testing, fiabilidad
+- **Pregunta tipica:** "Y si el input es null? Y si hay 10K usuarios simultaneos?"
+
+### Debugger (Detective)
+- **Perspectiva:** "He visto esto fallar antes"
+- **Enfoque:** Patrones de error, root causes, observabilidad
+- **Pregunta tipica:** "Como vamos a diagnosticar problemas en produccion?"
+
+### Planner (Arquitecto)
+- **Perspectiva:** "Pensemos a largo plazo"
+- **Enfoque:** Escalabilidad, mantenibilidad, patrones
+- **Pregunta tipica:** "Como se ve esto en 6 meses con 3x mas features?"
+
+### Analyst (Abogado del usuario)
+- **Perspectiva:** "El usuario importa mas que el codigo"
+- **Enfoque:** UX, requisitos, valor de negocio
+- **Pregunta tipica:** "Esto realmente resuelve lo que el usuario necesita?"
+
+### Quick-Dev (Velocista)
+- **Perspectiva:** "Menos es mas"
+- **Enfoque:** MVP, simplicidad, iteracion rapida
+- **Pregunta tipica:** "Cual es la version mas simple que aporta valor?"
+
+### UX Designer (Empatico)
+- **Perspectiva:** "Como se siente usar esto?"
+- **Enfoque:** Flujos, accesibilidad, consistencia visual
+- **Pregunta tipica:** "El usuario sabe que hacer en este paso?"
+
+### Tech Writer (Comunicador)
+- **Perspectiva:** "Si no se puede explicar, no se entiende"
+- **Enfoque:** Claridad, documentacion, onboarding
+- **Pregunta tipica:** "Un developer nuevo puede entender esto en 10 minutos?"
+
+### Scrum Master (Facilitador)
+- **Perspectiva:** "El equipo primero"
+- **Enfoque:** Proceso, bloqueos, comunicacion
+- **Pregunta tipica:** "Esto genera dependencias entre equipos?"
+
+## Proceso
+
+### Paso 1: Seleccion de Agentes
+
+```
+Agent Relevance Map:
+┌─────────────────────────────────────────────────────┐
+│  Topic Analysis: "estrategia de testing"            │
+├─────────────────────────────────────────────────────┤
+│  Relevance Score:                                   │
+│  ★★★ QA (testing expert)              → SELECTED   │
+│  ★★★ Executor (implementation view)   → SELECTED   │
+│  ★★☆ Debugger (error patterns)        → SELECTED   │
+│  ★☆☆ Planner (architecture)           → reserve    │
+│  ☆☆☆ UX Designer (not relevant)       → skip       │
+└─────────────────────────────────────────────────────┘
+```
+
+Seleccion automatica basada en keywords del topic:
+- **testing/quality/bugs** → QA, Executor, Debugger
+- **architecture/design/scale** → Planner, Executor, Debugger
+- **UX/UI/frontend** → UX Designer, Analyst, Quick-Dev
+- **process/team/sprint** → Scrum Master, Planner, Analyst
+- **requirements/scope/users** → Analyst, Planner, QA
+- **performance/optimization** → Debugger, Executor, Planner
+
+### Paso 2: Deliberacion (Single-Agent Simulation)
+
+La implementacion v1 usa **single-agent simulation**: un agente encarna secuencialmente a cada personalidad, generando respuestas autenticas desde cada perspectiva.
+
+```
+╔══════════════════════════════════════════════════════╗
+║  PARTY MODE: "Debemos usar microservicios?"          ║
+║  Agentes: Planner, Executor, QA                      ║
+║  Round: 1/3                                          ║
+╠══════════════════════════════════════════════════════╣
+║                                                      ║
+║  [Planner] A largo plazo, microservicios dan         ║
+║  flexibilidad para escalar equipos. Pero el costo    ║
+║  inicial es alto. Recomiendo empezar monolito        ║
+║  modular con boundaries claros.                      ║
+║                                                      ║
+║  [Executor] De acuerdo con el monolito modular.      ║
+║  Microservicios para un equipo de 3 personas es      ║
+║  over-engineering. Pero necesitamos API contracts     ║
+║  claros desde el dia 1 para facilitar la separacion  ║
+║  futura.                                             ║
+║                                                      ║
+║  [QA] Mi preocupacion: si no definimos boundaries    ║
+║  ahora, el monolito se convierte en un big ball of   ║
+║  mud. Propongo: domain modules con interfaces        ║
+║  explicitas + integration tests por modulo.          ║
+║                                                      ║
+╠══════════════════════════════════════════════════════╣
+║  Round 2: Reacciones...                              ║
+╚══════════════════════════════════════════════════════╝
+```
+
+### Paso 3: Rounds de Reaccion
+
+Cada round despues del primero permite a los agentes **reaccionar** a lo que dijeron los otros:
+
+- **Acuerdos:** "Concuerdo con [Agent] sobre..."
+- **Desacuerdos:** "No estoy seguro sobre lo que dice [Agent]..."
+- **Builds:** "Expandiendo lo que dijo [Agent]..."
+- **Preguntas:** "Le preguntaria a [Agent]: que pasa si...?"
+
+Rounds por defecto: 3 (configurable con --rounds)
+
+### Paso 4: Sintesis
+
+Al final, generar consenso y puntos de debate:
+
+```
+╔══════════════════════════════════════════════════════╗
+║  PARTY SUMMARY                                       ║
+╠══════════════════════════════════════════════════════╣
+║                                                      ║
+║  Consenso (todos de acuerdo):                        ║
+║  • Empezar con monolito modular                     ║
+║  • API contracts claros desde dia 1                 ║
+║  • Integration tests por modulo                     ║
+║                                                      ║
+║  Debate abierto (sin consenso):                      ║
+║  • Cuando migrar a microservicios?                  ║
+║    - Planner: cuando haya 3+ equipos               ║
+║    - Executor: cuando un modulo sea bottleneck      ║
+║                                                      ║
+║  Action items sugeridos:                             ║
+║  1. Definir domain boundaries                        ║
+║  2. Crear interface contracts entre modulos          ║
+║  3. Setup integration test framework                 ║
+║                                                      ║
+╚══════════════════════════════════════════════════════╝
+```
+
+### Paso 5: Documentacion
+
+Genera `.planning/PARTY-{topic-slug}-SUMMARY.md` usando template.
+
+## Implementacion Tecnica
+
+```javascript
+// Single-Agent Simulation (v1)
+// Un solo agente cambia de personalidad por iteracion
+
+const topic = inputs.topic;
+const agents = selectAgentsByRelevance(topic); // Top 3
+const rounds = inputs.rounds || 3;
+
+for (let round = 1; round <= rounds; round++) {
+  for (const agent of agents) {
+    const response = generateResponse({
+      personality: agent.personality,
+      topic: topic,
+      round: round,
+      previousResponses: history,
+      instruction: round === 1
+        ? "Da tu perspectiva inicial sobre el tema"
+        : "Reacciona a lo que dijeron los otros agentes"
+    });
+    history.push({ agent: agent.name, round, response });
+  }
+}
+
+// Sintetizar
+const summary = synthesize(history);
+```
+
+## Opciones
+
+| Opcion | Default | Descripcion |
+|--------|---------|-------------|
+| `--agents` | auto | Agentes especificos (separados por coma) |
+| `--rounds` | 3 | Numero de rounds de deliberacion |
+| `--focus` | general | Enfocar discusion: risks, approach, scope, architecture |
+| `--save` | true | Guardar resumen en .planning/ |
+
+<siguiente_paso>
+## Siguiente Paso
+
+Al completar el party mode, establecer en state.json:
+```javascript
+state.context = state.context || {};
+state.context.party_summary = summaryPath;
+state.context.party_consensus = consensusPoints;
+state.context.party_debates = openDebates;
+state.suggested_next = "discuss-phase";
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+```
+
+Mostrar al usuario:
+```
+## Siguiente Paso
+
+→ /elsabro:discuss-phase — profundizar en los puntos de debate
+→ /elsabro:plan — planificar basado en el consenso alcanzado
+```
+</siguiente_paso>

package/commands/elsabro/set-profile.md

@@ -53,6 +53,7 @@ Cambiar rápidamente el perfil de comportamiento de ELSABRO. Los perfiles son pr
 /elsabro:set-profile yolo
 /elsabro:set-profile careful
 /elsabro:set-profile default
+/elsabro:set-profile bmad
 ```
 
 ## Perfiles Disponibles
@@ -125,6 +126,36 @@ Ideal para:
 
 ---
 
+### 📋 BMAD (Spec-Driven)
+
+Desarrollo guiado por especificaciones formales (PRD → Manifest → Solution → Implementation).
+
+```
+Settings:
+- auto-commit: false
+- auto-tests: true
+- require-tests: true
+- parallel-agents: true
+- verbosity: verbose
+- default-flow: bmad
+- extra: require-prd, require-manifest, require-solution, spec-compliance-review
+```
+
+Ideal para:
+- Proyectos con múltiples stakeholders
+- Requisitos complejos que necesitan trazabilidad
+- Equipos que quieren documentación formal antes de implementar
+- Desarrollo con acceptance criteria verificables
+
+Fase BMAD:
+```
+Analysis → Planning → Solutioning → Implementation
+    ↓          ↓           ↓              ↓
+  PRD.md    PLAN.md   SOLUTION.md     Código + Tests
+```
+
+---
+
 ### 🎓 Beginner (Learning)
 
 Explicaciones detalladas, guía paso a paso.

package/commands/elsabro/settings.md

@@ -193,16 +193,16 @@ AskUserQuestion({
       multiSelect: false
     },
     {
-      question: "¿Quieres que ELSABRO use múltiples agentes en paralelo para trabajar más rápido?",
-      header: "Paralelo",
+      question: "¿Quieres que ELSABRO use Agent Teams (múltiples agentes coordinados) para trabajar más rápido?",
+      header: "Agent Teams",
       options: [
         {
-          label: "Sí (Recomendado)",
-          description: "ELSABRO lanza 2-4 agentes trabajando simultáneamente (exploración, implementación, testing). Más rápido pero usa más recursos del API."
+          label: "Sí con Agent Teams (Recomendado)",
+          description: "ELSABRO crea equipos de 2-4 agentes que se coordinan entre sí (TeamCreate + SendMessage). Se comunican, comparten progreso, y trabajan en paralelo. Es como tener un equipo de desarrolladores. Más rápido pero usa más recursos del API."
         },
         {
-          label: "No",
-          description: "Un solo agente a la vez, secuencial. Más lento pero más predecible y usa menos recursos. Útil si tienes límites de API."
+          label: "No, un agente a la vez",
+          description: "Un solo agente secuencial. Más lento pero más predecible y usa menos recursos. Útil si tienes límites de API o prefieres control total."
         }
       ],
       multiSelect: false

package/flows/development-flow.json

@@ -1,7 +1,7 @@
 {
   "id": "development_flow",
   "name": "Standard Development Flow",
-  "version": "4.0.0",
+  "version": "5.0.0",
   "description": "Workflow completo para desarrollar features con quality gates",
 
   "config": {
@@ -15,7 +15,7 @@
   "inputs": {
     "task": { "type": "string", "required": true, "description": "Descripción de la tarea" },
     "complexity": { "type": "enum", "values": ["low", "medium", "high"], "default": "medium" },
-    "profile": { "type": "enum", "values": ["default", "yolo", "careful", "teams"], "default": "default" }
+    "profile": { "type": "enum", "values": ["default", "yolo", "careful", "teams", "bmad"], "default": "default" }
   },
 
   "outputs": {
@@ -91,6 +91,7 @@
         "yolo": "yolo_execute",
         "careful": "careful_analyze",
         "teams": "teams_spawn",
+        "bmad": "bmad_analyze",
         "default": "standard_analyze"
       },
       "default": "standard_analyze"
@@ -236,6 +237,140 @@
       }
     },
 
+    {
+      "id": "bmad_analyze",
+      "type": "sequence",
+      "description": "BMAD Phase 1: Analysis - Generate PRD and Architecture overview",
+      "steps": [
+        {
+          "agent": "elsabro-analyst",
+          "as": "prd",
+          "model": "opus",
+          "inputs": {
+            "command": "[PRD]",
+            "task": "{{inputs.task}}",
+            "brief": "{{state.briefContent || ''}}",
+            "template": "templates/PRD.md.template"
+          }
+        },
+        {
+          "agent": "elsabro-planner",
+          "as": "architecture",
+          "model": "opus",
+          "inputs": {
+            "task": "Create architecture overview for: {{inputs.task}}",
+            "prd": "{{steps.prd.output}}"
+          }
+        }
+      ],
+      "outputs": {
+        "prd": "{{steps.prd.output}}",
+        "architecture": "{{steps.architecture.output}}"
+      },
+      "next": "interrupt_prd_approval"
+    },
+
+    {
+      "id": "interrupt_prd_approval",
+      "type": "interrupt",
+      "reason": "PRD and Architecture require human approval before planning",
+      "display": {
+        "title": "PRD Review (BMAD)",
+        "content": "Se ha generado el PRD con user stories y el documento de arquitectura. Revisa los artifacts antes de continuar.",
+        "artifacts": [".planning/PRD.md", ".planning/ARCHITECTURE.md"],
+        "options": [
+          { "id": "approve", "label": "Aprobar PRD y continuar" },
+          { "id": "modify", "label": "Modificar PRD" },
+          { "id": "reject", "label": "Cancelar" }
+        ]
+      },
+      "routes": {
+        "approve": "bmad_plan",
+        "modify": "bmad_analyze",
+        "reject": "end_cancelled"
+      }
+    },
+
+    {
+      "id": "bmad_plan",
+      "type": "sequence",
+      "description": "BMAD Phase 2: Planning - Break PRD into stories + human Control Manifest",
+      "steps": [
+        {
+          "agent": "elsabro-analyst",
+          "as": "stories",
+          "model": "opus",
+          "inputs": {
+            "task": "Break approved PRD into prioritized epics and stories with acceptance criteria",
+            "prd": "{{nodes.bmad_analyze.outputs.prd}}"
+          }
+        }
+      ],
+      "outputs": {
+        "stories": "{{steps.stories.output}}"
+      },
+      "next": "interrupt_manifest"
+    },
+
+    {
+      "id": "interrupt_manifest",
+      "type": "interrupt",
+      "reason": "Control Manifest needed - human defines constraints before code generation",
+      "display": {
+        "title": "Control Manifest (BMAD)",
+        "content": "Antes de generar codigo, define tus constraints en el Control Manifest. Esto establece los guardarrailes que los agentes DEBEN respetar.",
+        "template": "templates/CONTROL-MANIFEST.md.template",
+        "options": [
+          { "id": "auto", "label": "Generar automaticamente basado en PRD y tech stack" },
+          { "id": "manual", "label": "Lo creo yo manualmente" }
+        ]
+      },
+      "routes": {
+        "auto": "bmad_solution",
+        "manual": "bmad_solution"
+      }
+    },
+
+    {
+      "id": "bmad_solution",
+      "type": "agent",
+      "description": "BMAD Phase 3: Solutioning - Technical design per story with ADRs",
+      "agent": "elsabro-planner",
+      "config": { "model": "opus", "timeout": 600000 },
+      "inputs": {
+        "command": "[SOL]",
+        "prd": "{{nodes.bmad_analyze.outputs.prd}}",
+        "stories": "{{nodes.bmad_plan.outputs.stories}}",
+        "architecture": "{{nodes.bmad_analyze.outputs.architecture}}",
+        "task": "{{inputs.task}}"
+      },
+      "outputs": {
+        "solution": "{{output}}"
+      },
+      "next": "interrupt_solution_approval"
+    },
+
+    {
+      "id": "interrupt_solution_approval",
+      "type": "interrupt",
+      "reason": "Solution design requires approval before implementation starts",
+      "display": {
+        "title": "Solution Review (BMAD)",
+        "content": "Se ha disenado la solucion tecnica para cada story con ADRs y compliance check contra el Control Manifest. Revisa antes de implementar.",
+        "artifacts": [".planning/SOLUTION.md"],
+        "options": [
+          { "id": "approve", "label": "Aprobar solucion y comenzar implementacion" },
+          { "id": "modify", "label": "Modificar diseno" },
+          { "id": "reject", "label": "Cancelar" }
+        ]
+      },
+      "routes": {
+        "approve": "parallel_implementation",
+        "modify": "bmad_solution",
+        "reject": "end_cancelled"
+      }
+    },
+
     {
       "id": "standard_analyze",
       "type": "parallel",
@@ -298,7 +433,7 @@
           "config": { "model": "opus", "timeout": 900000 },
           "inputs": {
             "task": "{{inputs.task}}",
-            "plan": "{{nodes.merge_analysis.outputs.plan || nodes.careful_analyze.outputs.detailed_plan}}",
+            "plan": "{{nodes.merge_analysis.outputs.plan || nodes.careful_analyze.outputs.detailed_plan || nodes.bmad_solution.outputs.solution}}",
             "patterns": "{{state.patterns}}",
             "mistakes": "{{state.mistakes}}"
           }
@@ -309,7 +444,7 @@
           "config": { "model": "opus", "timeout": 600000 },
           "inputs": {
             "task": "Crear tests para: {{inputs.task}}",
-            "plan": "{{nodes.merge_analysis.outputs.plan || nodes.careful_analyze.outputs.detailed_plan}}"
+            "plan": "{{nodes.merge_analysis.outputs.plan || nodes.careful_analyze.outputs.detailed_plan || nodes.bmad_solution.outputs.solution}}"
           }
         }
       ],

package/hooks/hooks-config-updated.json

@@ -156,6 +156,22 @@
       "agent-teams": true,
       "blocking-review": true,
       "max-review-iterations": 5
+    },
+
+    "bmad": {
+      "description": "Perfil BMAD - Spec-Driven Development con PRD, Control Manifest y Solution Design",
+      "auto-test-on-edit": true,
+      "lint-on-save": true,
+      "confirm-destructive": true,
+      "skill-discovery": true,
+      "agent-teams": true,
+      "blocking-review": true,
+      "max-review-iterations": 5,
+      "require-prd": true,
+      "require-manifest": true,
+      "require-solution": true,
+      "spec-compliance-review": true,
+      "bmad-phases": ["analysis", "planning", "solutioning", "implementation"]
     }
   },
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elsabro",
-  "version": "4.2.1",
-  "description": "Sistema de desarrollo AI-powered para Claude Code - Next Step Suggestions, Stitch UI Design, Agent Teams, blocking code review, orquestación avanzada con checkpointing, memoria multi-nivel y flows declarativos",
+  "version": "5.0.0",
+  "description": "Sistema de desarrollo AI-powered para Claude Code - BMAD Method Integration, Spec-Driven Development, Party Mode, Next Step Suggestions, Stitch UI Design, Agent Teams, blocking code review, orquestación avanzada con flows declarativos",
   "bin": {
     "elsabro": "bin/install.js"
   },

package/references/enforcement-rules.md

@@ -238,6 +238,44 @@ Task({ subagent_type: "pr-review-toolkit:silent-failure-hunter", prompt: "..." }
 
 ---
 
+### 9. Spec Compliance OBLIGATORIO en Perfil BMAD
+
+**PROHIBIDO** (cuando profile=bmad): Ejecutar implementación sin que existan y estén aprobados los 3 artefactos de spec:
+1. PRD.md (aprobado por usuario)
+2. CONTROL-MANIFEST.md (firmado por usuario)
+3. SOLUTION.md (aprobado por usuario)
+
+**OBLIGATORIO**: Verificar que los 3 artefactos existen antes de pasar a implementación.
+
+**Secuencia BMAD:**
+```
+1. Analysis: Generar PRD → interrupt → aprobación usuario
+2. Planning: Generar Control Manifest → interrupt → aprobación usuario
+3. Solutioning: Generar Solution Design → interrupt → aprobación usuario
+4. Implementation: SOLO si los 3 están aprobados
+```
+
+**Aplica a**: Cualquier ejecución bajo profile `bmad` en el flow engine.
+
+**Ejemplo correcto:**
+```javascript
+// Verificar artefactos BMAD antes de implementar
+if (state.context?.bmad_phase === "implementation") {
+  assert(state.context.prd_approved, "PRD must be approved");
+  assert(state.context.manifest_approved, "Manifest must be approved");
+  assert(state.context.solution_approved, "Solution must be approved");
+}
+```
+
+**Ejemplo INCORRECTO:**
+```javascript
+// VIOLACIÓN: Saltar a implementación sin Solution aprobado
+state.context.bmad_phase = "implementation";
+// ← Sin verificar artefactos
+```
+
+---
+
 ## MATRIZ DE COMANDOS
 
 ### Comandos Core (Workflow Principal)

package/references/next-step-engine.md

@@ -60,6 +60,15 @@ Al final de cada `<process>`, mostrar:
 | progress | context-dependent | → /elsabro:execute — continuar trabajo activo | → /elsabro:check-todos — revisar pendientes |
 | exit | "resume-work" | → /elsabro:resume-work — cuando vuelvas | |
 
+### BMAD Profile Commands
+
+| Comando (BMAD) | suggested_next | Sugerencia Primaria | Alternativa |
+|----------------|---------------|---------------------|-------------|
+| bmad_analyze | "bmad_plan" | → Aprobar PRD y continuar a Planning | → Revisar/editar PRD antes de avanzar |
+| bmad_plan | "bmad_solution" | → Aprobar Manifest y continuar a Solutioning | → Editar Control Manifest |
+| bmad_solution | "execute" | → Aprobar Solution y ejecutar implementación | → Revisar Solution Design |
+| party | "discuss-phase" | → /elsabro:discuss-phase — discutir hallazgos | → /elsabro:plan — planificar basado en discusión |
+
 ## Contextual Overrides
 
 The suggested_next can be overridden based on context:

package/references/state-sync.md

@@ -134,6 +134,11 @@ Fases: initializing → diagnosing → fixing → verifying → done
 Fases: initializing → executing → done
 ```
 
+### BMAD Flow (profile=bmad)
+```
+Fases: bmad_analyze → prd_approval → bmad_plan → manifest_approval → bmad_solution → solution_approval → implementation → done
+```
+
 ---
 
 ## CONTEXTO QUE CADA COMANDO DEBE PASAR
@@ -194,6 +199,46 @@ Fases: initializing → executing → done
 }
 ```
 
+### BMAD Flow Context Fields
+
+#### bmad_analyze → bmad_plan
+```json
+{
+  "bmad_phase": "planning",
+  "prd_file": ".planning/PRD.md",
+  "prd_approved": true,
+  "architecture_overview": "resumen de arquitectura",
+  "user_stories_count": 5,
+  "acceptance_criteria_count": 12
+}
+```
+
+#### bmad_plan → bmad_solution
+```json
+{
+  "bmad_phase": "solutioning",
+  "prd_file": ".planning/PRD.md",
+  "manifest_file": ".planning/CONTROL-MANIFEST.md",
+  "manifest_approved": true,
+  "tech_constraints": ["constraint1", "constraint2"],
+  "plan_file": ".planning/01-01-PLAN.md"
+}
+```
+
+#### bmad_solution → execute
+```json
+{
+  "bmad_phase": "implementation",
+  "prd_file": ".planning/PRD.md",
+  "manifest_file": ".planning/CONTROL-MANIFEST.md",
+  "solution_file": ".planning/SOLUTION.md",
+  "solution_approved": true,
+  "stories_to_implement": ["story1", "story2"],
+  "adrs": ["ADR-001", "ADR-002"],
+  "ready_for_execution": true
+}
+```
+
 ---
 
 ## TRANSICIONES VÁLIDAS

package/templates/CONTROL-MANIFEST.md.template

@@ -0,0 +1,86 @@
+# Control Manifest: {{feature_name}}
+
+> This document is created by the HUMAN before AI agents generate code.
+> It serves as guardrails that agents MUST respect during implementation.
+> Generated by ELSABRO (BMAD Profile) | Date: {{date}}
+
+## Technology Constraints
+
+| Category | Constraint | Reason |
+|----------|-----------|--------|
+| Language | {{e.g., TypeScript strict mode}} | {{reason}} |
+| Framework | {{e.g., Next.js 15 App Router}} | {{reason}} |
+| Database | {{e.g., PostgreSQL via Prisma}} | {{reason}} |
+| Auth | {{e.g., Clerk}} | {{reason}} |
+| Styling | {{e.g., Tailwind CSS}} | {{reason}} |
+
+## Architecture Boundaries
+
+### MUST (mandatory patterns)
+- {{pattern that must be followed}}
+- {{pattern that must be followed}}
+
+### MUST NOT (forbidden patterns)
+- {{pattern that is forbidden}}
+- {{pattern that is forbidden}}
+
+### PREFER (recommended but not mandatory)
+- {{preferred pattern}}
+- {{preferred pattern}}
+
+## Performance Constraints
+
+| Metric | Target | Measurement |
+|--------|--------|-------------|
+| Page Load | < {{X}}s | Lighthouse |
+| API Response | < {{X}}ms | p95 latency |
+| Bundle Size | < {{X}} KB | webpack-bundle-analyzer |
+| Memory | < {{X}} MB | Chrome DevTools |
+
+## Coding Standards
+
+| Area | Standard |
+|------|----------|
+| Testing | {{e.g., Vitest, min 80% coverage}} |
+| Linting | {{e.g., ESLint strict + Prettier}} |
+| Naming (files) | {{e.g., kebab-case}} |
+| Naming (components) | {{e.g., PascalCase}} |
+| Naming (functions) | {{e.g., camelCase}} |
+| Commits | {{e.g., Conventional Commits}} |
+
+## Security Requirements
+
+- [ ] Input validation on all user inputs
+- [ ] SQL injection prevention (parameterized queries only)
+- [ ] XSS prevention (sanitized output)
+- [ ] CSRF protection
+- [ ] Rate limiting on public endpoints
+- [ ] {{custom_requirement}}
+
+## Dependency Policy
+
+### Pre-Approved
+{{list of packages that can be used freely}}
+
+### Forbidden
+{{packages that must NOT be used, with reason}}
+
+### Requires Human Approval
+{{packages that need explicit OK before adding}}
+
+## File Structure Conventions
+
+```
+{{expected file/folder structure}}
+```
+
+## Signed By
+
+- **Human:** _______________
+- **Date:** {{date}}
+- **Scope:** {{what this manifest covers}}
+
+---
+
+> Agents: If you cannot comply with any constraint above, you MUST stop
+> and report the conflict. Do NOT silently bypass constraints.

package/templates/PARTY-SUMMARY.md.template

@@ -0,0 +1,74 @@
+# Party Mode Summary: {{topic}}
+
+> Generated by ELSABRO Party Mode
+> Date: {{date}}
+> Rounds: {{rounds}}
+
+## Participants
+
+| Agent | Perspective | Key Contribution |
+|-------|------------|------------------|
+| {{agent_1_name}} | {{agent_1_perspective}} | {{agent_1_key_point}} |
+| {{agent_2_name}} | {{agent_2_perspective}} | {{agent_2_key_point}} |
+| {{agent_3_name}} | {{agent_3_perspective}} | {{agent_3_key_point}} |
+
+## Discussion Rounds
+
+### Round 1: Initial Perspectives
+
+**{{agent_1_name}}:**
+{{agent_1_round1}}
+
+**{{agent_2_name}}:**
+{{agent_2_round1}}
+
+**{{agent_3_name}}:**
+{{agent_3_round1}}
+
+### Round 2: Reactions
+
+{{round_2_content}}
+
+### Round 3: Convergence
+
+{{round_3_content}}
+
+## Consensus Points
+
+Items where all participants agreed:
+
+- {{consensus_1}}
+- {{consensus_2}}
+- {{consensus_3}}
+
+## Open Debates
+
+Items where participants disagreed or need more discussion:
+
+| Topic | Position A | Position B | Suggested Resolution |
+|-------|-----------|-----------|---------------------|
+| {{debate_1_topic}} | {{debate_1_pos_a}} | {{debate_1_pos_b}} | {{debate_1_resolution}} |
+
+## Action Items
+
+Suggested next steps based on the discussion:
+
+- [ ] {{action_1}}
+- [ ] {{action_2}}
+- [ ] {{action_3}}
+
+## Key Insights
+
+Notable observations that emerged during deliberation:
+
+1. {{insight_1}}
+2. {{insight_2}}
+
+## Relevance to Current Project
+
+{{project_relevance}}
+
+---
+
+> Use `/elsabro:discuss-phase` to deep-dive into any open debate
+> Use `/elsabro:plan` to turn consensus into an executable plan

package/templates/PRD.md.template

@@ -0,0 +1,83 @@
+# PRD: {{project_name}}
+
+> Generated by ELSABRO Analyst (BMAD Profile)
+> Version: 1.0 | Date: {{date}}
+
+## 1. Problem Statement
+
+{{one_sentence_problem}}
+
+## 2. Target Users
+
+| Persona | Description | Primary Need | Pain Point |
+|---------|-------------|-------------|------------|
+| {{persona_1}} | {{desc}} | {{need}} | {{pain}} |
+| {{persona_2}} | {{desc}} | {{need}} | {{pain}} |
+
+## 3. User Stories
+
+### Epic: {{epic_name}}
+
+#### Story {{N}}: {{story_title}}
+
+**As a** {{persona}},
+**I want to** {{action}},
+**So that** {{benefit}}.
+
+**Acceptance Criteria:**
+- [ ] **Given** {{context}}, **when** {{action}}, **then** {{expected_result}}
+- [ ] **Given** {{context}}, **when** {{action}}, **then** {{expected_result}}
+
+**Priority:** P0 | P1 | P2
+**Complexity:** Low | Medium | High
+**Dependencies:** {{list or "None"}}
+
+---
+
+## 4. Non-Functional Requirements
+
+### Performance
+- {{perf_criteria}}
+
+### Security
+- {{security_criteria}}
+
+### Accessibility
+- {{a11y_criteria}}
+
+### Scalability
+- {{scale_criteria}}
+
+## 5. Out of Scope
+
+> Explicitly listing what this PRD does NOT cover prevents scope creep.
+
+- {{explicit_exclusion_1}}
+- {{explicit_exclusion_2}}
+- {{explicit_exclusion_3}}
+
+## 6. Success Metrics
+
+| Metric | Target | How to Measure |
+|--------|--------|----------------|
+| {{metric_1}} | {{target}} | {{measurement}} |
+| {{metric_2}} | {{target}} | {{measurement}} |
+
+## 7. Technical Constraints
+
+> These constraints come from the Control Manifest (if available).
+
+- Language: {{language}}
+- Framework: {{framework}}
+- Database: {{database}}
+
+## 8. Open Questions
+
+- [ ] {{question_1}}
+- [ ] {{question_2}}
+
+## 9. Revision History
+
+| Version | Date | Author | Changes |
+|---------|------|--------|---------|
+| 1.0 | {{date}} | ELSABRO Analyst | Initial PRD |

package/templates/SOLUTION.md.template

@@ -0,0 +1,122 @@
+# Solution Design: {{feature_name}}
+
+> Generated by ELSABRO Planner (BMAD Profile)
+> PRD Reference: {{prd_path}}
+> Control Manifest: {{manifest_path}}
+> Date: {{date}}
+
+## Architecture Decisions
+
+### ADR-001: {{decision_title}}
+
+- **Status:** Proposed | Accepted | Deprecated
+- **Context:** {{why this decision is needed}}
+- **Decision:** {{what was decided}}
+- **Alternatives Considered:**
+  1. {{alternative_1}} — rejected because {{reason}}
+  2. {{alternative_2}} — rejected because {{reason}}
+- **Consequences:** {{positive and negative impact of this decision}}
+
+---
+
+## Implementation Plan per Story
+
+### Story: {{story_title}}
+
+**PRD Reference:** Section {{N}}, Story {{M}}
+**Priority:** {{priority}}
+
+**Technical Approach:**
+- Files to create: {{list}}
+- Files to modify: {{list}}
+- Dependencies needed: {{list}}
+
+**Implementation Steps:**
+1. {{step_1}}
+2. {{step_2}}
+3. {{step_3}}
+
+**Verification:**
+```bash
+{{command to verify this story works}}
+```
+
+**Acceptance Criteria Mapping:**
+| AC from PRD | Implementation | Test |
+|-------------|---------------|------|
+| Given X, When Y, Then Z | {{how it's implemented}} | {{test file/case}} |
+
+---
+
+## Data Flow
+
+```
+{{user_action}}
+  → {{frontend_component}}
+    → {{api_endpoint}}
+      → {{service_layer}}
+        → {{database}}
+      ← {{response}}
+    ← {{rendered_result}}
+```
+
+## API Contracts (if applicable)
+
+### {{endpoint_name}}
+```
+{{METHOD}} /api/{{path}}
+
+Request:
+  Headers: {{required_headers}}
+  Body: {
+    {{field}}: {{type}} // {{description}}
+  }
+
+Response (200):
+  {
+    {{field}}: {{type}}
+  }
+
+Response (4xx/5xx):
+  {
+    error: string,
+    code: string
+  }
+```
+
+## Database Changes (if applicable)
+
+### New Tables/Collections
+```sql
+{{schema changes}}
+```
+
+### Migrations
+- {{migration_description}}
+
+## Compliance with Control Manifest
+
+| Constraint | Status | Implementation Notes |
+|-----------|--------|---------------------|
+| {{constraint_1}} | Compliant | {{how it complies}} |
+| {{constraint_2}} | Compliant | {{how it complies}} |
+| {{constraint_3}} | BLOCKED | {{why it can't comply + proposed alternative}} |
+
+## Risk Assessment
+
+| Risk | Probability | Impact | Mitigation |
+|------|------------|--------|------------|
+| {{risk_1}} | Low/Med/High | Low/Med/High | {{mitigation}} |
+
+## Estimated Effort
+
+| Story | Complexity | Estimated Waves |
+|-------|-----------|----------------|
+| {{story_1}} | {{low/med/high}} | Wave {{N}} |
+| {{story_2}} | {{low/med/high}} | Wave {{N}} |
+
+## Revision History
+
+| Version | Date | Author | Changes |
+|---------|------|--------|---------|
+| 1.0 | {{date}} | ELSABRO Planner | Initial solution design |