elsabro 2.0.1 → 2.2.0

package/commands/elsabro/verify-work.md

@@ -1,45 +1,182 @@
 ---
 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
+  - Write
   - Bash
   - Glob
   - Grep
   - Task
+  - TaskCreate
+  - TaskUpdate
+  - TaskList
+  - TaskGet
+  - AskUserQuestion
+sync:
+  reads: [".elsabro/state.json"]
+  writes: [".elsabro/state.json", ".elsabro/context.md", ".planning/VERIFICATION-REPORT.md"]
+  phases: ["initializing", "verifying", "aggregating", "done"]
+  passes_context_to: ["execute (si gaps)", "done"]
+dispatcher:
+  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:verify-work
 
 <command-name>verify-work</command-name>
 
+<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 verify-work command",
+  description: "Leer estado y preparar verificación",
+  activeForm: "Inicializando..."
+})
+TaskUpdate(id, status: "in_progress")
+
+// 2. Leer estado existente
+const state = Read(".elsabro/state.json") || createInitialState();
+
+// 3. Verificar contexto de execute (archivos a verificar)
+if (state.context.changed_files && state.context.changed_files.length > 0) {
+  console.log("Archivos a verificar:", state.context.changed_files);
+  console.log("Commits a revisar:", state.context.commits);
+} else {
+  // No hay contexto de execute - verificar todo
+  console.log("Sin contexto de execute - verificación completa");
+}
+
+// 4. Actualizar estado
+state.current_flow = { command: "verify-work", 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 verificación
+state.current_flow.phase = "verifying";
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+
+// Antes de agregación
+state.current_flow.phase = "aggregating";
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+```
+
+### Al Completar
+
+```javascript
+// Registrar en historial
+state.history.push({
+  command: "verify-work",
+  completed_at: new Date().toISOString(),
+  result: verificationResult,  // "PASS" | "FAIL" | "PARTIAL"
+  artifact: ".planning/VERIFICATION-REPORT.md"
+});
+
+// Actualizar contexto
+state.context.verification_result = verificationResult;
+state.context.ready_for_merge = verificationResult === "PASS";
+
+// Limpiar flujo y sugerir siguiente
+state.current_flow = null;
+state.suggested_next = verificationResult === "PASS" ? null : "execute"; // null = done
+
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+
+// Actualizar context.md legible
+Write(".elsabro/context.md", generateHumanReadableContext(state));
+```
+</state_sync>
+
 ## Propósito
 
 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 +283,77 @@ Para verificación, usamos `policy: fail_fast` porque todos los checks son crít
 └────────────────────────────────────────────────┘
 ```
 
-### Lanzamiento de Agentes
+### Lanzamiento de Agentes OPUS x3 con Tasks
+
+**OBLIGATORIO:** Usar 3 agentes OPUS especializados para verificación profunda.
+
+```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 3 agentes OPUS EN UN SOLO MENSAJE (paralelo real)
+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, seguridad..."
+}) |
+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..."
+})
+
+// 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
+
+```
+📋 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
+# 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 +430,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 +516,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.1",
+  "version": "2.2.0",
   "description": "Sistema de desarrollo AI-powered para Claude Code - El mejor asistente para crear apps sin experiencia previa",
   "bin": {
     "elsabro": "bin/install.js"

package/references/SYSTEM_INDEX.md

@@ -0,0 +1,241 @@
+# ELSABRO System Index
+
+## ARQUITECTURA DEL SISTEMA
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                            ELSABRO SYSTEM                                    │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                                                                              │
+│  ┌──────────────────────────────────────────────────────────────────────┐   │
+│  │                      ENTRY POINT                                      │   │
+│  │                    /elsabro:start                                     │   │
+│  │              (Orquestador Principal)                                  │   │
+│  └────────────────────────────┬─────────────────────────────────────────┘   │
+│                               │                                              │
+│                               ▼                                              │
+│  ┌────────────────────────────────────────────────────────────────────────┐ │
+│  │                    CORE WORKFLOW                                        │ │
+│  │  ┌─────────┐  ┌─────────┐  ┌─────────────┐  ┌───────────────┐         │ │
+│  │  │  :new   │→ │  :plan  │→ │  :execute   │→ │ :verify-work  │         │ │
+│  │  │ (setup) │  │(design) │  │(implement)  │  │   (check)     │         │ │
+│  │  └─────────┘  └─────────┘  └─────────────┘  └───────────────┘         │ │
+│  │                    ↑               │                                    │ │
+│  │                    └───── :debug ──┘                                    │ │
+│  └────────────────────────────────────────────────────────────────────────┘ │
+│                                                                              │
+│  ┌────────────────────────────────────────────────────────────────────────┐ │
+│  │                    SHARED STATE                                         │ │
+│  │                 .elsabro/state.json                                     │ │
+│  │              (Sincronización entre comandos)                            │ │
+│  └────────────────────────────────────────────────────────────────────────┘ │
+│                                                                              │
+│  ┌────────────────────────────────────────────────────────────────────────┐ │
+│  │                    TASK DISPATCHER                                      │ │
+│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐                     │ │
+│  │  │   HAIKU     │  │   SONNET    │  │    OPUS     │                     │ │
+│  │  │ Exploración │  │  Balance    │  │ Implementar │                     │ │
+│  │  │  (rápido)   │  │ (flexible)  │  │  (calidad)  │                     │ │
+│  │  └─────────────┘  └─────────────┘  └─────────────┘                     │ │
+│  └────────────────────────────────────────────────────────────────────────┘ │
+│                                                                              │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## ARCHIVOS DE REFERENCIA
+
+### 1. `enforcement-rules.md`
+**Propósito**: Reglas NO negociables que todo comando debe seguir
+**Contiene**:
+- Secuencia obligatoria: TaskCreate → TaskUpdate → Task → TaskUpdate
+- Mínimos de agentes por fase
+- Matriz completa de todos los comandos (29 comandos)
+- Políticas de paralelismo
+
+### 2. `state-sync.md`
+**Propósito**: Protocolo de sincronización de estado entre comandos
+**Contiene**:
+- Código de sincronización para copiar a cada comando
+- Fases por comando
+- Contexto que pasa cada comando al siguiente
+- Transiciones válidas entre comandos
+
+### 3. `command-flow.md`
+**Propósito**: Flujo de navegación y estado compartido
+**Contiene**:
+- Diagrama de flujo principal
+- Estructura de `.elsabro/state.json`
+- Checkpoints entre comandos
+- Recuperación de contexto
+
+### 4. `task-dispatcher.md`
+**Propósito**: Selección automática de modelo según tipo de tarea
+**Contiene**:
+- Matriz modelo-tipo de tarea
+- Configuración de agentes por comando
+- Políticas de ejecución paralela
+- Integración con Claude Code Tasks API
+
+### 4.1. `tasks-integration.md` (NUEVO)
+**Propósito**: Integración con Claude Code Tasks API como backend único
+**Contiene**:
+- Arquitectura unificada (ELSABRO commands + Tasks API)
+- Metadata schema para TODOs, phases, milestones
+- Migración de `.planning/TODOS.md` a Tasks API
+- Ejemplos de implementación para cada comando
+
+### 5. `error-handling-instructions.md`
+**Propósito**: Manejo consistente de errores
+**Contiene**:
+- Clasificación (CRITICAL, HIGH, MEDIUM, LOW)
+- Display visual de errores
+- Políticas de retry
+- Actualización de estado después de errores
+
+### 6. `source-hierarchy.md`
+**Propósito**: Prioridad de fuentes de información
+**Contiene**:
+- Context7 > Docs > WebSearch > Training
+- Verificación de versiones
+- Proceso de research
+
+### 7. `token-optimization.md`
+**Propósito**: Uso eficiente del contexto
+**Contiene**:
+- Regla del 50%
+- Lazy loading
+- Wave execution
+
+---
+
+## ESTADO UNIFICADO
+
+**Archivo principal**: `.elsabro/state.json`
+
+```json
+{
+  "version": "1.0.0",
+  "created_at": "ISO timestamp",
+  "updated_at": "ISO timestamp",
+
+  "current_flow": {
+    "command": "string",
+    "phase": "string",
+    "started_at": "ISO timestamp"
+  },
+
+  "context": {
+    "project_type": "greenfield | brownfield | continuation",
+    "tech_stack": ["array"],
+    "current_feature": "string | null"
+  },
+
+  "history": [
+    {
+      "command": "string",
+      "completed_at": "ISO timestamp",
+      "result": "string",
+      "artifact": "path | null"
+    }
+  ],
+
+  "pending_tasks": [],
+  "blocked_on": null,
+  "suggested_next": "string | null",
+
+  "errors": {
+    "count": 0,
+    "lastError": null
+  }
+}
+```
+
+**Archivo legible**: `.elsabro/context.md` (para humanos)
+
+---
+
+## SKILLS PROFESIONALES
+
+| Skill | Stack | Versiones |
+|-------|-------|-----------|
+| `full-stack-app` | Next.js 15 + React 19 + Prisma 6 + PostgreSQL | Específicas |
+| `saas-starter` | Full-stack + Stripe 2024-12-18 | Específicas |
+| `mobile-app` | Expo SDK 52 + React Native | Específicas |
+| `api-microservice` | Fastify + OpenAPI + Docker | Parciales |
+| `chrome-extension` | Manifest V3 + Vite + TypeScript | Parciales |
+
+---
+
+## CHECKLIST DE CONSISTENCIA
+
+Para verificar que el sistema está correctamente configurado:
+
+### Comandos Core
+- [ ] `start.md` tiene sección `<enforcement>` y `<state_sync>`
+- [ ] `plan.md` tiene sección `<state_sync>` y `dispatcher` en frontmatter
+- [ ] `execute.md` tiene sección `<state_sync>` y `dispatcher` en frontmatter
+- [ ] `verify-work.md` tiene sección `<state_sync>` y `dispatcher` en frontmatter
+
+### Referencias
+- [ ] Todos los archivos usan `.elsabro/state.json` (NO `.planning/SESSION.md`)
+- [ ] `enforcement-rules.md` tiene matriz para los 29 comandos
+- [ ] `state-sync.md` tiene código de sincronización completo
+
+### Skills
+- [ ] Cada skill tiene `tags` en frontmatter
+- [ ] Cada skill tiene versiones específicas de tecnologías
+- [ ] Cada skill tiene `<verification>` ejecutable
+
+---
+
+## FLUJO DE EJECUCIÓN TÍPICO
+
+```
+1. Usuario ejecuta /elsabro:start
+   └─ Lee .elsabro/state.json (si existe)
+   └─ Lanza 2 HAIKU en paralelo para detectar contexto
+   └─ Muestra opciones según proyecto (greenfield/brownfield/continuation)
+   └─ Actualiza state.json con current_flow
+   └─ Invoca siguiente comando con Skill tool
+
+2. /elsabro:plan toma control
+   └─ Lee state.json (contexto de start)
+   └─ Lanza 3 HAIKU en paralelo para explorar
+   └─ Lanza 1 OPUS para crear RESEARCH.md y PLAN.md
+   └─ Lanza 1 SONNET para validar plan
+   └─ Actualiza state.json (plan_file, ready_for_execution)
+   └─ Sugiere /elsabro:execute
+
+3. /elsabro:execute toma control
+   └─ Lee state.json (plan_file)
+   └─ Lanza 3 HAIKU en paralelo para explorar
+   └─ Lanza 2+ OPUS en paralelo para implementar (por wave)
+   └─ Lanza 3 OPUS en paralelo para verificar
+   └─ Actualiza state.json (changed_files, commits)
+   └─ Sugiere /elsabro:verify-work
+
+4. /elsabro:verify-work finaliza
+   └─ Lee state.json (changed_files)
+   └─ Lanza 3 OPUS en paralelo para verificación exhaustiva
+   └─ Genera VERIFICATION-REPORT.md
+   └─ Actualiza state.json (verification_result)
+   └─ Si PASS: "Listo para merge"
+   └─ Si FAIL: Sugiere /elsabro:execute para fix
+```
+
+---
+
+## REGLAS DE ORO
+
+1. **TaskCreate ANTES de cualquier acción**
+2. **TaskUpdate(in_progress) ANTES de Task()**
+3. **Tasks API como backend único** (NO duplicar con sistemas custom)
+4. **Metadata schema consistente** para type, priority, category
+5. **TaskList para sincronización** (NO archivos .md separados)
+6. **Mínimo 3 agentes HAIKU para exploración**
+7. **OPUS para implementación y verificación**
+8. **Context7 ANTES de escribir código con librerías**
+9. **Paralelismo OBLIGATORIO cuando las tareas son independientes**
+10. **Pasar contexto via Task metadata** al siguiente comando