elsabro 2.2.0 → 2.3.0

package/agents/elsabro-orchestrator.md

@@ -150,6 +150,119 @@ Para cada story sin dependencias:
 ```
 </execution_pattern>
 
+<error_contracts>
+## Contratos de Error en Ejecución Paralela
+
+**IMPORTAR**: Este agente DEBE seguir `/references/error-contracts.md` para manejo de errores.
+
+### Integración Obligatoria
+
+Antes de ejecutar cualquier wave, el orquestador DEBE:
+
+1. **Validar Registry** (ContractRegistryValidator)
+```javascript
+const validator = new ContractRegistryValidator("./agents");
+const batch = await validator.validateBatch(agentsNeeded);
+if (!batch.canProceed) {
+  displayError({
+    severity: "CRITICAL",
+    message: `${batch.invalid} agentes faltantes`,
+    options: ["update", "help", "abort"]
+  });
+  return;
+}
+```
+
+2. **Validar Sesión** (ContractSessionValidator)
+```javascript
+const sessionValidator = new ContractSessionValidator();
+const session = await sessionValidator.load();
+if (!session.success) {
+  // Intentar reparar o escalar a usuario
+}
+```
+
+3. **Iniciar Timeout** (ContractTimeoutHandler)
+```javascript
+const timeoutHandler = new ContractTimeoutHandler();
+timeoutHandler.startTimeout(waveId, 30 * 60 * 1000);
+```
+
+### Durante Ejecución Paralela
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│             ERROR HANDLING EN WAVES PARALELAS                       │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  Wave N ejecutando:                                                 │
+│  ├─ Agent 1 ──→ SUCCESS ──┐                                        │
+│  ├─ Agent 2 ──→ FAILED ───┼──→ ErrorAggregator.addResult()         │
+│  └─ Agent 3 ──→ SUCCESS ──┘                                        │
+│                           ↓                                         │
+│                    ErrorAggregator.aggregate()                      │
+│                           ↓                                         │
+│              ┌────────────┴────────────┐                           │
+│              │ Aplicar Policy (quorum) │                           │
+│              └────────────┬────────────┘                           │
+│                           ↓                                         │
+│    ┌──────────────────────┴──────────────────────┐                 │
+│    │ 2/3 = 66% > 50%      │ 1/3 = 33% < 50%      │                 │
+│    │ → CONTINUE           │ → STOP               │                 │
+│    │ → Notificar warning  │ → Escalar a usuario  │                 │
+│    └──────────────────────┴──────────────────────┘                 │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+### Retry Automático
+
+Para errores transitorios (timeout, network):
+
+```javascript
+const retryPolicy = new ContractRetryPolicy({
+  maxAttempts: 3,
+  baseDelayMs: 1000,
+  backoffMultiplier: 2
+});
+
+const result = await retryPolicy.executeWithRetry(
+  operationId,
+  async () => executeAgent(agent),
+  { wave: waveId }
+);
+```
+
+### Notificación al Usuario
+
+**INMEDIATA para CRITICAL:**
+```
+╔════════════════════════════════════════════════════╗
+║  🔴 CRITICAL: Wave 2 Agent Failed                  ║
+╠════════════════════════════════════════════════════╣
+║  Agent: elsabro-verifier                           ║
+║  Error: Timeout after 30 minutes                   ║
+║                                                    ║
+║  [r] Retry now  [s] Skip  [a] Abort               ║
+╚════════════════════════════════════════════════════╝
+```
+
+**AL FINAL para otros:**
+```
+╔════════════════════════════════════════════════════╗
+║  PARALLEL EXECUTION SUMMARY                        ║
+╠════════════════════════════════════════════════════╣
+║  Waves: 3/3 completed                              ║
+║  Agents: 8/9 succeeded (89%)                       ║
+║                                                    ║
+║  Errors:                                           ║
+║  └─ Wave 2: elsabro-qa timeout (retried 2x)       ║
+║                                                    ║
+║  Status: SUCCESS (quorum met)                      ║
+╚════════════════════════════════════════════════════╝
+```
+</error_contracts>
+
 <conflict_resolution>
 ## Resolución de Conflictos
 

package/commands/elsabro/execute.md

@@ -588,74 +588,251 @@ TaskUpdate({
 ```
 </parallel_execution>
 
+<worktrees_integration>
+## Integración con Worktrees Paralelos
+
+**IMPORTAR**: En waves con múltiples agentes, usar worktrees para aislamiento.
+
+### Cuándo Usar Worktrees
+
+- Profile "careful": SIEMPRE usar worktrees
+- Más de 2 agentes en wave: Considerar worktrees
+- Archivos compartidos entre agentes: OBLIGATORIO usar worktrees
+
+### Flujo con Worktrees
+
+```javascript
+// Antes de ejecutar wave paralela
+if (shouldUseWorktrees(wave, profile)) {
+  const agents = wave.plans.map(p => p.agent);
+
+  // Crear worktrees
+  Bash(`./scripts/setup-parallel-worktrees.sh create ${agents.join(' ')}`);
+
+  // Ejecutar agentes en sus worktrees
+  for (const agent of agents) {
+    Task({
+      subagent_type: agent,
+      prompt: `Trabaja en worktree: ../elsabro-worktrees/${agent}-wt/`
+    });
+  }
+
+  // Merge y cleanup al completar
+  Bash(`./scripts/setup-parallel-worktrees.sh complete ${agents.join(' ')}`);
+}
+```
+
+### Resolución de Conflictos
+
+Si hay conflictos en el merge:
+1. Pausar ejecución
+2. Mostrar conflictos al usuario
+3. Opciones: resolver manual, descartar branch, o abortar
+</worktrees_integration>
+
 <error_handling>
-## Manejo de Errores
+## Manejo de Errores en Ejecucion Paralela
 
-### Política de Ejecución Paralela
+**IMPORTAR**: Este comando DEBE seguir `/references/error-contracts.md`.
 
-Este comando usa **policy: quorum** por defecto.
+### Inicializacion con Contratos
 
+```javascript
+// Antes de cualquier wave, inicializar contratos
+const registryValidator = new ContractRegistryValidator();
+const sessionValidator = new ContractSessionValidator();
+const timeoutHandler = new ContractTimeoutHandler();
+const retryPolicy = new ContractRetryPolicy({
+  maxAttempts: 3,
+  baseDelayMs: 1000,
+  backoffMultiplier: 2
+});
+const errorAggregator = new ContractErrorAggregator("quorum");
+const severityClassifier = new ContractSeverityClassifier();
+
+// 1. Validar registry
+const agentsNeeded = dispatcher.exploration.agents;
+const batch = await registryValidator.validateBatch(agentsNeeded);
+if (!batch.canProceed) {
+  return handleCriticalError("REGISTRY_MISSING", batch.details);
+}
+
+// 2. Validar sesion
+const session = await sessionValidator.load();
+if (!session.success) {
+  return handleCriticalError("SESSION_INVALID", session);
+}
 ```
-┌────────────────────────────────────────────────┐
-│  PARALLEL EXECUTION POLICY: quorum             │
-├────────────────────────────────────────────────┤
-│  Si >50% de agentes tienen éxito → continuar  │
-│  Si ≤50% de agentes fallan → STOP             │
-└────────────────────────────────────────────────┘
+
+### Error Handling por Fase
+
+#### Fase Exploracion (HAIKU x3)
+```javascript
+// Policy: continue_all (exploracion es best-effort)
+errorAggregator.setPolicy("continue_all");
+
+const results = await Promise.all([
+  executeWithRetry("explore-1", () => Task(Explore)),
+  executeWithRetry("explore-2", () => Task(CodeExplorer)),
+  executeWithRetry("explore-3", () => Task(Plan))
+]);
+
+const summary = await errorAggregator.aggregate("exploration", results);
+// continue_all: siempre continua, reporta al final
 ```
 
-### Clasificación de Errores
+#### Fase Implementacion (OPUS x2 por wave)
+```javascript
+// Policy: quorum (>50% debe tener exito)
+errorAggregator.setPolicy("quorum");
+
+for (const wave of waves) {
+  timeoutHandler.startTimeout(wave.id, 60 * 60 * 1000); // 60min por wave
+
+  const results = await Promise.all(
+    wave.plans.map(plan =>
+      executeWithRetry(plan.id, () => Task(elsabro-executor, plan))
+    )
+  );
+
+  const summary = await errorAggregator.aggregate(wave.id, results);
+
+  if (summary.decision === "STOP") {
+    // Quorum no alcanzado
+    await notifyUserImmediately({
+      severity: "CRITICAL",
+      message: `Wave ${wave.id} fallo: ${summary.reason}`,
+      options: ["retry", "debug", "abort"]
+    });
+    return;
+  }
 
-| Severity | Emoji | Acción |
-|----------|-------|--------|
-| 🔴 CRITICAL | Parar | No puede continuar de ninguna forma |
-| 🟠 HIGH | Preguntar | Ofrecer opciones: fix/skip/abort |
-| 🟡 MEDIUM | Warning | Mostrar y continuar |
-| ⬜ LOW | Info | Log y continuar |
+  timeoutHandler.completeTimeout(wave.id);
+}
+```
+
+#### Fase Verificacion (OPUS x3)
+```javascript
+// Policy: fail_fast (verificacion debe pasar completa)
+errorAggregator.setPolicy("fail_fast");
+
+const verificationResults = await Promise.all([
+  executeWithRetry("verify-code", () => Task(CodeReviewer)),
+  executeWithRetry("verify-silent", () => Task(SilentFailureHunter)),
+  executeWithRetry("verify-tests", () => Task(TestAnalyzer))
+]);
+
+const summary = await errorAggregator.aggregate("verification", verificationResults);
+
+if (summary.decision === "STOP") {
+  // Cualquier fallo en verificacion es critico
+  await displayVerificationFailure(summary);
+  return;
+}
+```
+
+### Escalamiento de Errores
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│             ESCALAMIENTO DE ERRORES                                 │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  Error detectado                                                    │
+│        ↓                                                            │
+│  SeverityClassifier.classify(error)                                 │
+│        ↓                                                            │
+│  ┌─────────────────────────────────────────────────────────────┐   │
+│  │ CRITICAL: Notificar inmediatamente, STOP                    │   │
+│  │ HIGH:     Notificar, ofrecer opciones [fix/skip/abort]      │   │
+│  │ MEDIUM:   Agregar a resumen, continuar                      │   │
+│  │ LOW:      Log para debugging, continuar                     │   │
+│  └─────────────────────────────────────────────────────────────┘   │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
 
-### Si una tarea falla
+### Retry Automatico con Backoff
 
+```javascript
+async function executeWithRetry(operationId, operation) {
+  return await retryPolicy.executeWithRetry(
+    operationId,
+    operation,
+    {
+      onAttempt: (attempt) => {
+        console.log(`[RETRY] ${operationId}: Intento ${attempt}/3`);
+      },
+      onSuccess: (result, attempts) => {
+        if (attempts > 1) {
+          console.log(`[RECOVERED] ${operationId}: Exitoso en intento ${attempts}`);
+        }
+      },
+      onFailure: (error, attempts) => {
+        console.error(`[FAILED] ${operationId}: Fallo despues de ${attempts} intentos`);
+
+        // Clasificar para decidir siguiente accion
+        const classification = severityClassifier.classify(error.message);
+        if (classification.severity === "CRITICAL") {
+          throw new CriticalError(error, classification);
+        }
+      }
+    }
+  );
+}
 ```
-1. CLASIFICAR ERROR:
-   - Tests fallan → HIGH
-   - Build falla → HIGH
-   - Dependencia falta → HIGH (auto-fixable)
-   - Lint warnings → MEDIUM
-   - File not found crítico → CRITICAL
 
-2. APLICAR RETRY (si es transitorio):
-   - Attempt 1: Ejecutar
-   - Attempt 2: Esperar 1s, reintentar
-   - Attempt 3: Esperar 2s, reintentar
-   - Máximo 3 intentos, timeout total 2 min
+### Guardar Estado de Errores
+
+Al completar cada wave (exito o fallo):
 
-3. SI RETRY FALLA → Escalar según severidad
+```javascript
+// Actualizar state.json con errores para recovery
+state.errors = {
+  count: allErrors.length,
+  lastError: allErrors[allErrors.length - 1],
+  byWave: errorsByWave,
+  bySeverity: {
+    CRITICAL: criticalErrors,
+    HIGH: highErrors,
+    MEDIUM: mediumErrors,
+    LOW: lowErrors
+  }
+};
+
+state.parallelExecution = {
+  policy: currentPolicy,
+  activeAgents: [],
+  completedAgents: completedAgentIds,
+  failedAgents: failedAgentIds
+};
 
-4. MOSTRAR ERROR formateado:
-   ╔══════════════════════════════════════════╗
-   ║  🟠 ERROR: TESTS_FAILED                  ║
-   ║  Severity: HIGH                          ║
-   ╠══════════════════════════════════════════╣
-   ║  [Detalles del error]                    ║
-   ╠══════════════════════════════════════════╣
-   ║  [d] Debug   [s] Skip   [a] Abort        ║
-   ╚══════════════════════════════════════════╝
+await sessionValidator.save(state);
 ```
 
-### Reglas de Desviación
+### Clasificacion de Errores (Referencia Rapida)
+
+| Severity | Emoji | Accion |
+|----------|-------|--------|
+| CRITICAL | Parar | No puede continuar de ninguna forma |
+| HIGH | Preguntar | Ofrecer opciones: fix/skip/abort |
+| MEDIUM | Warning | Mostrar y continuar |
+| LOW | Info | Log y continuar |
+
+### Reglas de Desviacion
 
-| Situación | Severity | Acción |
+| Situacion | Severity | Accion |
 |-----------|----------|--------|
 | Bug que impide continuar | HIGH | Auto-fix (3 intentos) |
-| Falta validación crítica | HIGH | Auto-add |
+| Falta validacion critica | HIGH | Auto-add |
 | Falta dependencia | HIGH | Auto-install |
-| Cambio arquitectónico | HIGH | CHECKPOINT |
+| Cambio arquitectonico | HIGH | CHECKPOINT |
 | Tests fallan | HIGH | Debug o skip |
 | Lint warnings | MEDIUM | Continuar |
 
 ### Actualizar Estado con Tasks
 
-Después de errores, actualizar tanto SESSION-STATE.json como Tasks:
+Despues de errores, actualizar tanto SESSION-STATE.json como Tasks:
 
 ```javascript
 // 1. Actualizar task con metadata de error
@@ -681,13 +858,13 @@ TaskCreate({
   metadata: { type: "bugfix", parentPlan: "plan-X-id" }
 })  // → bugfix-id
 
-// 3. Bloquear verificación hasta que bugfix complete
+// 3. Bloquear verificacion hasta que bugfix complete
 TaskUpdate({
   taskId: "verify-aggregate-id",
   addBlockedBy: ["bugfix-id"]
 })
 
-// 4. También actualizar SESSION-STATE.json para compatibilidad
+// 4. Tambien actualizar SESSION-STATE.json para compatibilidad
 ```
 
 ### Rollback de Estado con Tasks
@@ -711,7 +888,7 @@ TaskUpdate({ taskId: "plan-X-id", status: "completed" })
 // Listar todas las tasks
 TaskList()
 
-// Ver detalles de una task específica
+// Ver detalles de una task especifica
 TaskGet({ taskId: "plan-X-id" })
 ```
 </error_handling>

package/commands/elsabro/start.md

@@ -418,6 +418,40 @@ Ejecuta `/elsabro:start` o el comando específico.
 ```
 </state_management>
 
+<memory_integration>
+## Integración con Memoria Persistente
+
+**IMPORTAR**: Este comando lee la memoria del proyecto al iniciar.
+
+### Al Iniciar Sesión
+
+```javascript
+// Leer memoria si existe
+const memoryFiles = [
+  ".planning/CLAUDE.md",
+  ".planning/mistakes.md",
+  ".planning/patterns.md"
+];
+
+for (const file of memoryFiles) {
+  const content = Read(file);
+  if (content) {
+    // Aplicar reglas de memoria en toda la sesión
+    applyMemoryRules(content);
+  }
+}
+```
+
+### Detección de Correcciones
+
+Durante la sesión, detectar triggers de corrección:
+- "No, hazlo así..."
+- "Siempre usa X en lugar de Y"
+- "Guarda esto en tu memoria"
+
+Y actualizar automáticamente `.planning/mistakes.md` o `.planning/patterns.md`.
+</memory_integration>
+
 <error_handling>
 ## Manejo de Errores
 

package/commands/elsabro/verify-work.md

@@ -104,6 +104,35 @@ Write(".elsabro/context.md", generateHumanReadableContext(state));
 ```
 </state_sync>
 
+<review_integration>
+## Integración con Code Review
+
+**IMPORTAR**: Este comando puede invocar `/elsabro:review` para verificación detallada.
+
+### Opción: Review Profundo
+
+Si el usuario solicita verificación exhaustiva, invocar:
+
+```javascript
+// Verificación con code review profesional
+Task({
+  subagent_type: "skill:review",
+  prompt: `
+    /elsabro:review --staged --save
+
+    Guarda el resultado en .planning/REVIEW.md
+  `
+})
+```
+
+### Checklist de Verificación Extendido
+
+Además de los checks estándar, verificar contra:
+- `.planning/mistakes.md` - ¿Se cometieron errores conocidos?
+- `.planning/patterns.md` - ¿Se siguieron los patrones preferidos?
+- `.planning/CLAUDE.md` - ¿Se respetaron las reglas del proyecto?
+</review_integration>
+
 ## Propósito
 
 Verificar que el trabajo completado cumple con los requirements, pasa todos los tests, y está listo para merge/deploy.

package/hooks/confirm-destructive.sh

@@ -0,0 +1,145 @@
+#!/bin/bash
+# confirm-destructive.sh - ELSABRO Hook: Confirmar antes de operaciones destructivas
+# Uso: Este hook se ejecuta antes de comandos Bash que coinciden con patrones destructivos
+# Patrones: rm -rf, git reset --hard, git clean -fd, git push --force, drop table, truncate
+
+# Colores
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+BOLD='\033[1m'
+NC='\033[0m'
+
+# Prefijo ELSABRO
+PREFIX="[ELSABRO:hook]"
+
+# Comando que se va a ejecutar (pasado como argumento)
+COMMAND="${1:-}"
+
+# Patrones destructivos y su descripcion
+declare -A DESTRUCTIVE_PATTERNS=(
+    ["rm -rf"]="Eliminacion recursiva forzada de archivos/directorios"
+    ["rm -r"]="Eliminacion recursiva de archivos/directorios"
+    ["git reset --hard"]="Descarta TODOS los cambios locales sin posibilidad de recuperacion"
+    ["git clean -fd"]="Elimina archivos no rastreados y directorios"
+    ["git clean -f"]="Elimina archivos no rastreados"
+    ["git push --force"]="Sobreescribe historial remoto (puede perder commits de otros)"
+    ["git push -f"]="Sobreescribe historial remoto (puede perder commits de otros)"
+    ["DROP TABLE"]="Elimina tabla de base de datos permanentemente"
+    ["drop table"]="Elimina tabla de base de datos permanentemente"
+    ["TRUNCATE"]="Elimina todos los datos de una tabla"
+    ["truncate"]="Elimina todos los datos de una tabla"
+    ["DELETE FROM"]="Elimina registros de base de datos"
+    ["delete from"]="Elimina registros de base de datos"
+    ["> /dev/null"]="Redirige output (potencialmente peligroso si mal usado)"
+    ["chmod 777"]="Permisos inseguros - todos pueden leer/escribir/ejecutar"
+    ["chmod -R"]="Cambio recursivo de permisos"
+    ["dd if="]="Operacion de disco de bajo nivel"
+    ["mkfs"]="Formateo de sistema de archivos"
+    [":(){ :|:& };:"]="Fork bomb - puede crashear el sistema"
+)
+
+# Detectar patron destructivo
+detect_destructive_pattern() {
+    local cmd="$1"
+
+    for pattern in "${!DESTRUCTIVE_PATTERNS[@]}"; do
+        if [[ "$cmd" == *"$pattern"* ]]; then
+            echo "$pattern"
+            return 0
+        fi
+    done
+
+    echo ""
+    return 1
+}
+
+# Mostrar advertencia
+show_warning() {
+    local pattern="$1"
+    local description="${DESTRUCTIVE_PATTERNS[$pattern]}"
+
+    echo ""
+    echo -e "${RED}${BOLD}========================================${NC}"
+    echo -e "${RED}${BOLD}  ADVERTENCIA: OPERACION DESTRUCTIVA${NC}"
+    echo -e "${RED}${BOLD}========================================${NC}"
+    echo ""
+    echo -e "${YELLOW}$PREFIX Comando detectado:${NC}"
+    echo -e "${BLUE}  $COMMAND${NC}"
+    echo ""
+    echo -e "${YELLOW}$PREFIX Patron peligroso:${NC} ${RED}$pattern${NC}"
+    echo -e "${YELLOW}$PREFIX Riesgo:${NC} $description"
+    echo ""
+    echo -e "${RED}${BOLD}Este comando puede causar perdida de datos irreversible.${NC}"
+    echo ""
+}
+
+# Solicitar confirmacion
+request_confirmation() {
+    # En modo no interactivo (CI/CD), rechazar automaticamente
+    if [ ! -t 0 ]; then
+        echo -e "${RED}$PREFIX Modo no interactivo detectado - rechazando comando destructivo${NC}"
+        echo -e "${YELLOW}$PREFIX Para ejecutar en CI, desactiva el hook 'confirm-destructive'${NC}"
+        return 1
+    fi
+
+    echo -e "${YELLOW}Para confirmar, escribe exactamente: ${BOLD}SI CONFIRMO${NC}"
+    echo -n "> "
+    read -r confirmation
+
+    if [ "$confirmation" = "SI CONFIRMO" ]; then
+        echo -e "${GREEN}$PREFIX Confirmado. Procediendo con el comando...${NC}"
+        return 0
+    else
+        echo -e "${RED}$PREFIX Cancelado. El comando NO se ejecutara.${NC}"
+        return 1
+    fi
+}
+
+# Registrar en log
+log_destructive_attempt() {
+    local pattern="$1"
+    local confirmed="$2"
+    local log_dir=".planning/logs"
+    local log_file="$log_dir/destructive-commands.log"
+
+    # Crear directorio si no existe
+    mkdir -p "$log_dir" 2>/dev/null || true
+
+    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
+    local status="REJECTED"
+    [ "$confirmed" = "true" ] && status="CONFIRMED"
+
+    echo "[$timestamp] $status | Pattern: $pattern | Command: $COMMAND" >> "$log_file" 2>/dev/null || true
+}
+
+# Main
+main() {
+    if [ -z "$COMMAND" ]; then
+        # Sin comando, permitir (no hay nada que verificar)
+        exit 0
+    fi
+
+    # Detectar si es destructivo
+    local pattern=$(detect_destructive_pattern "$COMMAND")
+
+    if [ -z "$pattern" ]; then
+        # No es destructivo, permitir
+        exit 0
+    fi
+
+    # Es destructivo - mostrar advertencia
+    show_warning "$pattern"
+
+    # Solicitar confirmacion
+    if request_confirmation; then
+        log_destructive_attempt "$pattern" "true"
+        exit 0  # Permitir ejecucion
+    else
+        log_destructive_attempt "$pattern" "false"
+        exit 1  # Bloquear ejecucion
+    fi
+}
+
+main "$@"