elsabro 5.2.0 → 6.0.1

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/bin/install.js

@@ -239,8 +239,8 @@ if (hasUpdate) {
       console.log(`  ${yellow}⚠${reset} No se pudo verificar la última versión`);
       console.log(`  ${dim}Intentando actualizar de todas formas...${reset}\n`);
     } else if (latestVersion === pkg.version) {
-      console.log(`  ${green}✓${reset} Ya tienes la última versión (${pkg.version})\n`);
-      process.exit(0);
+      console.log(`  ${green}✓${reset} Versión actual: ${pkg.version} (ya es la última)`);
+      console.log(`  ${dim}Reinstalando archivos locales...${reset}\n`);
     } else {
       console.log(`  ${cyan}Nueva versión disponible: ${latestVersion}${reset}`);
       console.log(`  ${dim}Versión actual: ${pkg.version}${reset}\n`);
@@ -357,7 +357,9 @@ async function install() {
     { src: 'templates', dest: 'templates', name: 'Templates' },
     { src: 'workflows', dest: 'workflows', name: 'Workflows' },
     { src: 'references', dest: 'references', name: 'Referencias' },
-    { src: 'hooks/dist', dest: 'hooks', name: 'Hooks' }
+    { src: 'hooks/dist', dest: 'hooks', name: 'Hooks' },
+    { src: 'flows', dest: 'flows', name: 'Flows' },
+    { src: 'flow-engine', dest: 'flow-engine', name: 'Flow Engine' }
   ];
 
   const failures = [];
@@ -465,7 +467,9 @@ async function uninstall() {
     'skills',
     'templates',
     'workflows',
-    'references'
+    'references',
+    'flows',
+    'flow-engine'
   ];
 
   for (const item of toRemove) {

package/commands/elsabro/execute.md

@@ -162,6 +162,51 @@ 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
@@ -528,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
@@ -548,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",
@@ -562,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",
@@ -570,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
@@ -763,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)
 
@@ -786,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
@@ -1237,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/plan.md

@@ -11,6 +11,9 @@ allowed-tools:
   - TaskCreate
   - TaskUpdate
   - TaskList
+  - TeamCreate
+  - TeamDelete
+  - SendMessage
   - WebSearch
   - AskUserQuestion
   - mcp__plugin_context7_context7__*
@@ -157,6 +160,35 @@ 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

@@ -42,6 +42,27 @@ 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/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"
+}

package/flow-engine/src/checkpoint.js

@@ -0,0 +1,112 @@
+'use strict';
+
+/**
+ * Checkpoint manager for the ELSABRO flow engine.
+ *
+ * Saves and loads flow execution state to/from the filesystem,
+ * enabling resume-from-checkpoint after interrupts or crashes.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class CheckpointManager {
+  /**
+   * @param {object} options
+   * @param {string} [options.dir] – checkpoint directory (default: .elsabro/checkpoints/)
+   */
+  constructor(options = {}) {
+    this.dir = options.dir || path.join(process.cwd(), '.elsabro', 'checkpoints');
+    this._seq = 0;
+  }
+
+  /**
+   * Save a checkpoint to disk.
+   *
+   * @param {string} flowId – flow identifier
+   * @param {object} checkpointData – { currentNode, nextNode, context, nodesVisited }
+   * @returns {string} checkpoint filename
+   */
+  save(flowId, checkpointData) {
+    fs.mkdirSync(this.dir, { recursive: true });
+
+    const timestamp = Date.now();
+    this._seq++;
+    const filename = `${flowId}-${timestamp}-${String(this._seq).padStart(4, '0')}.json`;
+    const filepath = path.join(this.dir, filename);
+
+    const payload = {
+      flowId,
+      timestamp,
+      createdAt: new Date().toISOString(),
+      ...checkpointData
+    };
+
+    fs.writeFileSync(filepath, JSON.stringify(payload, null, 2));
+    return filename;
+  }
+
+  /**
+   * Load the latest checkpoint for a flow.
+   *
+   * @param {string} flowId
+   * @returns {object|null} checkpoint data, or null if none found
+   */
+  load(flowId) {
+    if (!fs.existsSync(this.dir)) return null;
+
+    const files = fs.readdirSync(this.dir)
+      .filter(f => f.startsWith(`${flowId}-`) && f.endsWith('.json'))
+      .sort()
+      .reverse();
+
+    if (files.length === 0) return null;
+
+    const filepath = path.join(this.dir, files[0]);
+    const data = JSON.parse(fs.readFileSync(filepath, 'utf8'));
+    return data;
+  }
+
+  /**
+   * List all checkpoints for a flow.
+   *
+   * @param {string} flowId
+   * @returns {{ filename: string, timestamp: number }[]}
+   */
+  list(flowId) {
+    if (!fs.existsSync(this.dir)) return [];
+
+    return fs.readdirSync(this.dir)
+      .filter(f => f.startsWith(`${flowId}-`) && f.endsWith('.json'))
+      .map(filename => {
+        const match = filename.match(/-(\d+)-\d+\.json$/);
+        return {
+          filename,
+          timestamp: match ? parseInt(match[1], 10) : 0
+        };
+      })
+      .sort((a, b) => b.timestamp - a.timestamp);
+  }
+
+  /**
+   * Remove old checkpoints, keeping only the most recent N.
+   *
+   * @param {string} flowId
+   * @param {number} [keepLast=5]
+   */
+  clean(flowId, keepLast = 5) {
+    const checkpoints = this.list(flowId);
+    const toRemove = checkpoints.slice(keepLast);
+
+    for (const cp of toRemove) {
+      const filepath = path.join(this.dir, cp.filename);
+      if (fs.existsSync(filepath)) {
+        fs.unlinkSync(filepath);
+      }
+    }
+
+    return toRemove.length;
+  }
+}
+
+module.exports = { CheckpointManager };