elsabro 5.1.0 → 6.0.0

package/agents/elsabro-executor.md

@@ -69,6 +69,31 @@ CHECKPOINT (preguntar):
 ```
 </critical_rules>
 
+<skill_awareness>
+## Skill Awareness
+
+### Si recibes skills en tu contexto (seccion "SKILLS DE REFERENCIA"):
+
+1. **Lee las guias ANTES de implementar** — los skills contienen patrones verificados
+2. **Sigue la estructura de archivos sugerida** en `<project_structure>`
+3. **Usa los pre-requisitos** de `<pre_requisites>` para verificar dependencias
+4. **Aplica los patrones de codigo** de las secciones de implementacion
+5. **En tu output, menciona que skill usaste** para cada decision
+
+### Si NO recibes skills pero la tarea parece relevante:
+
+1. Busca en `skills/` con Glob("skills/*.md") por archivos relevantes
+2. Lee el archivo con Read() y usa como referencia
+3. Prioriza skills de: auth, database, testing, api
+
+### Keywords que activan busqueda de skills:
+- auth/login/registro → skills/auth-setup.md
+- database/db/prisma → skills/database-setup.md
+- test/testing/jest → skills/testing-setup.md
+- api/endpoint/rest → skills/api-setup.md
+- payments/stripe → skills/payments-setup.md
+</skill_awareness>
+
 <execution_flow>
 ## Flujo de Ejecución
 

package/agents/elsabro-planner.md

@@ -46,6 +46,16 @@ Cada tarea debe:
 - Generar un commit significativo
 </critical_rules>
 
+<skill_awareness>
+## Skill Awareness (Planner)
+
+Si recibes skills en tu contexto:
+1. Referencia los skills relevantes en el PLAN.md que crees
+2. Usa las estructuras de archivos sugeridas por los skills
+3. Incorpora los pre-requisitos como dependencias del plan
+4. Menciona que skill aplica a cada tarea del plan
+</skill_awareness>
+
 <research_first>
 ## Protocolo: Research-Before-Plan
 

package/commands/elsabro/debug.md

@@ -38,6 +38,24 @@ sync:
 - Establecer `state.suggested_next = "verify-work"`
 </state_sync>
 
+<skill_discovery>
+## Skill Discovery (Pre-Debug)
+
+**ANTES de investigar el problema**, descubrir skills de debugging relevantes:
+
+```javascript
+// Ejecutar skill discovery enfocado en debugging
+const discoveryResult = Bash(`bash ./hooks/skill-discovery.sh "debug ${inputs.problem || args}" "medium"`, { timeout: 30000 });
+
+// Guardar en estado
+state.context = state.context || {};
+state.context.available_skills = JSON.parse(discoveryResult).recommended || [];
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+```
+
+Skills de testing, sentry, profiling y debugging pueden acelerar la investigación.
+</skill_discovery>
+
 <objective>
 Investigar y resolver bugs usando el método científico, no adivinando.
 

package/commands/elsabro/design-ui.md

@@ -4,6 +4,7 @@ description: Diseñar interfaces visuales con Stitch AI - genera screens y mocku
 allowed-tools:
   - Read
   - Write
+  - Bash
   - Task
   - TaskCreate
   - TaskUpdate
@@ -98,6 +99,24 @@ Write(".elsabro/context.md", generateHumanReadableContext(state));
 ```
 </state_sync>
 
+<skill_discovery>
+## Skill Discovery (Pre-Design)
+
+**ANTES de diseñar**, descubrir skills de UI relevantes:
+
+```javascript
+// Ejecutar skill discovery enfocado en UI/design
+const discoveryResult = Bash(`bash ./hooks/skill-discovery.sh "design ui ${inputs.task || args}" "medium"`, { timeout: 30000 });
+
+// Guardar en estado
+state.context = state.context || {};
+state.context.available_skills = JSON.parse(discoveryResult).recommended || [];
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+```
+
+Skills de stitch-ui-design, frontend-design y component libraries informan las decisiones de diseño.
+</skill_discovery>
+
 <objective>
 Diseñar interfaces visuales usando **Stitch AI** como motor de generación. Convierte descripciones de texto o requerimientos de fase en screens visuales profesionales.
 

package/commands/elsabro/execute.md

@@ -139,6 +139,74 @@ Write(".elsabro/context.md", generateHumanReadableContext(state));
 ```
 </state_sync>
 
+<skill_discovery>
+## Skill Discovery (Pre-Execution)
+
+**ANTES de ejecutar el plan**, descubrir skills para el stack:
+
+```javascript
+// Ejecutar skill discovery con la tarea
+const discoveryResult = Bash(`bash ./hooks/skill-discovery.sh "${inputs.task || state.context.current_feature || ''}" "medium"`, { timeout: 30000 });
+
+// Guardar en estado
+state.context = state.context || {};
+state.context.available_skills = JSON.parse(discoveryResult).recommended || [];
+
+// Informar al usuario
+if (state.context.available_skills.length > 0) {
+  output(`Skills cargados: ${state.context.available_skills.map(s => s.name).join(", ")}`);
+}
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+```
+
+Los skills proveen patrones de código verificados, configuraciones de setup, y guides de integración durante la implementación.
+</skill_discovery>
+
+<skill_injection>
+## Skill Injection (OBLIGATORIO despues de Discovery)
+
+**Si skill discovery encontro skills relevantes, CARGAR su contenido como contexto.**
+
+```javascript
+// 1. Obtener skills recomendados
+const recommendedSkills = state.context.available_skills || [];
+
+if (recommendedSkills.length > 0) {
+  // 2. Cargar contenido de los top-3 skills con match
+  const loadedSkills = [];
+  for (const skill of recommendedSkills.slice(0, 3)) {
+    const content = Read(`skills/${skill.id}.md`);
+    if (content) {
+      loadedSkills.push({
+        name: skill.id,
+        content: content
+      });
+    }
+  }
+
+  // 3. Guardar skills cargados en state
+  state.context.loaded_skills = loadedSkills;
+  Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+
+  // 4. Informar al usuario
+  output(`Skills cargados para esta ejecucion:`);
+  loadedSkills.forEach(s => output(`  - ${s.name}`));
+}
+```
+
+**GATE**: Cuando lances agentes executors, INCLUIR los skills en el prompt:
+```
+Si state.context.loaded_skills tiene contenido, agregar al prompt de CADA executor:
+
+"SKILLS DE REFERENCIA:
+[Para cada skill cargado:]
+### Skill: {name}
+{contenido del archivo .md}
+
+Usa estos skills como guia de patrones, estructura y mejores practicas."
+```
+</skill_injection>
+
 <objective>
 Ejecutar planes de una fase con:
 - **Sistema de Tasks para tracking real** de waves y dependencias
@@ -505,6 +573,41 @@ Para cada wave:
 TaskUpdate({ taskId: "wave-W-id", status: "in_progress" })
 ```
 
+<IMPERATIVO_AGENT_TEAMS>
+## ⛔ STOP — LEER ANTES DE LANZAR AGENTES PARALELOS
+
+**REGLA NO NEGOCIABLE (Rule 8):** Si vas a lanzar 2+ Task() para implementacion o review:
+
+1. **PRIMERO** → `TeamCreate({ team_name: "elsabro-impl", description: "..." })`
+2. **DESPUES** → `Task({ ..., team_name: "elsabro-impl", name: "executor-1" })`
+3. **AL FINAL** → `SendMessage({ type: "shutdown_request", ... })` para CADA teammate
+4. **ULTIMO** → `TeamDelete()`
+
+**Si ya lanzaste Task() sin TeamCreate: DETENTE AHORA. No continúes.**
+Vuelve arriba, crea el team, y relanza los agentes CON team_name.
+
+**NUNCA hagas esto:**
+```javascript
+// ⛔ PROHIBIDO — bare Task() sin team
+Task({ subagent_type: "elsabro-executor", prompt: "..." })
+Task({ subagent_type: "elsabro-qa", prompt: "..." })
+```
+
+**SIEMPRE haz esto:**
+```javascript
+// ✅ CORRECTO — con Agent Team
+TeamCreate({ team_name: "elsabro-impl", description: "Implementation" })
+Task({ subagent_type: "elsabro-executor", team_name: "elsabro-impl", name: "executor-1", prompt: "..." })
+Task({ subagent_type: "elsabro-qa", team_name: "elsabro-impl", name: "qa-1", prompt: "..." })
+// ... al completar ...
+SendMessage({ type: "shutdown_request", recipient: "executor-1", content: "Done" })
+SendMessage({ type: "shutdown_request", recipient: "qa-1", content: "Done" })
+TeamDelete()
+```
+
+**Excepcion UNICA:** Exploracion read-only con HAIKU (Paso 0) puede usar subagents sueltos.
+</IMPERATIVO_AGENT_TEAMS>
+
 ### Si hay múltiples planes en la wave → Paralelo (OPUS)
 ```javascript
 // Marcar todos los planes como in_progress
@@ -525,13 +628,20 @@ Write(".elsabro/state.json", JSON.stringify(state, null, 2));
 
 // Lanzar teammates OPUS en paralelo (UN SOLO MENSAJE)
 // MODELO: OPUS porque escriben código
+// SKILLS: Incluir loaded_skills en CADA prompt de executor
+const skillContext = state.context.loaded_skills?.length > 0
+  ? '\n\n## SKILLS DE REFERENCIA\n' + state.context.loaded_skills.map(s =>
+      '### Skill: ' + s.name + '\n' + s.content
+    ).join('\n\n---\n\n') + '\n\nUsa los skills como referencia de patrones y estructura de archivos.'
+  : '';
+
 Task({
   subagent_type: "elsabro-executor",
   model: "opus",  // ← OPUS para implementación
   team_name: "elsabro-impl",
   name: "executor-1",
   description: "Ejecutar Plan A",
-  prompt: "Implementa el Plan A siguiendo TDD..."
+  prompt: `Implementa el Plan A siguiendo TDD.${skillContext}`
 }) |
 Task({
   subagent_type: "elsabro-executor",
@@ -539,7 +649,7 @@ Task({
   team_name: "elsabro-impl",
   name: "executor-2",
   description: "Ejecutar Plan B",
-  prompt: "Implementa el Plan B siguiendo TDD..."
+  prompt: `Implementa el Plan B siguiendo TDD.${skillContext}`
 }) |
 Task({
   subagent_type: "elsabro-executor",
@@ -547,7 +657,7 @@ Task({
   team_name: "elsabro-impl",
   name: "executor-3",
   description: "Ejecutar Plan C",
-  prompt: "Implementa el Plan C siguiendo TDD..."
+  prompt: `Implementa el Plan C siguiendo TDD.${skillContext}`
 })
 
 // Al completar cada plan
@@ -740,6 +850,29 @@ Cuando termines, dime si funcionó o qué problemas encontraste.
 
 </process>
 
+<agent_teams_cleanup>
+## Agent Teams Cleanup (OBLIGATORIO)
+
+**Al completar TODAS las fases de implementacion y review:**
+
+```javascript
+// 1. Shutdown CADA teammate por nombre
+const teammates = ["executor-1", "executor-2", "executor-3", "reviewer-1", "reviewer-2", "reviewer-3"];
+for (const name of teammates) {
+  SendMessage({ type: "shutdown_request", recipient: name, content: "All phases complete" });
+}
+
+// 2. Eliminar team
+TeamDelete();
+
+// 3. Registrar en state
+state.current_flow.agent_teams_cleanup = true;
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+```
+
+**GATE**: No mostrar "Siguiente Paso" si agent_teams_cleanup !== true y hubo 2+ agentes.
+</agent_teams_cleanup>
+
 <code_review_gate>
 ## Code Review Gate (OBLIGATORIO - NO NEGOCIABLE)
 
@@ -763,6 +896,30 @@ Cuando termines, dime si funcionó o qué problemas encontraste.
 <siguiente_paso>
 ## Siguiente Paso
 
+### Self-Check (OBLIGATORIO antes de reportar resultado)
+
+Antes de mostrar "Siguiente Paso", verifica CADA UNO de estos items:
+
+```
+[ ] Si lance 2+ Task() en paralelo → ¿use TeamCreate primero?
+    SI: Continuar
+    NO: DETENERME. Crear team y relanzar.
+
+[ ] Si descubri skills relevantes → ¿los cargue con Read() y los pase al executor?
+    SI: Continuar
+    NO: DETENERME. Cargar skills y re-ejecutar.
+
+[ ] Si escribi/modifique codigo → ¿ejecute code review?
+    SI: Continuar
+    NO: DETENERME. Ejecutar code review.
+
+[ ] Si use Agent Teams → ¿ejecute SendMessage(shutdown) + TeamDelete?
+    SI: Continuar
+    NO: DETENERME. Hacer cleanup.
+```
+
+**Si alguna respuesta es NO: NO mostrar siguiente paso. Corregir primero.**
+
 Al completar, establecer en state.json:
 ```javascript
 // GATE CHECK 1: No escribir suggested_next sin code review
@@ -1214,3 +1371,22 @@ Al completar un plan:
 - [x] Tests: npm run test
 ```
 </summary_creation>
+
+<engine_integration>
+## Flow Engine (v6.0.0)
+
+The flow engine runtime is available at `flow-engine/src/index.js`.
+It can parse and execute `flows/development-flow.json`.
+
+Current status: Engine handles implemented nodes (19/42).
+Not-implemented nodes throw NotImplementedError with gap descriptions.
+
+For full engine-driven execution (future):
+```javascript
+const { FlowEngine } = require('./flow-engine/src/index.js');
+const flow = require('./flows/development-flow.json');
+const engine = new FlowEngine({ callbacks: { onAgent, onBash, onInterrupt, onCheckpoint, onParallel, onTeamRequired } });
+engine.loadFlow(flow);
+const result = await engine.run({ task, profile, complexity }, callbacks);
+```
+</engine_integration>

package/commands/elsabro/new.md

@@ -38,6 +38,29 @@ sync:
 - Establecer `state.context.suggested_args = "1"` para la primera fase
 </state_sync>
 
+<skill_discovery>
+## Skill Discovery (Pre-Work)
+
+**DESPUÉS de saber qué quiere crear el usuario**, descubrir skills del stack:
+
+```javascript
+// Ejecutar skill discovery con el tipo de proyecto
+const discoveryResult = Bash(`bash ./hooks/skill-discovery.sh "${inputs.projectType || args}" "medium"`, { timeout: 30000 });
+
+// Guardar en estado
+state.context = state.context || {};
+state.context.available_skills = JSON.parse(discoveryResult).recommended || [];
+
+// Informar al usuario
+if (state.context.available_skills.length > 0) {
+  output(`Skills para tu proyecto: ${state.context.available_skills.map(s => s.name).join(", ")}`);
+}
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+```
+
+Estos skills guían la configuración inicial del proyecto (nextjs-app, expo-app, auth-setup, etc.).
+</skill_discovery>
+
 <objective>
 Crear un proyecto nuevo con investigación previa, configuración correcta, y estructura lista para desarrollo.
 

package/commands/elsabro/plan.md

@@ -11,6 +11,9 @@ allowed-tools:
   - TaskCreate
   - TaskUpdate
   - TaskList
+  - TeamCreate
+  - TeamDelete
+  - SendMessage
   - WebSearch
   - AskUserQuestion
   - mcp__plugin_context7_context7__*
@@ -134,6 +137,58 @@ Write(".elsabro/context.md", generateHumanReadableContext(state));
 ```
 </state_sync>
 
+<skill_discovery>
+## Skill Discovery (Pre-Planning)
+
+**ANTES de explorar el codebase**, descubrir skills relevantes para la tarea:
+
+```javascript
+// Ejecutar skill discovery con la descripción de la tarea
+const discoveryResult = Bash(`bash ./hooks/skill-discovery.sh "${inputs.task || args}" "medium"`, { timeout: 30000 });
+
+// Guardar en estado
+state.context = state.context || {};
+state.context.available_skills = JSON.parse(discoveryResult).recommended || [];
+
+// Informar al usuario
+if (state.context.available_skills.length > 0) {
+  output(`Skills relevantes: ${state.context.available_skills.map(s => s.name).join(", ")}`);
+}
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+```
+
+Los skills descubiertos informan la fase de research (Context7 queries) y la creación del PLAN.md.
+</skill_discovery>
+
+<skill_injection>
+## Skill Injection (Para Planificacion)
+
+Despues de skill discovery, cargar skills relevantes para informar al planner:
+
+```javascript
+const recommendedSkills = state.context.available_skills || [];
+if (recommendedSkills.length > 0) {
+  const loadedSkills = [];
+  for (const skill of recommendedSkills.slice(0, 3)) {
+    const content = Read(`skills/${skill.id}.md`);
+    if (content) {
+      loadedSkills.push({ name: skill.id, content: content });
+    }
+  }
+  state.context.loaded_skills = loadedSkills;
+  Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+}
+```
+
+**Al lanzar el planner OPUS**: Incluir skills como contexto:
+```
+"Skills disponibles para esta tarea:
+${loadedSkills.map(s => '- ' + s.name + ': ' + s.content.slice(0, 200)).join('\n')}
+
+Referencia estos skills en tu plan cuando aplique."
+```
+</skill_injection>
+
 <objective>
 Crear un plan ejecutable para una fase o feature, con investigación previa usando Context7 y WebSearch.
 

package/commands/elsabro/quick.md

@@ -26,6 +26,43 @@ sync:
 - Establecer `state.suggested_next = "progress"` en state.json
 </state_sync>
 
+<skill_discovery>
+## Skill Discovery (Quick)
+
+**Descubrir skills relevantes** para el fix rápido:
+
+```javascript
+// Ejecutar skill discovery (rápido, usa cache)
+const discoveryResult = Bash(`bash ./hooks/skill-discovery.sh "${inputs.task || args}" "low"`, { timeout: 15000 });
+
+// Guardar en estado
+state.context = state.context || {};
+state.context.available_skills = JSON.parse(discoveryResult).recommended || [];
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+```
+</skill_discovery>
+
+<skill_injection>
+## Skill Injection (Quick)
+
+Si discovery encontro skills relevantes, cargar el top-1 skill como referencia rapida:
+
+```javascript
+const skills = state.context.available_skills || [];
+if (skills.length > 0) {
+  const topSkill = Read(`skills/${skills[0].id}.md`);
+  if (topSkill) {
+    state.context.loaded_skills = [{ name: skills[0].id, content: topSkill }];
+  }
+}
+```
+
+Incluir en el prompt del agente quick:
+```
+"Skill de referencia: ${topSkill ? topSkill.name : 'ninguno'}"
+```
+</skill_injection>
+
 <command-name>quick</command-name>
 
 ## Propósito

package/commands/elsabro/research-phase.md

@@ -24,6 +24,24 @@ sync:
 - Establecer `state.suggested_next = "plan"`
 </state_sync>
 
+<skill_discovery>
+## Skill Discovery (Pre-Research)
+
+**ANTES de investigar**, descubrir skills relevantes para las tecnologías:
+
+```javascript
+// Ejecutar skill discovery con el tema de research
+const discoveryResult = Bash(`bash ./hooks/skill-discovery.sh "research ${inputs.phase || args}" "medium"`, { timeout: 30000 });
+
+// Guardar en estado
+state.context = state.context || {};
+state.context.available_skills = JSON.parse(discoveryResult).recommended || [];
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+```
+
+Los skills informan qué tecnologías investigar y qué patrones buscar en Context7.
+</skill_discovery>
+
 <command-name>research-phase</command-name>
 
 ## Propósito

package/commands/elsabro/start.md

@@ -49,6 +49,29 @@ allowed-tools:
 - Menos de 2 agentes para detección = **ABORTAR**
 </enforcement>
 
+<skill_discovery>
+## Skill Discovery (Pre-Work)
+
+**DESPUÉS de detectar contexto**, descubrir skills relevantes para la tarea:
+
+```javascript
+// Ejecutar skill discovery (usa cache de 1 hora)
+const discoveryResult = Bash(`bash ./hooks/skill-discovery.sh "${inputs.task || 'detect project'}" "medium"`, { timeout: 30000 });
+
+// Guardar en estado
+state.context = state.context || {};
+state.context.available_skills = JSON.parse(discoveryResult).recommended || [];
+
+// Informar al usuario si hay skills relevantes
+if (state.context.available_skills.length > 0) {
+  output(`Skills detectados: ${state.context.available_skills.map(s => s.name).join(", ")}`);
+}
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+```
+
+Los skills descubiertos se pasan al comando siguiente (plan, execute, etc.) para informar patrones y configuraciones.
+</skill_discovery>
+
 <objective>
 Eres el **orquestador principal** de ELSABRO. Tu trabajo es:
 

package/commands/elsabro/verify-work.md

@@ -324,6 +324,19 @@ Agrega verificaciones extra:
 - Compatible con CI/CD pipelines
 - Genera reporte en `.planning/VERIFICATION-REPORT.md`
 
+<IMPERATIVO_AGENT_TEAMS>
+## ⛔ STOP — ANTES DE LANZAR REVIEWERS PARALELOS
+
+**REGLA NO NEGOCIABLE (Rule 8):** Los 3 reviewers DEBEN ejecutarse como Agent Team.
+
+1. **PRIMERO** → `TeamCreate({ team_name: "elsabro-verify", description: "Verification team" })`
+2. **DESPUES** → `Task({ ..., team_name: "elsabro-verify", name: "reviewer-N" })` x3
+3. **AL FINAL** → `SendMessage({ type: "shutdown_request", ... })` x3
+4. **ULTIMO** → `TeamDelete()`
+
+**NUNCA lances 3 Task() de review sin TeamCreate previo.**
+</IMPERATIVO_AGENT_TEAMS>
+
 <parallel_coordination>
 ## Coordinación de Verificación Paralela
 
@@ -612,6 +625,22 @@ TaskCreate({
 <siguiente_paso>
 ## Siguiente Paso
 
+### Self-Check (OBLIGATORIO antes de reportar resultado)
+
+Antes de mostrar "Siguiente Paso", verifica CADA UNO de estos items:
+
+```
+[ ] Si lance 2+ Task() en paralelo → ¿use TeamCreate primero?
+    SI: Continuar
+    NO: DETENERME. Crear team y relanzar.
+
+[ ] Si use Agent Teams → ¿ejecute SendMessage(shutdown) + TeamDelete?
+    SI: Continuar
+    NO: DETENERME. Hacer cleanup.
+```
+
+**Si alguna respuesta es NO: NO mostrar siguiente paso. Corregir primero.**
+
 Al completar, establecer en state.json:
 ```javascript
 // GATE CHECK: No proceder sin Agent Teams para fases con 2+ agentes

package/flow-engine/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "elsabro-flow-engine",
+  "version": "0.1.0",
+  "description": "Runtime engine for ELSABRO development-flow.json",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "node --test tests/"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT"
+}