elsabro 2.0.0 → 2.1.0

package/README.md

@@ -22,19 +22,19 @@ ELSABRO es un sistema de desarrollo AI-powered para Claude Code que te guía pas
 
 ## Instalación
 
-### Desde GitHub (Recomendado)
+### Con NPX (Recomendado)
 ```bash
-npx github:goat1990/elsabro --global
+npx elsabro --global
 ```
 
 ### Con PNPM
 ```bash
-pnpm dlx github:goat1990/elsabro --global
+pnpm dlx elsabro --global
 ```
 
 ### Con BUN
 ```bash
-bunx github:goat1990/elsabro --global
+bunx elsabro --global
 ```
 
 Después de instalar, abre Claude Code y escribe:
@@ -221,7 +221,7 @@ Voy a crear tu blog con:
 ## Actualización
 
 ```bash
-npx github:goat1990/elsabro --update
+npx elsabro --update
 ```
 
 O desde Claude Code:
@@ -232,7 +232,7 @@ O desde Claude Code:
 ## Desinstalación
 
 ```bash
-npx github:goat1990/elsabro --uninstall
+npx elsabro --uninstall
 ```
 
 ## Estructura del Proyecto

package/bin/install.js

@@ -397,9 +397,20 @@ async function install() {
     }
   }
 
-  // Add hook configurations
-  settings.hooks = settings.hooks || {};
-  settings.hooks.postToolUse = settings.hooks.postToolUse || [];
+  // Clean up any empty hooks structure from previous installations
+  // Claude Code rejects empty postToolUse arrays/objects
+  if (settings.hooks) {
+    const ptu = settings.hooks.postToolUse;
+    const isEmptyArray = Array.isArray(ptu) && ptu.length === 0;
+    const isEmptyObject = ptu && typeof ptu === 'object' && !Array.isArray(ptu) && Object.keys(ptu).length === 0;
+    if (isEmptyArray || isEmptyObject) {
+      delete settings.hooks.postToolUse;
+    }
+    // Remove hooks object entirely if empty
+    if (Object.keys(settings.hooks).length === 0) {
+      delete settings.hooks;
+    }
+  }
 
   // Add version tracking
   settings.elsabro = {

package/commands/elsabro/execute.md

@@ -9,6 +9,10 @@ allowed-tools:
   - Glob
   - Grep
   - Task
+  - TaskCreate
+  - TaskUpdate
+  - TaskList
+  - TaskGet
   - mcp__plugin_context7_context7__*
 argument-hint: "[número de fase]"
 ---
@@ -17,10 +21,11 @@ argument-hint: "[número de fase]"
 
 <objective>
 Ejecutar planes de una fase con:
+- **Sistema de Tasks para tracking real** de waves y dependencias
 - 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>
 
 <process>
@@ -32,48 +37,137 @@ 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
+### Marcar wave como in_progress
+```javascript
+TaskUpdate({ taskId: "wave-W-id", status: "in_progress" })
 ```
-Task(elsabro-executor) para Plan 1 |
-Task(elsabro-executor) para Plan 2 |
-Task(elsabro-executor) para Plan 3
+
+### Si hay múltiples planes en la wave → Paralelo
+```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 en paralelo (UN SOLO MENSAJE)
+Task(elsabro-executor) para Plan A |
+Task(elsabro-executor) para Plan B |
+Task(elsabro-executor) para Plan C
+
+// Al completar cada plan
+TaskUpdate({ taskId: "plan-A-id", status: "completed" })
 ```
 
 ### Si solo hay un plan → Secuencial
-```
+```javascript
+TaskUpdate({ taskId: "plan-X-id", status: "in_progress" })
 Task(elsabro-executor) para Plan único
+TaskUpdate({ taskId: "plan-X-id", status: "completed" })
 ```
 
-Cada executor recibe:
-- El PLAN.md completo
-- Referencias a RESEARCH.md
-- Instrucciones de TDD
-- Instrucciones de commits
+### 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"]
+})
+```
 
-## Paso 4: Verificar Fase
+### 4.2 Ejecutar verificación en paralelo
+```javascript
+TaskUpdate({ taskId: "verify-functional-id", status: "in_progress" })
+TaskUpdate({ taskId: "verify-quality-id", status: "in_progress" })
 
-Una vez todos los planes completados:
+// Lanzar agentes verificadores en paralelo
+Task(elsabro-verifier): Verifica funcionalidad |
+Task(elsabro-verifier): Verifica calidad
 
-```
-Task(elsabro-verifier):
-  Verifica la fase [N]:
-  - Lee los SUMMARY.md generados
-  - Verifica must_haves de cada plan
-  - Genera VERIFICATION.md
+// Marcar completed al terminar
+TaskUpdate({ taskId: "verify-functional-id", status: "completed" })
+TaskUpdate({ taskId: "verify-quality-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 +257,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 +377,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/pause-work.md

@@ -6,6 +6,10 @@ allowed-tools:
   - Write
   - Bash
   - Glob
+  - TaskUpdate
+  - TaskCreate
+  - TaskList
+  - TaskGet
 ---
 
 # /elsabro:pause-work
@@ -16,6 +20,41 @@ allowed-tools:
 
 Guardar el estado actual del trabajo para poder retomarlo fácilmente después. Captura contexto, notas y próximos pasos.
 
+## Integración con Tasks API
+
+Al pausar, se actualiza el estado en el sistema de Tasks para persistencia y fácil recuperación:
+
+```javascript
+// 1. Obtener task activa actual
+TaskList()  // Ver qué está in_progress
+
+// 2. Actualizar task con estado de pausa
+TaskUpdate({
+  taskId: "current-phase-task-id",
+  metadata: {
+    status: "paused",
+    pausedAt: "2024-01-20T17:30:00Z",
+    expectedReturn: "2024-01-21T09:00:00Z",
+    lastCompletedSubtask: "validation-implementation",
+    nextSubtask: "avatar-upload",
+    notes: "Zod schema completo, falta avatar",
+    uncommittedFiles: 3
+  }
+})
+
+// 3. Crear reminder task (opcional)
+TaskCreate({
+  subject: "Resume: User profile page",
+  description: "Paused on 2024-01-20, expected return tomorrow morning",
+  activeForm: "Waiting to resume...",
+  metadata: {
+    type: "reminder",
+    pausedTaskId: "current-phase-task-id",
+    dueDate: "2024-01-21T09:00:00Z"
+  }
+})
+```
+
 ## Uso
 
 ```bash
@@ -178,9 +217,26 @@ Choice (1/2/3):
 ## Integración
 
 - Paired con `/elsabro:resume-work`
+- **Tasks API** para persistencia de estado entre sesiones
 - Optional git integration (commit/stash)
 - Session file tracked in `.planning/`
 
+### Flujo Completo con Tasks
+
+```javascript
+// Al pausar:
+// 1. Guardar SESSION.md (humano-legible)
+// 2. Guardar SESSION-STATE.json (agente-legible)
+// 3. TaskUpdate con metadata de pausa
+// 4. TaskCreate reminder (opcional)
+
+// Al reanudar (/elsabro:resume-work):
+// 1. TaskGet para recuperar metadata de pausa
+// 2. Validar integridad del contexto
+// 3. TaskUpdate para reactivar task
+// 4. TaskDelete reminder si existe
+```
+
 <session_state_management>
 ## Gestión de Estado de Sesión
 

package/commands/elsabro/resume-work.md

@@ -7,6 +7,10 @@ allowed-tools:
   - Bash
   - Glob
   - Grep
+  - TaskGet
+  - TaskUpdate
+  - TaskList
+  - TaskCreate
 ---
 
 # /elsabro:resume-work
@@ -15,7 +19,50 @@ allowed-tools:
 
 ## Propósito
 
-Retomar trabajo en un proyecto después de una interrupción. Reconstruye contexto, muestra estado actual y sugiere siguiente paso.
+Retomar trabajo en un proyecto después de una interrupción. Reconstruye contexto desde Tasks API, muestra estado actual y sugiere siguiente paso.
+
+## Integración con Tasks API
+
+Al reanudar, primero consultar el sistema de Tasks para recuperar contexto:
+
+```javascript
+// 1. Listar todas las tasks para ver estado actual
+TaskList()
+// Output:
+//   ⏸ User profile page - Paused (metadata.status: "paused")
+//   ✅ Dashboard layout - Completed
+//   ⏳ Settings modal - Pending
+
+// 2. Obtener detalles de la task pausada
+TaskGet({ taskId: "paused-task-id" })
+// Output:
+//   status: "in_progress" (pero metadata.status: "paused")
+//   metadata: {
+//     pausedAt: "2024-01-20T17:30:00Z",
+//     expectedReturn: "2024-01-21T09:00:00Z",
+//     lastCompletedSubtask: "validation-implementation",
+//     nextSubtask: "avatar-upload",
+//     notes: "Zod schema completo, falta avatar"
+//   }
+
+// 3. Validar integridad del contexto
+// - ¿Tiempo desde pausa > 7 días? → Warning
+// - ¿Tiempo > 30 días? → Sugerir revisión completa
+// - ¿Archivos referenciados aún existen?
+
+// 4. Reactivar task
+TaskUpdate({
+  taskId: "paused-task-id",
+  metadata: {
+    status: "active",  // Ya no está pausada
+    resumedAt: "2024-01-21T09:15:00Z",
+    resumedFrom: "pause"
+  }
+})
+
+// 5. Eliminar reminder si existe
+TaskUpdate({ taskId: "reminder-task-id", status: "deleted" })
+```
 
 ## Uso
 
@@ -151,9 +198,71 @@ Implementing user profile validation
 ## Integración
 
 - Paired con `/elsabro:pause-work`
-- Uses session data from `.planning/SESSION.md`
+- **Tasks API** como fuente primaria de estado
+- Uses session data from `.planning/SESSION.md` como fallback
 - Can trigger `/elsabro:progress` for overview
 
+### Flujo de Recuperación con Tasks
+
+```javascript
+// Prioridad de fuentes de contexto:
+// 1. Tasks API (TaskGet) → Más confiable, persistente entre sesiones
+// 2. SESSION-STATE.json → Backup para detalles adicionales
+// 3. SESSION.md → Fallback humano-legible
+
+async function resumeWork() {
+  // 1. Intentar recuperar de Tasks
+  const tasks = await TaskList()
+  const pausedTask = tasks.find(t => t.metadata?.status === "paused")
+
+  if (pausedTask) {
+    const details = await TaskGet({ taskId: pausedTask.id })
+
+    // Reactivar task principal
+    await TaskUpdate({
+      taskId: pausedTask.id,
+      metadata: { ...details.metadata, status: "active", resumedAt: new Date() }
+    })
+
+    // Buscar y eliminar reminder task asociada
+    const reminderTask = tasks.find(t =>
+      t.metadata?.type === "reminder" &&
+      t.metadata?.pausedTaskId === pausedTask.id
+    )
+    if (reminderTask) {
+      await TaskUpdate({ taskId: reminderTask.id, status: "deleted" })
+    }
+
+    // Mostrar metadatos recuperados al usuario
+    console.log(`Recovered context:
+      - Last completed: ${details.metadata.lastCompletedSubtask}
+      - Next step: ${details.metadata.nextSubtask}
+      - Notes: ${details.metadata.notes}
+    `)
+
+    return details
+  }
+
+  // 2. Fallback a SESSION-STATE.json
+  if (fs.existsSync('.planning/SESSION-STATE.json')) {
+    // ... recuperar de archivo ...
+  }
+
+  // 3. Fallback final a SESSION.md
+  // ...
+}
+```
+
+### Ventajas de Tasks API para Resume
+
+| Aspecto | Antes (archivos) | Ahora (Tasks API) |
+|---------|------------------|-------------------|
+| Persistencia | Solo en proyecto | Entre sesiones |
+| Recuperación | Parse manual | TaskGet directo |
+| Integridad | Validar JSON | Sistema garantiza |
+| Visibilidad | Leer archivo | Ctrl+T nativo |
+| Staleness | Calcular manual | Metadata timestamps |
+
 <session_validation>
 ## Validación de Sesión
 

package/commands/elsabro/verify-work.md

@@ -1,12 +1,16 @@
 ---
 name: verify-work
-description: Verificación completa del trabajo realizado usando agentes paralelos
+description: Verificación completa del trabajo realizado usando agentes paralelos con Tasks
 allowed-tools:
   - Read
   - Bash
   - Glob
   - Grep
   - Task
+  - TaskCreate
+  - TaskUpdate
+  - TaskList
+  - TaskGet
 ---
 
 # /elsabro:verify-work
@@ -17,29 +21,75 @@ allowed-tools:
 
 Verificar que el trabajo completado cumple con los requirements, pasa todos los tests, y está listo para merge/deploy.
 
+## Sistema de Tasks para Verificación
+
+### Crear estructura de verificación con dependencias
+
+```javascript
+// 1. Crear tasks de verificación paralela
+TaskCreate({
+  subject: "Verify Functional Requirements",
+  description: "Check acceptance criteria and feature behavior",
+  activeForm: "Verificando funcionalidad...",
+  metadata: { type: "verifier", area: "functional", timeout: 30 }
+})  // → functional-id
+
+TaskCreate({
+  subject: "Verify Quality Metrics",
+  description: "Run tests, check coverage, lint",
+  activeForm: "Verificando calidad...",
+  metadata: { type: "verifier", area: "quality", timeout: 45 }
+})  // → quality-id
+
+TaskCreate({
+  subject: "Verify Security & Edge Cases",
+  description: "Check vulnerabilities, error handling",
+  activeForm: "Verificando seguridad...",
+  metadata: { type: "verifier", area: "security", timeout: 25 }
+})  // → security-id
+
+// 2. Crear agregador que espera a todos
+TaskCreate({
+  subject: "Aggregate Verification Results",
+  description: "Combine results and generate final report",
+  activeForm: "Agregando resultados...",
+  metadata: { type: "aggregator", policy: "fail_fast" }
+})  // → aggregate-id
+
+// 3. Configurar dependencias (agregador espera a todos)
+TaskUpdate({
+  taskId: "aggregate-id",
+  addBlockedBy: ["functional-id", "quality-id", "security-id"]
+})
+```
+
 ## Protocolo de Verificación
 
 Usa **mínimo 3 agentes en paralelo** para verificación exhaustiva:
 
 ```
 ┌──────────────────────────────────────────────────────┐
-│  VERIFICACIÓN PARALELA (CUBAIT Protocol)             │
+│  VERIFICACIÓN PARALELA CON TASKS                     │
 ├──────────────────────────────────────────────────────┤
 │                                                      │
-│  Agent 1: Functional Verification                   │
+│  Task: Functional Verification (verify-functional)  │
 │  └─ ¿El código hace lo que debe?                    │
 │  └─ ¿Cumple acceptance criteria?                    │
 │                                                      │
-│  Agent 2: Quality Verification                      │
+│  Task: Quality Verification (verify-quality)        │
 │  └─ ¿Tests pasan?                                   │
 │  └─ ¿Coverage adecuado?                             │
 │  └─ ¿Sin errores de lint?                           │
 │                                                      │
-│  Agent 3: Security/Edge Cases                       │
+│  Task: Security/Edge Cases (verify-security)        │
 │  └─ ¿Sin vulnerabilidades obvias?                   │
 │  └─ ¿Edge cases manejados?                          │
 │  └─ ¿Error handling correcto?                       │
 │                                                      │
+│  Task: Aggregator (blockedBy: [all above])          │
+│  └─ Se desbloquea cuando TODOS completen            │
+│  └─ Genera VERIFICATION-REPORT.md                   │
+│                                                      │
 └──────────────────────────────────────────────────────┘
 ```
 
@@ -146,22 +196,60 @@ Para verificación, usamos `policy: fail_fast` porque todos los checks son crít
 └────────────────────────────────────────────────┘
 ```
 
-### Lanzamiento de Agentes
+### Lanzamiento de Agentes con Tasks
+
+```javascript
+// 1. Marcar todos como in_progress
+TaskUpdate({ taskId: "functional-id", status: "in_progress" })
+TaskUpdate({ taskId: "quality-id", status: "in_progress" })
+TaskUpdate({ taskId: "security-id", status: "in_progress" })
+
+// 2. Lanzar agentes EN UN SOLO MENSAJE (paralelo real)
+Task(elsabro-verifier, model: "opus"): Verify functional requirements |
+Task(elsabro-verifier, model: "opus"): Verify quality metrics |
+Task(elsabro-verifier, model: "opus"): Verify security and edge cases
+
+// 3. Al completar cada uno, marcar completed
+TaskUpdate({
+  taskId: "functional-id",
+  status: "completed",
+  metadata: { result: "PASS", duration: "18s" }
+})
+// ... repeat for others ...
+
+// 4. Cuando TODOS completen, aggregator se desbloquea automáticamente
+TaskUpdate({ taskId: "aggregate-id", status: "in_progress" })
+// ... generate VERIFICATION-REPORT.md ...
+TaskUpdate({ taskId: "aggregate-id", status: "completed" })
+```
+
+### Visualización con Ctrl+T
 
 ```
-# Los 3 agentes corren en paralelo
+📋 Verification Tasks:
+  ✅ Functional Verification - PASS (18s)
+  ✅ Quality Verification - PASS (25s)
+  🔧 Security Verification - Running...
+  ⏳ Aggregate Results - Blocked (waiting for security)
+```
+
+### Diagrama de Dependencias
+
+```
+# Los 3 agentes corren en paralelo, agregador espera
 ┌─────────────────────────────────────────────────┐
 │                                                 │
 │  ┌─────────────┐  ┌─────────────┐  ┌─────────┐ │
 │  │ Functional  │  │  Quality    │  │Security │ │
-│  │ Verifier    │  │  Verifier   │  │Verifier │ │
+│  │ (Task)      │  │  (Task)     │  │(Task)   │ │
 │  └──────┬──────┘  └──────┬──────┘  └────┬────┘ │
 │         │                │              │       │
-│         └────────────────┼──────────────┘       │
+│         └───── blockedBy ┼──────────────┘       │
 │                          │                      │
 │                   ┌──────▼──────┐               │
 │                   │ Aggregator  │               │
-│                   │ (wait all)  │               │
+│                   │ (Task)      │               │
+│                   │ auto-unlock │               │
 │                   └─────────────┘               │
 │                                                 │
 └─────────────────────────────────────────────────┘
@@ -238,9 +326,70 @@ Si un agente falla por razones transitorias (timeout, network):
 └──────────────────────────────────────────────────┘
 ```
 
-### Actualizar Estado
+### Actualizar Estado con Tasks
+
+Al completar verificación, actualizar tanto Tasks como SESSION-STATE.json:
+
+```javascript
+// 1. Verificar estado final con TaskList
+TaskList()
+// Output:
+//   ✅ functional-verifier: completed
+//   ✅ quality-verifier: completed
+//   ✅ security-verifier: completed
+//   ✅ aggregate-results: completed
+
+// 2. Obtener detalles de cualquier task
+TaskGet({ taskId: "quality-id" })
+// Output:
+//   status: "completed"
+//   metadata: { result: "PASS", tests: "45/45", coverage: "87%" }
+
+// 3. Si alguna falló, TaskGet muestra detalles
+TaskGet({ taskId: "security-id" })
+// Output:
+//   status: "completed"
+//   metadata: { result: "FAIL", vulnerabilities: ["SQL injection in /api/users"] }
+```
 
-Al completar verificación:
+### Manejo de Fallo con Tasks
+
+```javascript
+// Si quality-verifier falla:
+TaskUpdate({
+  taskId: "quality-id",
+  status: "completed",  // Completó pero con error
+  metadata: {
+    result: "FAIL",
+    failedTests: 3,
+    details: ["Profile.test.ts: Expected John got null"]
+  }
+})
+
+// El agregador se activa pero reporta el fallo
+TaskUpdate({ taskId: "aggregate-id", status: "in_progress" })
+// Genera VERIFICATION-REPORT.md con detalles del fallo
+TaskUpdate({
+  taskId: "aggregate-id",
+  status: "completed",
+  metadata: {
+    overallResult: "FAIL",
+    passedChecks: 2,
+    failedChecks: 1,
+    readyForReview: false
+  }
+})
+
+// Crear subtask de fix si es necesario
+TaskCreate({
+  subject: "Fix: Quality verification failed",
+  description: "3 tests failing, needs attention",
+  activeForm: "Fixing test failures...",
+  metadata: { type: "bugfix", parentTask: "quality-id" }
+})
+```
+
+### JSON State (compatibilidad)
 
 ```json
 {
@@ -263,6 +412,12 @@ Al completar verificación:
     "lastRun": "2024-01-20T16:30:00Z",
     "result": "PASS",
     "readyForReview": true
+  },
+  "tasks": {
+    "functional-id": "completed",
+    "quality-id": "completed",
+    "security-id": "completed",
+    "aggregate-id": "completed"
   }
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elsabro",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Sistema de desarrollo AI-powered para Claude Code - El mejor asistente para crear apps sin experiencia previa",
   "bin": {
     "elsabro": "bin/install.js"