elsabro 2.0.1 → 2.2.0

package/commands/elsabro/discuss-phase.md

@@ -1,10 +1,27 @@
 ---
 name: discuss-phase
-description: Discusión colaborativa sobre una fase - clarificar scope, identificar riesgos, refinar approach
+description: Discusion colaborativa sobre una fase - clarificar scope, identificar riesgos, refinar approach
+sync:
+  reads: [".elsabro/state.json"]
+  writes: [".elsabro/state.json"]
 ---
 
 # /elsabro:discuss-phase
 
+<state_sync>
+## SINCRONIZACION DE ESTADO
+
+**IMPORTAR**: Ver `/references/state-sync.md` para protocolo completo.
+
+### Al Iniciar
+- Leer `.elsabro/state.json`
+- Verificar contexto actual del milestone/phase
+
+### Al Completar
+- Registrar cambio en `history`
+- Actualizar `context` si corresponde
+</state_sync>
+
 <command-name>discuss-phase</command-name>
 
 ## Propósito

package/commands/elsabro/execute.md

@@ -9,21 +9,229 @@ allowed-tools:
   - Glob
   - Grep
   - Task
+  - TaskCreate
+  - TaskUpdate
+  - TaskList
+  - TaskGet
+  - AskUserQuestion
   - mcp__plugin_context7_context7__*
 argument-hint: "[número de fase]"
+sync:
+  reads: [".elsabro/state.json", ".planning/*-PLAN.md"]
+  writes: [".elsabro/state.json", ".elsabro/context.md"]
+  phases: ["initializing", "exploring", "executing_wave_N", "verifying", "done"]
+  passes_context_to: ["verify-work"]
+dispatcher:
+  exploration:
+    agents: [Explore, feature-dev:code-explorer, Plan]
+    model: haiku
+    parallel: true
+    min_agents: 3
+  implementation:
+    agents: [elsabro-executor, feature-dev:code-architect]
+    model: opus
+    parallel: true
+    min_agents: 2
+  verification:
+    agents: [pr-review-toolkit:code-reviewer, pr-review-toolkit:silent-failure-hunter, pr-review-toolkit:pr-test-analyzer]
+    model: opus
+    parallel: true
+    min_agents: 3
 ---
 
 # ELSABRO: Execute
 
+<state_sync>
+## SINCRONIZACIÓN DE ESTADO (OBLIGATORIO)
+
+**IMPORTAR**: Este comando DEBE seguir `/references/state-sync.md` y `/references/enforcement-rules.md`.
+
+### Al Iniciar (ANTES de cualquier operación)
+
+```javascript
+// 1. Crear task de inicialización
+TaskCreate({
+  subject: "Initialize execute command",
+  description: "Leer estado y preparar ejecución",
+  activeForm: "Inicializando..."
+})
+TaskUpdate(id, status: "in_progress")
+
+// 2. Leer estado existente
+const state = Read(".elsabro/state.json") || createInitialState();
+
+// 3. Verificar flujo en progreso
+if (state.current_flow && state.current_flow.command !== "execute") {
+  AskUserQuestion({
+    questions: [{
+      question: `Hay un flujo de "${state.current_flow.command}" en progreso. ¿Continuar ese o empezar execute?`,
+      header: "Flujo",
+      options: [
+        { label: "Continuar anterior", description: "Retomar " + state.current_flow.command },
+        { label: "Empezar execute", description: "Pausar anterior" }
+      ]
+    }]
+  });
+}
+
+// 4. Actualizar estado
+state.current_flow = { command: "execute", phase: "initializing", started_at: new Date().toISOString() };
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+
+// 5. Completar task de inicialización
+TaskUpdate(id, status: "completed")
+```
+
+### Al Cambiar de Fase
+
+```javascript
+// Antes de exploración
+state.current_flow.phase = "exploring";
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+
+// Antes de cada wave
+state.current_flow.phase = "executing_wave_" + waveNumber;
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+
+// Antes de verificación
+state.current_flow.phase = "verifying";
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+```
+
+### Al Completar
+
+```javascript
+// Registrar en historial
+state.history.push({
+  command: "execute",
+  completed_at: new Date().toISOString(),
+  result: "completed_phase_" + phaseNumber,
+  artifact: null
+});
+
+// Pasar contexto a verify-work
+state.context.changed_files = [...changedFiles];
+state.context.commits = [...commitIds];
+state.context.tests_added = [...testFiles];
+state.context.phase_completed = phaseNumber;
+
+// Limpiar flujo y sugerir siguiente
+state.current_flow = null;
+state.suggested_next = "verify-work";
+
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+
+// Actualizar context.md legible
+Write(".elsabro/context.md", generateHumanReadableContext(state));
+```
+</state_sync>
+
 <objective>
 Ejecutar planes de una fase con:
+- **Sistema de Tasks para tracking real** de waves y dependencias
+- **Dispatcher inteligente con selección automática de modelo** (ver @references/task-dispatcher.md)
+- **Ejecución por subagentes en paralelo** según tipo de tarea
 - Investigación de patrones con Context7
 - TDD cuando sea apropiado
 - Commits atómicos por tarea
-- Verificación automática
+- Verificación automática con agregador
 </objective>
 
+<dispatcher_integration>
+## Selección Automática de Modelo
+
+**REGLA CRÍTICA:** Cada tarea se ejecuta con el modelo óptimo para su tipo.
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                    MODELO SEGÚN FASE                                     │
+├─────────────────────────────────────────────────────────────────────────┤
+│  FASE              │  SUBAGENTES                        │  MODELO       │
+├────────────────────┼────────────────────────────────────┼───────────────┤
+│  Exploración       │  Explore                           │  HAIKU        │
+│  (pre-ejecución)   │  feature-dev:code-explorer         │  HAIKU        │
+│                    │  Plan                              │  HAIKU        │
+│                    │  (3 en paralelo obligatorio)       │               │
+├────────────────────┼────────────────────────────────────┼───────────────┤
+│  Implementación    │  elsabro-executor                  │  OPUS         │
+│  (waves)           │  feature-dev:code-architect        │  OPUS         │
+│                    │  (2+ en paralelo por wave)         │               │
+├────────────────────┼────────────────────────────────────┼───────────────┤
+│  Verificación      │  pr-review-toolkit:code-reviewer   │  OPUS         │
+│  (post-ejecución)  │  pr-review-toolkit:silent-...      │  OPUS         │
+│                    │  pr-review-toolkit:pr-test-...     │  OPUS         │
+│                    │  (3 en paralelo obligatorio)       │               │
+└────────────────────┴────────────────────────────────────┴───────────────┘
+```
+
+### Por qué esta distribución
+
+- **HAIKU para exploración:** Solo lee y mapea, no necesita razonamiento profundo
+- **OPUS para implementación:** Escribe código, necesita máxima calidad
+- **OPUS para verificación:** Análisis profundo de bugs y edge cases
+</dispatcher_integration>
+
 <process>
+## Paso 0: Exploración Pre-Ejecución (HAIKU x3 paralelo)
+
+**OBLIGATORIO:** Antes de ejecutar, explorar el codebase para entender contexto.
+
+```javascript
+// Crear tasks de exploración
+TaskCreate({
+  subject: "Explore: Find related files",
+  description: "Buscar archivos relacionados con la fase",
+  activeForm: "Buscando archivos...",
+  metadata: { type: "exploration", model: "haiku" }
+})  // → explore-files-id
+
+TaskCreate({
+  subject: "Explore: Analyze patterns",
+  description: "Analizar patrones existentes en el codebase",
+  activeForm: "Analizando patrones...",
+  metadata: { type: "exploration", model: "haiku" }
+})  // → explore-patterns-id
+
+TaskCreate({
+  subject: "Explore: Map architecture",
+  description: "Mapear arquitectura del área afectada",
+  activeForm: "Mapeando arquitectura...",
+  metadata: { type: "exploration", model: "haiku" }
+})  // → explore-arch-id
+
+// Marcar todas como in_progress
+TaskUpdate({ taskId: "explore-files-id", status: "in_progress" })
+TaskUpdate({ taskId: "explore-patterns-id", status: "in_progress" })
+TaskUpdate({ taskId: "explore-arch-id", status: "in_progress" })
+
+// Lanzar 3 agentes HAIKU EN PARALELO (UN SOLO MENSAJE)
+Task({
+  subagent_type: "Explore",
+  model: "haiku",
+  description: "Buscar archivos relacionados",
+  prompt: "Busca archivos relacionados con la fase [N]. Lista los 10 más relevantes."
+}) |
+Task({
+  subagent_type: "feature-dev:code-explorer",
+  model: "haiku",
+  description: "Analizar patrones",
+  prompt: "Analiza patrones de arquitectura en el área de la fase [N]."
+}) |
+Task({
+  subagent_type: "Plan",
+  model: "haiku",
+  description: "Mapear arquitectura",
+  prompt: "Mapea componentes y flujo de datos del área afectada."
+})
+
+// Marcar completed
+TaskUpdate({ taskId: "explore-files-id", status: "completed" })
+TaskUpdate({ taskId: "explore-patterns-id", status: "completed" })
+TaskUpdate({ taskId: "explore-arch-id", status: "completed" })
+```
+
+**Resultado:** Contexto del codebase capturado antes de modificar nada.
+
 ## Paso 1: Descubrir Planes
 
 ```bash
@@ -32,48 +240,210 @@ ls .planning/*-PLAN.md
 
 Encontrar planes para la fase especificada.
 
-## Paso 2: Organizar por Waves
+## Paso 2: Crear Estructura de Tasks
 
+### 2.1 Crear Task coordinadora de fase
+```javascript
+TaskCreate({
+  subject: "Execute Phase [N]",
+  description: "Coordinar ejecución de todos los planes de la fase",
+  activeForm: "Ejecutando Fase [N]...",
+  metadata: { phase: N, type: "coordinator" }
+})  // → phase-coordinator-id
+```
+
+### 2.2 Organizar por Waves y crear Tasks
 Leer frontmatter de cada plan para agrupar por `wave`:
 
+```javascript
+// Para cada wave, crear task coordinadora
+TaskCreate({
+  subject: "Execute Wave [W]",
+  description: "Plans: A, B, C en paralelo",
+  activeForm: "Ejecutando Wave [W]...",
+  metadata: { wave: W, plans: ["A", "B", "C"] }
+})  // → wave-W-id
+
+// Wave 2+ tiene dependencia de wave anterior
+TaskUpdate({
+  taskId: "wave-2-id",
+  addBlockedBy: ["wave-1-id"]
+})
 ```
-Wave 1: [Planes que pueden correr en paralelo]
-Wave 2: [Planes que dependen de Wave 1]
-Wave 3: [Planes que dependen de Wave 2]
+
+### 2.3 Crear Tasks por plan dentro de cada wave
+```javascript
+TaskCreate({
+  subject: "Execute Plan [name]",
+  description: "TDD + commits para plan específico",
+  activeForm: "Ejecutando Plan [name]...",
+  metadata: { wave: W, plan: "name", type: "executor" }
+})  // → plan-X-id
+
+// Bloquear por wave coordinator
+TaskUpdate({
+  taskId: "plan-X-id",
+  addBlockedBy: ["wave-W-id"]
+})
 ```
 
-## Paso 3: Ejecutar Waves
+## Paso 3: Ejecutar Waves con Tracking
 
 Para cada wave:
 
-### Si hay múltiples planes en la wave → Paralelo
-```
-Task(elsabro-executor) para Plan 1 |
-Task(elsabro-executor) para Plan 2 |
-Task(elsabro-executor) para Plan 3
+### Marcar wave como in_progress
+```javascript
+TaskUpdate({ taskId: "wave-W-id", status: "in_progress" })
 ```
 
-### Si solo hay un plan → Secuencial
-```
-Task(elsabro-executor) para Plan único
+### Si hay múltiples planes en la wave → Paralelo (OPUS)
+```javascript
+// Marcar todos los planes como in_progress
+TaskUpdate({ taskId: "plan-A-id", status: "in_progress" })
+TaskUpdate({ taskId: "plan-B-id", status: "in_progress" })
+TaskUpdate({ taskId: "plan-C-id", status: "in_progress" })
+
+// Lanzar agentes OPUS en paralelo (UN SOLO MENSAJE)
+// MODELO: OPUS porque escriben código
+Task({
+  subagent_type: "elsabro-executor",
+  model: "opus",  // ← OPUS para implementación
+  description: "Ejecutar Plan A",
+  prompt: "Implementa el Plan A siguiendo TDD..."
+}) |
+Task({
+  subagent_type: "elsabro-executor",
+  model: "opus",  // ← OPUS para implementación
+  description: "Ejecutar Plan B",
+  prompt: "Implementa el Plan B siguiendo TDD..."
+}) |
+Task({
+  subagent_type: "elsabro-executor",
+  model: "opus",  // ← OPUS para implementación
+  description: "Ejecutar Plan C",
+  prompt: "Implementa el Plan C siguiendo TDD..."
+})
+
+// Al completar cada plan
+TaskUpdate({ taskId: "plan-A-id", status: "completed" })
 ```
 
-Cada executor recibe:
-- El PLAN.md completo
-- Referencias a RESEARCH.md
-- Instrucciones de TDD
-- Instrucciones de commits
+### Validación arquitectónica en paralelo (OPUS x2)
+```javascript
+// Además de implementar, validar arquitectura en paralelo
+Task({
+  subagent_type: "elsabro-executor",
+  model: "opus",
+  description: "Implementar cambios",
+  prompt: "..."
+}) |
+Task({
+  subagent_type: "feature-dev:code-architect",
+  model: "opus",  // ← OPUS para decisiones arquitectónicas
+  description: "Validar arquitectura",
+  prompt: "Verifica que la implementación sigue los patrones del codebase..."
+})
+```
 
-## Paso 4: Verificar Fase
+### Si solo hay un plan → Secuencial (OPUS)
+```javascript
+TaskUpdate({ taskId: "plan-X-id", status: "in_progress" })
+Task({
+  subagent_type: "elsabro-executor",
+  model: "opus",  // ← OPUS porque escribe código
+  description: "Ejecutar plan único",
+  prompt: "..."
+})
+TaskUpdate({ taskId: "plan-X-id", status: "completed" })
+```
 
-Una vez todos los planes completados:
+### Marcar wave como completed cuando todos sus planes terminen
+```javascript
+TaskUpdate({ taskId: "wave-W-id", status: "completed" })
+// → Wave W+1 se desbloquea automáticamente
+```
 
+## Paso 4: Verificar Fase (con Agregador)
+
+### 4.1 Crear tasks de verificación
+```javascript
+TaskCreate({
+  subject: "Verify Functional Requirements",
+  activeForm: "Verificando funcionalidad...",
+  metadata: { type: "verifier", area: "functional" }
+})  // → verify-functional-id
+
+TaskCreate({
+  subject: "Verify Quality Metrics",
+  activeForm: "Verificando calidad...",
+  metadata: { type: "verifier", area: "quality" }
+})  // → verify-quality-id
+
+TaskCreate({
+  subject: "Verify Phase Completion",
+  activeForm: "Agregando resultados...",
+  metadata: { type: "aggregator" }
+})  // → verify-aggregate-id
+
+// Agregador espera a todos los verificadores
+TaskUpdate({
+  taskId: "verify-aggregate-id",
+  addBlockedBy: ["verify-functional-id", "verify-quality-id"]
+})
 ```
-Task(elsabro-verifier):
-  Verifica la fase [N]:
-  - Lee los SUMMARY.md generados
-  - Verifica must_haves de cada plan
-  - Genera VERIFICATION.md
+
+### 4.2 Ejecutar verificación en paralelo (OPUS x3)
+
+**OBLIGATORIO:** Usar 3 agentes OPUS para verificación profunda.
+
+```javascript
+// Crear task adicional de seguridad
+TaskCreate({
+  subject: "Verify Security & Edge Cases",
+  activeForm: "Verificando seguridad...",
+  metadata: { type: "verifier", area: "security", model: "opus" }
+})  // → verify-security-id
+
+// Actualizar agregador para esperar los 3
+TaskUpdate({
+  taskId: "verify-aggregate-id",
+  addBlockedBy: ["verify-functional-id", "verify-quality-id", "verify-security-id"]
+})
+
+// Marcar todos como in_progress
+TaskUpdate({ taskId: "verify-functional-id", status: "in_progress" })
+TaskUpdate({ taskId: "verify-quality-id", status: "in_progress" })
+TaskUpdate({ taskId: "verify-security-id", status: "in_progress" })
+
+// Lanzar 3 agentes OPUS EN PARALELO (UN SOLO MENSAJE)
+Task({
+  subagent_type: "pr-review-toolkit:code-reviewer",
+  model: "opus",  // ← OPUS para análisis profundo
+  description: "Code review completo",
+  prompt: "Revisa los cambios buscando bugs, code smells, mejores prácticas..."
+}) |
+Task({
+  subagent_type: "pr-review-toolkit:silent-failure-hunter",
+  model: "opus",  // ← OPUS para edge cases
+  description: "Buscar errores ocultos",
+  prompt: "Busca errores silenciosos, try/catch que ocultan errores, fallbacks problemáticos..."
+}) |
+Task({
+  subagent_type: "pr-review-toolkit:pr-test-analyzer",
+  model: "opus",  // ← OPUS para análisis de tests
+  description: "Analizar cobertura de tests",
+  prompt: "Verifica que los tests cubren los cambios, busca casos críticos sin test..."
+})
+
+// Marcar completed al terminar
+TaskUpdate({ taskId: "verify-functional-id", status: "completed" })
+TaskUpdate({ taskId: "verify-quality-id", status: "completed" })
+TaskUpdate({ taskId: "verify-security-id", status: "completed" })
+
+// Agregador se desbloquea y genera reporte final
+TaskUpdate({ taskId: "verify-aggregate-id", status: "in_progress" })
+// ... genera VERIFICATION.md ...
+TaskUpdate({ taskId: "verify-aggregate-id", status: "completed" })
 ```
 
 ## Paso 5: Manejar Resultados
@@ -163,24 +533,59 @@ git commit -m "feat([fase]-[plan]): [descripción]"
 </execution_protocol>
 
 <parallel_execution>
-## Ejecución Paralela
+## Ejecución Paralela con Tasks
 
 ### Cuándo usar paralelo
 - Múltiples planes en la misma wave
 - Tareas independientes (sin dependencias)
 
-### Cómo paralelizar
+### Cómo paralelizar CON TRACKING
+```javascript
+// 1. Crear tasks para cada plan
+const planATask = TaskCreate({ subject: "Plan A", activeForm: "Ejecutando Plan A..." })
+const planBTask = TaskCreate({ subject: "Plan B", activeForm: "Ejecutando Plan B..." })
+const planCTask = TaskCreate({ subject: "Plan C", activeForm: "Ejecutando Plan C..." })
+
+// 2. Marcar todas como in_progress
+TaskUpdate({ taskId: planATask.id, status: "in_progress" })
+TaskUpdate({ taskId: planBTask.id, status: "in_progress" })
+TaskUpdate({ taskId: planCTask.id, status: "in_progress" })
+
+// 3. Lanzar agentes EN UN SOLO MENSAJE
+Task(elsabro-executor) Plan A |
+Task(elsabro-executor) Plan B |
+Task(elsabro-executor) Plan C
+
+// 4. Al completar cada uno
+TaskUpdate({ taskId: planATask.id, status: "completed" })
+// ...
+```
+
+### Visualización automática (Ctrl+T)
 ```
-# En un solo mensaje con múltiples Task calls:
-Task(elsabro-executor) Plan 1
-Task(elsabro-executor) Plan 2
-Task(elsabro-executor) Plan 3
+📋 Execute Phase 3:
+  ✅ Wave 1 - Completed (3/3 plans)
+  🔧 Wave 2 - Executing Plan D... (1/2 plans done)
+      ✅ Plan D - Completed
+      ⏳ Plan E - In Progress
+  ⏳ Wave 3 - Blocked by Wave 2
+  ⏳ Verification - Blocked by Wave 3
 ```
 
 ### Cuándo NO paralelizar
-- Planes con dependencias entre sí
+- Planes con dependencias entre sí (usar `blockedBy`)
 - Plan 2 necesita output de Plan 1
 - Modifican los mismos archivos
+
+### Expresar dependencias entre planes
+```javascript
+// Plan B depende de Plan A
+TaskUpdate({
+  taskId: "plan-B-id",
+  addBlockedBy: ["plan-A-id"]
+})
+// Plan B no puede empezar hasta que Plan A complete
+```
 </parallel_execution>
 
 <error_handling>
@@ -248,27 +653,66 @@ Este comando usa **policy: quorum** por defecto.
 | Tests fallan | HIGH | Debug o skip |
 | Lint warnings | MEDIUM | Continuar |
 
-### Actualizar Estado
-
-Después de errores, actualizar `.planning/SESSION-STATE.json`:
-
-```json
-{
-  "errors": {
-    "count": 1,
-    "lastError": {
-      "code": "TESTS_FAILED",
-      "severity": "HIGH",
-      "at": "2024-01-20T15:25:00Z",
-      "resolved": false
+### Actualizar Estado con Tasks
+
+Después de errores, actualizar tanto SESSION-STATE.json como Tasks:
+
+```javascript
+// 1. Actualizar task con metadata de error
+TaskUpdate({
+  taskId: "plan-X-id",
+  metadata: {
+    error: {
+      code: "TESTS_FAILED",
+      severity: "HIGH",
+      at: "2024-01-20T15:25:00Z",
+      attempt: 3,
+      maxAttempts: 3
     }
-  },
-  "retry": {
-    "currentAttempt": 3,
-    "maxAttempts": 3,
-    "exhausted": true
   }
-}
+})
+
+// 2. Si retry exhausted, NO marcar completed
+// Crear subtask de fix
+TaskCreate({
+  subject: "Fix: Tests failing in Plan X",
+  description: "3 retry attempts exhausted, needs manual fix",
+  activeForm: "Fixing test failures...",
+  metadata: { type: "bugfix", parentPlan: "plan-X-id" }
+})  // → bugfix-id
+
+// 3. Bloquear verificación hasta que bugfix complete
+TaskUpdate({
+  taskId: "verify-aggregate-id",
+  addBlockedBy: ["bugfix-id"]
+})
+
+// 4. También actualizar SESSION-STATE.json para compatibilidad
+```
+
+### Rollback de Estado con Tasks
+
+Si necesitas volver a ejecutar un plan:
+
+```javascript
+// Volver plan a in_progress (no crear nuevo)
+TaskUpdate({ taskId: "plan-X-id", status: "in_progress" })
+
+// Re-ejecutar
+Task(elsabro-executor) para Plan X
+
+// Marcar completed cuando funcione
+TaskUpdate({ taskId: "plan-X-id", status: "completed" })
+```
+
+### Ver Estado Actual
+
+```javascript
+// Listar todas las tasks
+TaskList()
+
+// Ver detalles de una task específica
+TaskGet({ taskId: "plan-X-id" })
 ```
 </error_handling>
 

package/commands/elsabro/insert-phase.md

@@ -1,10 +1,27 @@
 ---
 name: insert-phase
-description: Insertar una nueva fase en una posición específica del milestone
+description: Insertar una nueva fase en una posicion especifica del milestone
+sync:
+  reads: [".elsabro/state.json"]
+  writes: [".elsabro/state.json"]
 ---
 
 # /elsabro:insert-phase
 
+<state_sync>
+## SINCRONIZACION DE ESTADO
+
+**IMPORTAR**: Ver `/references/state-sync.md` para protocolo completo.
+
+### Al Iniciar
+- Leer `.elsabro/state.json`
+- Verificar contexto actual del milestone/phase
+
+### Al Completar
+- Registrar cambio en `history`
+- Actualizar `context` si corresponde
+</state_sync>
+
 <command-name>insert-phase</command-name>
 
 ## Propósito