elsabro 2.1.0 → 2.3.0

package/references/error-contracts.md

@@ -0,0 +1,3102 @@
+---
+name: error-contracts
+description: Contratos de error para ejecucion paralela confiable
+version: 1.0.0
+---
+
+# ELSABRO Error Contracts
+
+## Vision General
+
+Este documento define los 7 contratos de error que garantizan ejecucion paralela confiable en ELSABRO. Cada contrato actua como una capa defensiva en cascada.
+
+```
++============================================================================+
+|                     CASCADA DEFENSIVA DE CONTRATOS                          |
++============================================================================+
+|                                                                            |
+|  [1] REGISTRY VALIDATOR                                                    |
+|       |                                                                    |
+|       v    Agentes/comandos existen?                                       |
+|  [2] TASK LIFECYCLE -----> NO --> ERROR: AGENT_NOT_FOUND                   |
+|       |                                                                    |
+|       v    Estado valido?                                                  |
+|  [3] TIMEOUT HANDLER -----> NO --> ERROR: INVALID_STATE_TRANSITION         |
+|       |                                                                    |
+|       v    Dentro de tiempo?                                               |
+|  [4] RETRY POLICY --------> NO --> ERROR: TASK_TIMEOUT                     |
+|       |                                                                    |
+|       v    Reintentos agotados?                                            |
+|  [5] ERROR AGGREGATOR ----> SI --> ERROR: RETRY_EXHAUSTED                  |
+|       |                                                                    |
+|       v    Errores recolectados                                            |
+|  [6] SEVERITY CLASSIFIER -> Clasificar cada error                          |
+|       |                                                                    |
+|       v    Decidir accion                                                  |
+|  [7] SESSION VALIDATOR ---> Validar integridad de estado                   |
+|       |                                                                    |
+|       v                                                                    |
+|  [OK] CONTINUAR o [STOP] ABORTAR                                           |
+|                                                                            |
++============================================================================+
+```
+
+---
+
+## Contrato 1: ContractRegistryValidator
+
+### Proposito
+
+Validar que todos los agentes, comandos y recursos referenciados existan antes de ejecutar cualquier operacion paralela.
+
+### Cuando se Activa
+
+- Antes de lanzar cualquier Task() con subagente
+- Antes de invocar comandos /elsabro:*
+- Antes de referenciar recursos externos (skills, profiles)
+
+### Comportamiento en Fallo
+
+```
+SI recurso no existe:
+  1. NO lanzar la tarea
+  2. Generar ERROR con codigo especifico
+  3. Sugerir alternativas si existen
+  4. Abortar operacion paralela si es critico
+```
+
+### Notificacion al Usuario
+
+```
++======================================================+
+|  ERROR: AGENT_NOT_FOUND                              |
+|  Severity: CRITICAL                                  |
++======================================================+
+|                                                      |
+|  El agente "elsabro-nonexistent" no existe          |
+|                                                      |
+|  Agentes similares disponibles:                      |
+|  - elsabro-executor                                  |
+|  - elsabro-verifier                                  |
+|  - elsabro-analyst                                   |
+|                                                      |
++------------------------------------------------------+
+|  ACCION REQUERIDA:                                   |
+|  -> Corregir nombre del agente en la configuracion   |
++======================================================+
+```
+
+### Codigo Ejecutable
+
+```javascript
+/**
+ * ContractRegistryValidator
+ * Valida existencia de agentes y recursos antes de ejecucion
+ */
+class ContractRegistryValidator {
+  constructor() {
+    // Registro de agentes validos por categoria
+    this.validAgents = {
+      exploration: [
+        'Explore',
+        'Plan',
+        'feature-dev:code-explorer'
+      ],
+      implementation: [
+        'elsabro-executor',
+        'elsabro-analyst',
+        'elsabro-planner',
+        'elsabro-debugger',
+        'feature-dev:code-architect'
+      ],
+      verification: [
+        'elsabro-verifier',
+        'pr-review-toolkit:code-reviewer',
+        'pr-review-toolkit:silent-failure-hunter',
+        'pr-review-toolkit:pr-test-analyzer'
+      ],
+      utility: [
+        'elsabro-qa',
+        'elsabro-tech-writer',
+        'elsabro-scrum-master',
+        'elsabro-ux-designer',
+        'elsabro-quick-dev',
+        'elsabro-yolo-dev'
+      ]
+    };
+
+    // Comandos validos
+    this.validCommands = [
+      'start', 'plan', 'execute', 'verify-work', 'debug', 'quick', 'new',
+      'pause-work', 'resume-work', 'progress',
+      'new-milestone', 'complete-milestone', 'audit-milestone', 'plan-milestone-gaps',
+      'add-phase', 'insert-phase', 'remove-phase', 'discuss-phase', 'research-phase',
+      'add-todo', 'check-todos',
+      'help', 'settings', 'set-profile', 'update', 'map-codebase', 'verify'
+    ];
+  }
+
+  /**
+   * Valida un agente individual
+   * @param {string} agentName - Nombre del agente
+   * @returns {Object} Resultado de validacion
+   */
+  validateAgent(agentName) {
+    const allAgents = Object.values(this.validAgents).flat();
+
+    if (allAgents.includes(agentName)) {
+      return {
+        valid: true,
+        agent: agentName,
+        category: this.getAgentCategory(agentName)
+      };
+    }
+
+    // Buscar sugerencias similares
+    const suggestions = this.findSimilarAgents(agentName, allAgents);
+
+    return {
+      valid: false,
+      agent: agentName,
+      error: {
+        code: 'AGENT_NOT_FOUND',
+        severity: 'CRITICAL',
+        message: `El agente "${agentName}" no existe en el registro`,
+        suggestions: suggestions,
+        canContinue: false
+      }
+    };
+  }
+
+  /**
+   * Valida multiples agentes para ejecucion paralela
+   * @param {string[]} agentNames - Lista de agentes
+   * @returns {Object} Resultado agregado
+   */
+  validateAgents(agentNames) {
+    const results = agentNames.map(name => this.validateAgent(name));
+    const invalid = results.filter(r => !r.valid);
+
+    if (invalid.length === 0) {
+      return {
+        valid: true,
+        agents: results,
+        readyForParallel: true
+      };
+    }
+
+    return {
+      valid: false,
+      agents: results,
+      errors: invalid.map(r => r.error),
+      readyForParallel: false,
+      aggregatedError: {
+        code: 'AGENTS_VALIDATION_FAILED',
+        severity: 'CRITICAL',
+        message: `${invalid.length} de ${agentNames.length} agentes no son validos`,
+        details: invalid
+      }
+    };
+  }
+
+  /**
+   * Valida un comando ELSABRO
+   * @param {string} commandName - Nombre del comando
+   * @returns {Object} Resultado de validacion
+   */
+  validateCommand(commandName) {
+    const normalizedName = commandName.replace(/^\/elsabro:/, '');
+
+    if (this.validCommands.includes(normalizedName)) {
+      return {
+        valid: true,
+        command: normalizedName
+      };
+    }
+
+    const suggestions = this.findSimilarCommands(normalizedName);
+
+    return {
+      valid: false,
+      command: commandName,
+      error: {
+        code: 'COMMAND_NOT_FOUND',
+        severity: 'CRITICAL',
+        message: `El comando "${commandName}" no existe`,
+        suggestions: suggestions.map(s => `/elsabro:${s}`),
+        canContinue: false
+      }
+    };
+  }
+
+  /**
+   * Obtiene la categoria de un agente
+   */
+  getAgentCategory(agentName) {
+    for (const [category, agents] of Object.entries(this.validAgents)) {
+      if (agents.includes(agentName)) {
+        return category;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Encuentra agentes similares usando distancia de Levenshtein
+   */
+  findSimilarAgents(input, agents) {
+    return agents
+      .map(agent => ({
+        name: agent,
+        distance: this.levenshteinDistance(input.toLowerCase(), agent.toLowerCase())
+      }))
+      .filter(a => a.distance <= 5)
+      .sort((a, b) => a.distance - b.distance)
+      .slice(0, 3)
+      .map(a => a.name);
+  }
+
+  /**
+   * Encuentra comandos similares
+   */
+  findSimilarCommands(input) {
+    return this.validCommands
+      .map(cmd => ({
+        name: cmd,
+        distance: this.levenshteinDistance(input.toLowerCase(), cmd.toLowerCase())
+      }))
+      .filter(c => c.distance <= 4)
+      .sort((a, b) => a.distance - b.distance)
+      .slice(0, 3)
+      .map(c => c.name);
+  }
+
+  /**
+   * Calcula distancia de Levenshtein entre dos strings
+   */
+  levenshteinDistance(str1, str2) {
+    const m = str1.length;
+    const n = str2.length;
+    const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
+
+    for (let i = 0; i <= m; i++) dp[i][0] = i;
+    for (let j = 0; j <= n; j++) dp[0][j] = j;
+
+    for (let i = 1; i <= m; i++) {
+      for (let j = 1; j <= n; j++) {
+        if (str1[i - 1] === str2[j - 1]) {
+          dp[i][j] = dp[i - 1][j - 1];
+        } else {
+          dp[i][j] = 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+      }
+    }
+
+    return dp[m][n];
+  }
+
+  /**
+   * Valida un batch de agentes
+   * @param {Object[]} agents - Lista de objetos agente a validar
+   * @returns {Object} Resultado de validacion batch
+   */
+  async validateBatch(agents) {
+    const results = await Promise.all(
+      agents.map(agent => this.validate("agent", agent))
+    );
+    const failures = results.filter(r => !r.valid);
+    return {
+      total: agents.length,
+      valid: results.length - failures.length,
+      invalid: failures.length,
+      details: failures,
+      canProceed: failures.length === 0
+    };
+  }
+}
+
+// Ejemplo de uso
+const validator = new ContractRegistryValidator();
+
+// Validar agentes para ejecucion paralela
+const result = validator.validateAgents([
+  'elsabro-executor',
+  'feature-dev:code-explorer',
+  'elsabro-nonexistent'  // Este fallara
+]);
+
+if (!result.valid) {
+  console.log('Validacion fallida:', result.aggregatedError);
+}
+```
+
+---
+
+## Contrato 2: ContractTaskLifecycle
+
+### Proposito
+
+Garantizar que todas las tareas sigan el ciclo de vida correcto: INIT -> ACTIVE -> COMPLETE (o ERROR).
+
+### Cuando se Activa
+
+- Al crear una Task con TaskCreate
+- Al cambiar estado con TaskUpdate
+- Al completar o fallar una tarea
+
+### Comportamiento en Fallo
+
+```
+SI transicion invalida:
+  1. Rechazar la operacion
+  2. Mantener estado anterior
+  3. Generar ERROR con transicion invalida
+  4. Sugerir transicion correcta
+```
+
+### Notificacion al Usuario
+
+```
++======================================================+
+|  ERROR: INVALID_STATE_TRANSITION                     |
+|  Severity: HIGH                                      |
++======================================================+
+|                                                      |
+|  Transicion invalida detectada:                      |
+|  INIT -> COMPLETED (saltando ACTIVE)                 |
+|                                                      |
+|  Flujo correcto:                                     |
+|  INIT -> ACTIVE -> COMPLETED                         |
+|         INIT -> ACTIVE -> ERROR                      |
+|                                                      |
++------------------------------------------------------+
+|  Opciones:                                           |
+|  [f] Forzar transicion (no recomendado)              |
+|  [c] Corregir flujo automaticamente                  |
+|  [a] Abortar operacion                               |
++======================================================+
+```
+
+### Codigo Ejecutable
+
+```javascript
+/**
+ * ContractTaskLifecycle
+ * Garantiza transiciones de estado validas para tareas
+ */
+class ContractTaskLifecycle {
+  // Estados consistentes con config.json
+  static STATES = {
+    INIT: "INIT",
+    ACTIVE: "ACTIVE",
+    COMPLETE: "COMPLETE",
+    FAILED: "FAILED",
+    ROLLED_BACK: "ROLLED_BACK",
+    DELETED: "DELETED"
+  };
+
+  static VALID_TRANSITIONS = {
+    INIT: ["ACTIVE", "FAILED", "DELETED"],
+    ACTIVE: ["COMPLETE", "FAILED", "ROLLED_BACK"],
+    COMPLETE: ["ROLLED_BACK"],
+    FAILED: ["ACTIVE", "DELETED"],
+    ROLLED_BACK: ["INIT"],
+    DELETED: []
+  };
+
+  constructor() {
+    // Estados validos (usando static para consistencia)
+    this.states = ContractTaskLifecycle.STATES;
+
+    // Transiciones validas: desde -> [hacia]
+    this.validTransitions = ContractTaskLifecycle.VALID_TRANSITIONS;
+
+    // Historial de tareas para tracking
+    this.taskHistory = new Map();
+  }
+
+  /**
+   * Registra una nueva tarea
+   * @param {string} taskId - ID de la tarea
+   * @param {Object} metadata - Metadata de la tarea
+   */
+  registerTask(taskId, metadata = {}) {
+    const task = {
+      id: taskId,
+      state: this.states.INIT,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      transitions: [{
+        from: null,
+        to: this.states.INIT,
+        at: new Date().toISOString()
+      }],
+      metadata: metadata
+    };
+
+    this.taskHistory.set(taskId, task);
+
+    return {
+      valid: true,
+      task: task
+    };
+  }
+
+  /**
+   * Valida y ejecuta una transicion de estado
+   * @param {string} taskId - ID de la tarea
+   * @param {string} newState - Nuevo estado
+   * @returns {Object} Resultado de la transicion
+   */
+  transition(taskId, newState) {
+    const task = this.taskHistory.get(taskId);
+
+    if (!task) {
+      return {
+        valid: false,
+        error: {
+          code: 'TASK_NOT_FOUND',
+          severity: 'CRITICAL',
+          message: `Tarea "${taskId}" no encontrada en el registro`,
+          canContinue: false
+        }
+      };
+    }
+
+    const currentState = task.state;
+    const allowedTransitions = this.validTransitions[currentState] || [];
+
+    if (!allowedTransitions.includes(newState)) {
+      return {
+        valid: false,
+        error: {
+          code: 'INVALID_STATE_TRANSITION',
+          severity: 'HIGH',
+          message: `Transicion invalida: ${currentState} -> ${newState}`,
+          currentState: currentState,
+          attemptedState: newState,
+          allowedTransitions: allowedTransitions,
+          canContinue: true,
+          suggestedFix: this.suggestCorrectTransition(currentState, newState)
+        }
+      };
+    }
+
+    // Ejecutar transicion
+    task.transitions.push({
+      from: currentState,
+      to: newState,
+      at: new Date().toISOString()
+    });
+    task.state = newState;
+    task.updatedAt = new Date().toISOString();
+
+    return {
+      valid: true,
+      task: task,
+      transition: {
+        from: currentState,
+        to: newState
+      }
+    };
+  }
+
+  /**
+   * Valida el ciclo completo de una tarea
+   * @param {string} taskId - ID de la tarea
+   */
+  validateLifecycle(taskId) {
+    const task = this.taskHistory.get(taskId);
+
+    if (!task) {
+      return { valid: false, error: 'Task not found' };
+    }
+
+    const requiredFlow = ['init', 'in_progress'];
+    const actualFlow = task.transitions.map(t => t.to);
+
+    // Verificar que paso por INIT y ACTIVE
+    const hasInit = actualFlow.includes('init');
+    const hasActive = actualFlow.includes('in_progress');
+
+    if (!hasInit || !hasActive) {
+      return {
+        valid: false,
+        error: {
+          code: 'INCOMPLETE_LIFECYCLE',
+          severity: 'MEDIUM',
+          message: 'La tarea no siguio el ciclo de vida completo',
+          expectedFlow: requiredFlow,
+          actualFlow: actualFlow
+        }
+      };
+    }
+
+    return {
+      valid: true,
+      lifecycle: actualFlow,
+      duration: this.calculateDuration(task)
+    };
+  }
+
+  /**
+   * Sugiere la transicion correcta
+   */
+  suggestCorrectTransition(currentState, attemptedState) {
+    // Si intenta ir a COMPLETED desde INIT, sugerir pasar por ACTIVE
+    if (currentState === 'init' && attemptedState === 'completed') {
+      return {
+        suggestion: 'Primero transicionar a in_progress, luego a completed',
+        steps: ['in_progress', 'completed']
+      };
+    }
+
+    return {
+      suggestion: `Transicionar a uno de: ${this.validTransitions[currentState].join(', ')}`,
+      steps: this.validTransitions[currentState]
+    };
+  }
+
+  /**
+   * Calcula la duracion de una tarea
+   */
+  calculateDuration(task) {
+    const start = new Date(task.createdAt);
+    const end = new Date(task.updatedAt);
+    return end - start;
+  }
+
+  /**
+   * Obtiene el estado actual de todas las tareas
+   */
+  getTasksStatus() {
+    const status = {
+      total: this.taskHistory.size,
+      byState: {},
+      active: [],
+      failed: []
+    };
+
+    for (const [id, task] of this.taskHistory) {
+      status.byState[task.state] = (status.byState[task.state] || 0) + 1;
+
+      if (task.state === 'in_progress') {
+        status.active.push(id);
+      }
+      if (task.state === 'error') {
+        status.failed.push(id);
+      }
+    }
+
+    return status;
+  }
+}
+
+// Ejemplo de uso
+const lifecycle = new ContractTaskLifecycle();
+
+// Flujo correcto
+lifecycle.registerTask('task-001', { type: 'exploration' });
+lifecycle.transition('task-001', 'in_progress');
+lifecycle.transition('task-001', 'completed');
+
+// Flujo incorrecto (detectado)
+lifecycle.registerTask('task-002', { type: 'implementation' });
+const badResult = lifecycle.transition('task-002', 'completed');  // Error!
+if (!badResult.valid) {
+  console.log('Error detectado:', badResult.error);
+}
+```
+
+---
+
+## Contrato 3: ContractTimeoutHandler
+
+### Proposito
+
+Manejar timeouts de tareas paralelas con health checks periodicos y terminacion controlada.
+
+### Cuando se Activa
+
+- Al lanzar cualquier Task() paralela
+- Durante health checks periodicos (cada 5 segundos)
+- Cuando una tarea excede su tiempo maximo (30 minutos default)
+
+### Comportamiento en Fallo
+
+```
+SI timeout excedido:
+  1. Intentar terminacion graceful (10s)
+  2. Si no responde, terminacion forzada
+  3. Marcar tarea como TIMEOUT
+  4. Notificar al agregador de errores
+  5. Decidir si continuar o abortar segun policy
+```
+
+### Notificacion al Usuario
+
+```
++======================================================+
+|  WARNING: TASK_TIMEOUT                               |
+|  Severity: HIGH                                      |
++======================================================+
+|                                                      |
+|  La tarea "explore-codebase" excedio el timeout      |
+|                                                      |
+|  Tiempo configurado: 30 minutos                      |
+|  Tiempo transcurrido: 31:45                          |
+|  Ultimo health check: hace 35 segundos               |
+|                                                      |
++------------------------------------------------------+
+|  Estado actual:                                      |
+|  - Agente: elsabro-executor                          |
+|  - Fase: in_progress                                 |
+|  - Output parcial: 1,234 tokens                      |
+|                                                      |
++------------------------------------------------------+
+|  Opciones:                                           |
+|  [e] Extender timeout (+15 min)                      |
+|  [t] Terminar y usar output parcial                  |
+|  [r] Reintentar desde inicio                         |
+|  [a] Abortar toda la operacion                       |
++======================================================+
+```
+
+### Codigo Ejecutable
+
+```javascript
+/**
+ * ContractTimeoutHandler
+ * Maneja timeouts con health checks y terminacion controlada
+ */
+class ContractTimeoutHandler {
+  constructor(options = {}) {
+    this.defaultTimeout = options.defaultTimeout || 30 * 60 * 1000;  // 30 min
+    this.healthCheckInterval = options.healthCheckInterval || 5000;   // 5 seg
+    this.gracefulShutdownTime = options.gracefulShutdownTime || 10000; // 10 seg
+
+    this.activeTasks = new Map();
+    this.healthCheckTimers = new Map();
+  }
+
+  /**
+   * Inicia el tracking de una tarea con timeout
+   * @param {string} taskId - ID de la tarea
+   * @param {Object} options - Opciones de timeout
+   */
+  startTracking(taskId, options = {}) {
+    const timeout = options.timeout || this.defaultTimeout;
+    const startTime = Date.now();
+
+    const taskTracker = {
+      taskId: taskId,
+      startTime: startTime,
+      timeout: timeout,
+      lastHealthCheck: startTime,
+      healthCheckCount: 0,
+      status: 'active',
+      partialOutput: null
+    };
+
+    this.activeTasks.set(taskId, taskTracker);
+
+    // Iniciar health checks periodicos
+    const healthTimer = setInterval(() => {
+      this.performHealthCheck(taskId);
+    }, this.healthCheckInterval);
+
+    this.healthCheckTimers.set(taskId, healthTimer);
+
+    // Timer de timeout principal
+    setTimeout(() => {
+      this.handleTimeout(taskId);
+    }, timeout);
+
+    return {
+      taskId: taskId,
+      timeout: timeout,
+      startTime: new Date(startTime).toISOString()
+    };
+  }
+
+  /**
+   * Realiza un health check de la tarea
+   * @param {string} taskId - ID de la tarea
+   */
+  performHealthCheck(taskId) {
+    const tracker = this.activeTasks.get(taskId);
+
+    if (!tracker || tracker.status !== 'active') {
+      this.stopTracking(taskId);
+      return;
+    }
+
+    const now = Date.now();
+    const elapsed = now - tracker.startTime;
+    const remaining = tracker.timeout - elapsed;
+
+    tracker.lastHealthCheck = now;
+    tracker.healthCheckCount++;
+
+    // Calcular progreso estimado
+    const progress = {
+      elapsed: elapsed,
+      remaining: remaining,
+      percentage: Math.min(100, (elapsed / tracker.timeout) * 100),
+      healthChecks: tracker.healthCheckCount
+    };
+
+    // Emitir evento de health check
+    this.emitHealthStatus(taskId, progress);
+
+    // Warning si queda poco tiempo
+    if (remaining < 60000 && remaining > 0) {  // Menos de 1 minuto
+      this.emitWarning(taskId, {
+        code: 'TIMEOUT_IMMINENT',
+        severity: 'MEDIUM',
+        message: `Tarea ${taskId} tiene menos de 1 minuto antes del timeout`,
+        remaining: remaining
+      });
+    }
+
+    return progress;
+  }
+
+  /**
+   * Maneja el timeout de una tarea
+   * @param {string} taskId - ID de la tarea
+   */
+  handleTimeout(taskId) {
+    const tracker = this.activeTasks.get(taskId);
+
+    if (!tracker || tracker.status !== 'active') {
+      return;  // Ya fue manejado
+    }
+
+    tracker.status = 'timeout';
+
+    // Intentar terminacion graceful
+    const gracefulResult = this.attemptGracefulShutdown(taskId);
+
+    if (!gracefulResult.success) {
+      // Terminacion forzada
+      this.forceTerminate(taskId);
+    }
+
+    // Generar error de timeout
+    const timeoutError = {
+      code: 'TASK_TIMEOUT',
+      severity: 'HIGH',
+      taskId: taskId,
+      configuredTimeout: tracker.timeout,
+      elapsedTime: Date.now() - tracker.startTime,
+      lastHealthCheck: new Date(tracker.lastHealthCheck).toISOString(),
+      partialOutput: tracker.partialOutput,
+      canContinue: true,
+      options: ['extend', 'terminate', 'retry', 'abort']
+    };
+
+    this.stopTracking(taskId);
+
+    return timeoutError;
+  }
+
+  /**
+   * Intenta terminacion graceful
+   */
+  attemptGracefulShutdown(taskId) {
+    // Simular intento de terminacion graceful
+    // En implementacion real, enviaria senal a la tarea
+    return {
+      success: true,
+      taskId: taskId,
+      method: 'graceful'
+    };
+  }
+
+  /**
+   * Fuerza terminacion de la tarea
+   */
+  forceTerminate(taskId) {
+    const tracker = this.activeTasks.get(taskId);
+    if (tracker) {
+      tracker.status = 'terminated';
+    }
+
+    return {
+      taskId: taskId,
+      method: 'forced',
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Extiende el timeout de una tarea
+   * @param {string} taskId - ID de la tarea
+   * @param {number} additionalTime - Tiempo adicional en ms
+   */
+  extendTimeout(taskId, additionalTime = 15 * 60 * 1000) {
+    const tracker = this.activeTasks.get(taskId);
+
+    if (!tracker) {
+      return {
+        success: false,
+        error: 'Task not found'
+      };
+    }
+
+    tracker.timeout += additionalTime;
+    tracker.status = 'active';
+
+    return {
+      success: true,
+      taskId: taskId,
+      newTimeout: tracker.timeout,
+      additionalTime: additionalTime
+    };
+  }
+
+  /**
+   * Detiene el tracking de una tarea
+   */
+  stopTracking(taskId) {
+    const timer = this.healthCheckTimers.get(taskId);
+    if (timer) {
+      clearInterval(timer);
+      this.healthCheckTimers.delete(taskId);
+    }
+    this.activeTasks.delete(taskId);
+  }
+
+  /**
+   * Marca una tarea como completada
+   */
+  markComplete(taskId, result = null) {
+    const tracker = this.activeTasks.get(taskId);
+
+    if (tracker) {
+      tracker.status = 'completed';
+      tracker.partialOutput = result;
+    }
+
+    this.stopTracking(taskId);
+
+    return {
+      taskId: taskId,
+      status: 'completed',
+      duration: tracker ? Date.now() - tracker.startTime : null
+    };
+  }
+
+  /**
+   * Emite estado de health check (para logging/UI)
+   */
+  emitHealthStatus(taskId, progress) {
+    // En implementacion real, emitir a event bus o logger
+    console.log(`[HEALTH] Task ${taskId}: ${progress.percentage.toFixed(1)}% - ${progress.healthChecks} checks`);
+  }
+
+  /**
+   * Emite warning
+   */
+  emitWarning(taskId, warning) {
+    console.log(`[WARNING] ${warning.message}`);
+  }
+
+  /**
+   * Obtiene estado de todas las tareas activas
+   */
+  getActiveTasksStatus() {
+    const status = [];
+
+    for (const [taskId, tracker] of this.activeTasks) {
+      const elapsed = Date.now() - tracker.startTime;
+      status.push({
+        taskId: taskId,
+        status: tracker.status,
+        elapsed: elapsed,
+        remaining: tracker.timeout - elapsed,
+        healthChecks: tracker.healthCheckCount
+      });
+    }
+
+    return status;
+  }
+
+  /**
+   * Alias para startTracking - para compatibilidad con contratos
+   * @param {string} operationId - ID de la operacion
+   * @param {number} limitMs - Limite de tiempo en ms
+   * @param {Object} metadata - Metadata adicional
+   */
+  startTimeout(operationId, limitMs, metadata) {
+    return this.startTracking(operationId, { timeout: limitMs, ...metadata });
+  }
+
+  /**
+   * Alias para markComplete - para compatibilidad con contratos
+   * @param {string} operationId - ID de la operacion
+   * @param {number} actualDuration - Duracion real de la operacion
+   */
+  completeTimeout(operationId, actualDuration) {
+    return this.markComplete(operationId, { duration: actualDuration });
+  }
+}
+
+// Ejemplo de uso
+const timeoutHandler = new ContractTimeoutHandler({
+  defaultTimeout: 5 * 60 * 1000,  // 5 minutos para testing
+  healthCheckInterval: 1000       // 1 segundo
+});
+
+// Iniciar tracking
+timeoutHandler.startTracking('task-parallel-001');
+timeoutHandler.startTracking('task-parallel-002');
+
+// Obtener estado
+const status = timeoutHandler.getActiveTasksStatus();
+console.log('Active tasks:', status);
+```
+
+---
+
+## Contrato 4: ContractRetryPolicy
+
+### Proposito
+
+Implementar politica de reintentos con backoff exponencial para operaciones fallidas.
+
+### Cuando se Activa
+
+- Cuando una tarea falla con error transitorio
+- Despues de timeout
+- En errores de red o rate limit
+
+### Comportamiento en Fallo
+
+```
+Intento 1: Ejecutar inmediatamente
+  |
+  v FALLO
+Intento 2: Esperar 1s, reintentar
+  |
+  v FALLO
+Intento 3: Esperar 2s, reintentar
+  |
+  v FALLO
+Intento 4: Esperar 4s, reintentar
+  |
+  v FALLO
+-> RETRY_EXHAUSTED: Escalar a usuario
+```
+
+### Notificacion al Usuario
+
+```
++------------------------------------------------------+
+|  RETRY: npm test                                     |
++------------------------------------------------------+
+|  Attempt 1/3: FAILED (timeout)                       |
+|  Waiting 1s before retry...                          |
+|                                                      |
+|  Attempt 2/3: FAILED (exit code 1)                   |
+|  Waiting 2s before retry...                          |
+|                                                      |
+|  Attempt 3/3: FAILED (exit code 1)                   |
+|                                                      |
+|  X All attempts exhausted                            |
+|  -> Error escalated to user                          |
++------------------------------------------------------+
+
++======================================================+
+|  ERROR: RETRY_EXHAUSTED                              |
+|  Severity: HIGH                                      |
++======================================================+
+|                                                      |
+|  Intentos: 3/3 agotados                              |
+|  Tiempo total: 8.5s                                  |
+|                                                      |
+|  Ultimo error:                                       |
+|  > Test suite failed to run                          |
+|  > Cannot find module '@/utils'                      |
+|                                                      |
++------------------------------------------------------+
+|  El problema parece ser:                             |
+|  -> Dependencia faltante o path alias incorrecto     |
+|                                                      |
+|  Opciones:                                           |
+|  [d] Investigar con /elsabro:debug                   |
+|  [r] Reintentar despues de arreglar                  |
+|  [s] Saltar esta tarea                               |
+|  [a] Abortar                                         |
++======================================================+
+```
+
+### Codigo Ejecutable
+
+```javascript
+/**
+ * ContractRetryPolicy
+ * Implementa reintentos con backoff exponencial
+ */
+class ContractRetryPolicy {
+  constructor(options = {}) {
+    this.maxAttempts = options.maxAttempts || 3;
+    this.baseDelayMs = options.baseDelayMs || 1000;
+    this.backoffMultiplier = options.backoffMultiplier || 2;
+    this.maxDelayMs = options.maxDelayMs || 30000;
+    this.timeoutPerAttemptMs = options.timeoutPerAttemptMs || 30000;
+    this.totalTimeoutMs = options.totalTimeoutMs || 120000;
+
+    // Errores que SI deben reintentarse
+    this.retryableErrors = [
+      'TIMEOUT',
+      'NETWORK_ERROR',
+      'RATE_LIMIT',
+      'SERVICE_UNAVAILABLE',
+      'CONNECTION_RESET',
+      'ECONNREFUSED',
+      'ETIMEDOUT'
+    ];
+
+    // Errores que NO deben reintentarse
+    this.nonRetryableErrors = [
+      'PARSE_ERROR',
+      'VALIDATION_ERROR',
+      'LOGIC_ERROR',
+      'FILE_NOT_FOUND',
+      'PERMISSION_DENIED',
+      'INVALID_ARGUMENT'
+    ];
+  }
+
+  /**
+   * Determina si un error es reintentable
+   * @param {Object} error - Error a evaluar
+   */
+  isRetryable(error) {
+    const errorCode = error.code || error.type || '';
+
+    // Verificar lista negra primero
+    if (this.nonRetryableErrors.some(e => errorCode.includes(e))) {
+      return false;
+    }
+
+    // Verificar lista blanca
+    if (this.retryableErrors.some(e => errorCode.includes(e))) {
+      return true;
+    }
+
+    // Por defecto, no reintentar errores desconocidos
+    return false;
+  }
+
+  /**
+   * Calcula el delay para el siguiente intento
+   * @param {number} attempt - Numero de intento (1-based)
+   */
+  calculateDelay(attempt) {
+    const delay = this.baseDelayMs * Math.pow(this.backoffMultiplier, attempt - 1);
+    return Math.min(delay, this.maxDelayMs);
+  }
+
+  /**
+   * Ejecuta una operacion con reintentos
+   * @param {Function} operation - Operacion a ejecutar
+   * @param {Object} context - Contexto de la operacion
+   */
+  async executeWithRetry(operation, context = {}) {
+    const startTime = Date.now();
+    const attempts = [];
+    let lastError = null;
+
+    for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
+      const attemptStart = Date.now();
+
+      try {
+        // Verificar timeout total
+        if (Date.now() - startTime > this.totalTimeoutMs) {
+          throw {
+            code: 'TOTAL_TIMEOUT_EXCEEDED',
+            message: `Timeout total de ${this.totalTimeoutMs}ms excedido`
+          };
+        }
+
+        // Ejecutar operacion
+        const result = await this.executeWithTimeout(operation, this.timeoutPerAttemptMs);
+
+        // Exito!
+        attempts.push({
+          attempt: attempt,
+          status: 'SUCCESS',
+          duration: Date.now() - attemptStart
+        });
+
+        return {
+          success: true,
+          result: result,
+          attempts: attempts,
+          totalDuration: Date.now() - startTime
+        };
+
+      } catch (error) {
+        lastError = error;
+
+        attempts.push({
+          attempt: attempt,
+          status: 'FAILED',
+          error: error.code || error.message,
+          duration: Date.now() - attemptStart
+        });
+
+        // Verificar si debe reintentar
+        if (!this.isRetryable(error)) {
+          return {
+            success: false,
+            error: this.createNonRetryableError(error, attempts),
+            attempts: attempts,
+            totalDuration: Date.now() - startTime
+          };
+        }
+
+        // Si hay mas intentos, esperar y reintentar
+        if (attempt < this.maxAttempts) {
+          const delay = this.calculateDelay(attempt);
+          await this.sleep(delay);
+        }
+      }
+    }
+
+    // Todos los intentos fallaron
+    return {
+      success: false,
+      error: this.createExhaustedError(lastError, attempts),
+      attempts: attempts,
+      totalDuration: Date.now() - startTime
+    };
+  }
+
+  /**
+   * Ejecuta operacion con timeout
+   */
+  async executeWithTimeout(operation, timeout) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject({ code: 'TIMEOUT', message: `Operation timed out after ${timeout}ms` });
+      }, timeout);
+
+      Promise.resolve(operation())
+        .then(result => {
+          clearTimeout(timer);
+          resolve(result);
+        })
+        .catch(error => {
+          clearTimeout(timer);
+          reject(error);
+        });
+    });
+  }
+
+  /**
+   * Crea error de reintentos agotados
+   */
+  createExhaustedError(lastError, attempts) {
+    return {
+      code: 'RETRY_EXHAUSTED',
+      severity: 'HIGH',
+      message: `Todos los ${this.maxAttempts} intentos fallaron`,
+      lastError: lastError,
+      attempts: attempts,
+      canContinue: true,
+      options: ['debug', 'retry_manual', 'skip', 'abort'],
+      suggestedAction: this.suggestAction(lastError)
+    };
+  }
+
+  /**
+   * Crea error no reintentable
+   */
+  createNonRetryableError(error, attempts) {
+    return {
+      code: 'NON_RETRYABLE_ERROR',
+      severity: 'HIGH',
+      message: `Error no reintentable: ${error.code || error.message}`,
+      originalError: error,
+      attempts: attempts,
+      reason: 'El tipo de error indica un problema que no se resolvera con reintentos',
+      canContinue: true,
+      options: ['fix_manual', 'skip', 'abort']
+    };
+  }
+
+  /**
+   * Sugiere accion basada en el error
+   */
+  suggestAction(error) {
+    const errorCode = error.code || '';
+
+    if (errorCode.includes('TIMEOUT')) {
+      return 'Considerar extender el timeout o revisar la carga del sistema';
+    }
+    if (errorCode.includes('NETWORK')) {
+      return 'Verificar conexion de red y disponibilidad del servicio';
+    }
+    if (errorCode.includes('RATE_LIMIT')) {
+      return 'Esperar antes de reintentar o reducir frecuencia de requests';
+    }
+
+    return 'Investigar la causa raiz con /elsabro:debug';
+  }
+
+  /**
+   * Helper para sleep
+   */
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Genera reporte visual de reintentos
+   */
+  generateRetryReport(attempts, context = {}) {
+    const lines = [
+      '+------------------------------------------------------+',
+      `|  RETRY: ${context.operation || 'operation'}`.padEnd(55) + '|',
+      '+------------------------------------------------------+'
+    ];
+
+    for (const attempt of attempts) {
+      const status = attempt.status === 'SUCCESS' ? 'SUCCESS' : 'FAILED';
+      const statusLine = `|  Attempt ${attempt.attempt}/${this.maxAttempts}: ${status}`;
+
+      if (attempt.error) {
+        lines.push(statusLine + ` (${attempt.error})`.padEnd(55 - statusLine.length) + '|');
+      } else {
+        lines.push(statusLine.padEnd(55) + '|');
+      }
+
+      if (attempt.attempt < attempts.length && attempt.status === 'FAILED') {
+        const delay = this.calculateDelay(attempt.attempt) / 1000;
+        lines.push(`|  Waiting ${delay}s before retry...`.padEnd(55) + '|');
+        lines.push('|'.padEnd(55) + '|');
+      }
+    }
+
+    const lastAttempt = attempts[attempts.length - 1];
+    if (lastAttempt.status === 'FAILED' && attempts.length >= this.maxAttempts) {
+      lines.push('|'.padEnd(55) + '|');
+      lines.push('|  X All attempts exhausted'.padEnd(55) + '|');
+      lines.push('|  -> Error escalated to user'.padEnd(55) + '|');
+    }
+
+    lines.push('+------------------------------------------------------+');
+
+    return lines.join('\n');
+  }
+}
+
+// Ejemplo de uso
+const retryPolicy = new ContractRetryPolicy({
+  maxAttempts: 3,
+  baseDelayMs: 1000,
+  backoffMultiplier: 2
+});
+
+// Operacion que podria fallar
+async function unreliableOperation() {
+  // Simular 60% de fallos
+  if (Math.random() < 0.6) {
+    throw { code: 'NETWORK_ERROR', message: 'Connection failed' };
+  }
+  return { success: true, data: 'result' };
+}
+
+// Ejecutar con reintentos
+retryPolicy.executeWithRetry(unreliableOperation)
+  .then(result => {
+    console.log(retryPolicy.generateRetryReport(result.attempts, { operation: 'api-call' }));
+  });
+```
+
+---
+
+## Contrato 5: ContractErrorAggregator
+
+### Proposito
+
+Colectar, agregar y aplicar politicas a errores de multiples tareas paralelas.
+
+### Cuando se Activa
+
+- Al finalizar una wave de tareas paralelas
+- Cuando cualquier tarea individual falla
+- Para decidir si continuar o abortar la operacion general
+
+### Comportamiento en Fallo
+
+```
+Politicas disponibles:
+- fail_fast: Un fallo = abortar todo
+- quorum: Continuar si >50% exito
+- continue_all: Continuar siempre, reportar fallos
+- critical_path: Abortar solo si falla tarea critica
+```
+
+### Notificacion al Usuario
+
+```
++======================================================+
+|  PARALLEL EXECUTION COMPLETE                         |
++======================================================+
+|  Policy: quorum                                      |
+|  Total: 4 agents                                     |
+|                                                      |
+|  OK Agent 1 (code-reviewer): SUCCESS (45s)           |
+|  OK Agent 2 (typescript-pro): SUCCESS (32s)          |
+|  X  Agent 3 (silent-failure): FAILED (timeout)       |
+|  OK Agent 4 (test-analyzer): SUCCESS (28s)           |
+|                                                      |
+|  Result: 3/4 (75%) - QUORUM MET                      |
+|  Status: CONTINUING                                  |
++======================================================+
+```
+
+### Codigo Ejecutable
+
+```javascript
+/**
+ * ContractErrorAggregator
+ * Colecta y aplica politicas a errores de ejecucion paralela
+ */
+class ContractErrorAggregator {
+  constructor() {
+    this.errors = [];
+    this.results = [];
+    this.policy = 'quorum';  // default
+    this.criticalAgents = [];
+  }
+
+  /**
+   * Configura la politica de agregacion
+   * @param {string} policy - Politica a usar
+   * @param {Object} options - Opciones adicionales
+   */
+  setPolicy(policy, options = {}) {
+    const validPolicies = ['fail_fast', 'quorum', 'continue_all', 'critical_path'];
+
+    if (!validPolicies.includes(policy)) {
+      throw new Error(`Politica invalida: ${policy}. Validas: ${validPolicies.join(', ')}`);
+    }
+
+    this.policy = policy;
+    this.criticalAgents = options.criticalAgents || [];
+    this.quorumThreshold = options.quorumThreshold || 0.5;  // 50%
+  }
+
+  /**
+   * Registra un resultado de tarea
+   * @param {Object} result - Resultado de la tarea
+   */
+  addResult(result) {
+    this.results.push({
+      taskId: result.taskId,
+      agent: result.agent,
+      status: result.status,
+      duration: result.duration,
+      output: result.output,
+      error: result.error,
+      timestamp: new Date().toISOString()
+    });
+
+    if (result.status === 'error' || result.status === 'timeout') {
+      this.errors.push({
+        taskId: result.taskId,
+        agent: result.agent,
+        error: result.error,
+        severity: this.determineSeverity(result),
+        isCritical: this.criticalAgents.includes(result.agent)
+      });
+    }
+
+    return this.evaluatePolicy();
+  }
+
+  /**
+   * Evalua si debe continuar segun la politica
+   */
+  evaluatePolicy() {
+    switch (this.policy) {
+      case 'fail_fast':
+        return this.evaluateFailFast();
+      case 'quorum':
+        return this.evaluateQuorum();
+      case 'continue_all':
+        return this.evaluateContinueAll();
+      case 'critical_path':
+        return this.evaluateCriticalPath();
+      default:
+        return this.evaluateQuorum();
+    }
+  }
+
+  /**
+   * Politica: fail_fast
+   * Un solo fallo = abortar todo
+   */
+  evaluateFailFast() {
+    if (this.errors.length > 0) {
+      return {
+        shouldContinue: false,
+        policy: 'fail_fast',
+        reason: 'Fallo detectado - abortando segun politica fail_fast',
+        failedAgent: this.errors[0].agent,
+        error: this.errors[0].error
+      };
+    }
+
+    return {
+      shouldContinue: true,
+      policy: 'fail_fast',
+      reason: 'Sin fallos detectados'
+    };
+  }
+
+  /**
+   * Politica: quorum
+   * Continuar si >50% exito
+   */
+  evaluateQuorum() {
+    const total = this.results.length;
+    const successes = this.results.filter(r => r.status === 'success').length;
+    const successRate = total > 0 ? successes / total : 0;
+    const quorumMet = successRate >= this.quorumThreshold;
+
+    return {
+      shouldContinue: quorumMet,
+      policy: 'quorum',
+      successRate: successRate,
+      threshold: this.quorumThreshold,
+      quorumMet: quorumMet,
+      reason: quorumMet
+        ? `Quorum alcanzado: ${successes}/${total} (${(successRate * 100).toFixed(0)}%)`
+        : `Quorum NO alcanzado: ${successes}/${total} (${(successRate * 100).toFixed(0)}% < ${this.quorumThreshold * 100}%)`,
+      failedAgents: this.errors.map(e => e.agent)
+    };
+  }
+
+  /**
+   * Politica: continue_all
+   * Continuar siempre, solo reportar fallos
+   */
+  evaluateContinueAll() {
+    return {
+      shouldContinue: true,
+      policy: 'continue_all',
+      reason: 'Continuando segun politica continue_all',
+      errors: this.errors,
+      errorCount: this.errors.length
+    };
+  }
+
+  /**
+   * Politica: critical_path
+   * Abortar solo si falla un agente critico
+   */
+  evaluateCriticalPath() {
+    const criticalFailures = this.errors.filter(e => e.isCritical);
+
+    if (criticalFailures.length > 0) {
+      return {
+        shouldContinue: false,
+        policy: 'critical_path',
+        reason: 'Agente critico fallo',
+        criticalFailures: criticalFailures,
+        optionalFailures: this.errors.filter(e => !e.isCritical)
+      };
+    }
+
+    return {
+      shouldContinue: true,
+      policy: 'critical_path',
+      reason: 'Agentes criticos OK (fallos en opcionales ignorados)',
+      optionalFailures: this.errors
+    };
+  }
+
+  /**
+   * Determina la severidad de un error
+   */
+  determineSeverity(result) {
+    if (result.error?.severity) {
+      return result.error.severity;
+    }
+
+    if (result.status === 'timeout') {
+      return 'HIGH';
+    }
+
+    if (this.criticalAgents.includes(result.agent)) {
+      return 'CRITICAL';
+    }
+
+    return 'MEDIUM';
+  }
+
+  /**
+   * Genera reporte visual de ejecucion paralela
+   */
+  generateReport() {
+    const total = this.results.length;
+    const successes = this.results.filter(r => r.status === 'success').length;
+    const failures = this.errors.length;
+    const successRate = total > 0 ? (successes / total * 100).toFixed(0) : 0;
+
+    const evaluation = this.evaluatePolicy();
+
+    const lines = [
+      '+======================================================+',
+      '|  PARALLEL EXECUTION COMPLETE                         |',
+      '+======================================================+',
+      `|  Policy: ${this.policy}`.padEnd(55) + '|',
+      `|  Total: ${total} agents`.padEnd(55) + '|',
+      '|'.padEnd(55) + '|'
+    ];
+
+    // Resultados por agente
+    for (const result of this.results) {
+      const icon = result.status === 'success' ? 'OK' : 'X ';
+      const duration = result.duration ? `(${(result.duration / 1000).toFixed(0)}s)` : '';
+      const status = result.status.toUpperCase();
+      const errorInfo = result.error ? ` (${result.error.code || 'error'})` : '';
+
+      const line = `|  ${icon} Agent (${result.agent}): ${status}${errorInfo} ${duration}`;
+      lines.push(line.padEnd(55) + '|');
+    }
+
+    lines.push('|'.padEnd(55) + '|');
+
+    // Resumen
+    const quorumStatus = evaluation.shouldContinue ? 'MET' : 'NOT MET';
+    lines.push(`|  Result: ${successes}/${total} (${successRate}%) - ${this.policy.toUpperCase()} ${quorumStatus}`.padEnd(55) + '|');
+    lines.push(`|  Status: ${evaluation.shouldContinue ? 'CONTINUING' : 'STOPPING'}`.padEnd(55) + '|');
+    lines.push('+======================================================+');
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Obtiene resumen de errores
+   */
+  getErrorSummary() {
+    const bySeverity = {};
+
+    for (const error of this.errors) {
+      bySeverity[error.severity] = (bySeverity[error.severity] || 0) + 1;
+    }
+
+    return {
+      total: this.errors.length,
+      bySeverity: bySeverity,
+      criticalCount: this.errors.filter(e => e.isCritical).length,
+      errors: this.errors
+    };
+  }
+
+  /**
+   * Limpia el estado para nueva ejecucion
+   */
+  reset() {
+    this.errors = [];
+    this.results = [];
+  }
+}
+
+// Ejemplo de uso
+const aggregator = new ContractErrorAggregator();
+
+// Configurar politica
+aggregator.setPolicy('quorum', {
+  quorumThreshold: 0.5,
+  criticalAgents: ['elsabro-executor', 'elsabro-verifier']
+});
+
+// Simular resultados de ejecucion paralela
+aggregator.addResult({
+  taskId: 'task-001',
+  agent: 'code-reviewer',
+  status: 'success',
+  duration: 45000
+});
+
+aggregator.addResult({
+  taskId: 'task-002',
+  agent: 'typescript-pro',
+  status: 'success',
+  duration: 32000
+});
+
+aggregator.addResult({
+  taskId: 'task-003',
+  agent: 'silent-failure-hunter',
+  status: 'timeout',
+  error: { code: 'TIMEOUT' }
+});
+
+aggregator.addResult({
+  taskId: 'task-004',
+  agent: 'test-analyzer',
+  status: 'success',
+  duration: 28000
+});
+
+// Generar reporte
+console.log(aggregator.generateReport());
+```
+
+---
+
+## Contrato 6: ContractSeverityClassifier
+
+### Proposito
+
+Clasificar errores consistentemente en CRITICAL, HIGH, MEDIUM, LOW para tomar decisiones apropiadas.
+
+### Cuando se Activa
+
+- Al recibir cualquier error
+- Al agregar errores en el ContractErrorAggregator
+- Para decidir notificaciones y acciones
+
+### Comportamiento en Fallo
+
+```
+CRITICAL: Estado corrupto, no puede continuar
+  -> Abortar inmediatamente
+  -> Notificar con urgencia
+  -> Sugerir recuperacion
+
+HIGH: Problema serio que deberia parar
+  -> Ofrecer opciones al usuario
+  -> Permitir continuar con riesgo
+
+MEDIUM: Warning, puede continuar
+  -> Registrar
+  -> Continuar automaticamente
+  -> Notificar al final
+
+LOW: Informativo
+  -> Solo registrar
+  -> Continuar sin interrupcion
+```
+
+### Notificacion al Usuario
+
+```
+CRITICAL:
++======================================================+
+|  ERROR: STATE_CORRUPTED                              |
+|  Severity: CRITICAL                                  |
++======================================================+
+|                                                      |
+|  El archivo de estado esta corrupto                  |
+|                                                      |
+|  ACCION REQUERIDA:                                   |
+|  -> Ejecutar /elsabro:start para reinicializar       |
++======================================================+
+
+HIGH:
++======================================================+
+|  ERROR: TESTS_FAILED                                 |
+|  Severity: HIGH                                      |
++======================================================+
+|                                                      |
+|  3 tests fallaron                                    |
+|                                                      |
+|  Opciones:                                           |
+|  [d] Debug con /elsabro:debug                        |
+|  [s] Saltar (no recomendado)                         |
+|  [a] Abortar                                         |
++======================================================+
+
+MEDIUM:
++------------------------------------------------------+
+|  WARNING: LINT_WARNINGS                              |
++------------------------------------------------------+
+|  5 lint warnings encontrados                         |
+|  Continuando automaticamente...                      |
++------------------------------------------------------+
+
+LOW:
+[INFO] Retry exitoso despues de 1 intento fallido
+```
+
+### Codigo Ejecutable
+
+```javascript
+/**
+ * ContractSeverityClassifier
+ * Clasifica errores en niveles de severidad consistentes
+ */
+class ContractSeverityClassifier {
+  constructor() {
+    // Definicion de severidades
+    this.severities = {
+      CRITICAL: {
+        level: 4,
+        icon: 'ERROR',
+        canContinue: false,
+        notifyImmediately: true,
+        requiresUserAction: true
+      },
+      HIGH: {
+        level: 3,
+        icon: 'ERROR',
+        canContinue: true,
+        notifyImmediately: true,
+        requiresUserAction: true
+      },
+      MEDIUM: {
+        level: 2,
+        icon: 'WARNING',
+        canContinue: true,
+        notifyImmediately: false,
+        requiresUserAction: false
+      },
+      LOW: {
+        level: 1,
+        icon: 'INFO',
+        canContinue: true,
+        notifyImmediately: false,
+        requiresUserAction: false
+      }
+    };
+
+    // Mapeo de codigos de error a severidades
+    this.errorSeverityMap = {
+      // CRITICAL - No puede continuar
+      'STATE_CORRUPTED': 'CRITICAL',
+      'STATE_MISSING': 'CRITICAL',
+      'CONFIG_INVALID': 'CRITICAL',
+      'AGENT_NOT_FOUND': 'CRITICAL',
+      'INCOMPATIBLE_VERSION': 'CRITICAL',
+      'GIT_DETACHED_HEAD': 'CRITICAL',
+      'GIT_CONFLICTS': 'CRITICAL',
+      'SESSION_CORRUPTED': 'CRITICAL',
+
+      // HIGH - Deberia parar
+      'TESTS_FAILED': 'HIGH',
+      'BUILD_FAILED': 'HIGH',
+      'VALIDATION_FAILED': 'HIGH',
+      'TASK_TIMEOUT': 'HIGH',
+      'RETRY_EXHAUSTED': 'HIGH',
+      'API_ERROR': 'HIGH',
+      'PERMISSION_DENIED': 'HIGH',
+      'QUORUM_NOT_MET': 'HIGH',
+      'CRITICAL_AGENT_FAILED': 'HIGH',
+      'INVALID_STATE_TRANSITION': 'HIGH',
+
+      // MEDIUM - Warning
+      'LINT_WARNINGS': 'MEDIUM',
+      'DEPRECATION_WARNING': 'MEDIUM',
+      'COVERAGE_LOW': 'MEDIUM',
+      'UNUSED_FILES': 'MEDIUM',
+      'OPTIONAL_AGENT_FAILED': 'MEDIUM',
+      'SLOW_OPERATION': 'MEDIUM',
+      'PARTIAL_SUCCESS': 'MEDIUM',
+
+      // LOW - Informativo
+      'RETRY_SUCCESS': 'LOW',
+      'OPERATION_COMPLETE': 'LOW',
+      'SUGGESTION': 'LOW',
+      'IMPROVEMENT_HINT': 'LOW'
+    };
+
+    // Patrones de error para clasificacion dinamica
+    this.errorPatterns = [
+      { pattern: /corrupt|invalid.*state|missing.*critical/i, severity: 'CRITICAL' },
+      { pattern: /test.*fail|build.*fail|timeout|exhausted/i, severity: 'HIGH' },
+      { pattern: /warning|deprecated|slow/i, severity: 'MEDIUM' },
+      { pattern: /info|success|hint/i, severity: 'LOW' }
+    ];
+  }
+
+  /**
+   * Clasifica un error
+   * @param {Object|string} error - Error a clasificar
+   * @returns {Object} Error clasificado con severidad
+   */
+  classify(error) {
+    const errorCode = this.extractErrorCode(error);
+    const errorMessage = this.extractErrorMessage(error);
+
+    // Buscar en mapa de errores conocidos
+    let severity = this.errorSeverityMap[errorCode];
+
+    // Si no esta en el mapa, usar patrones
+    if (!severity) {
+      severity = this.classifyByPattern(errorMessage);
+    }
+
+    // Fail-safe: errores desconocidos se tratan como HIGH
+    if (!severity) {
+      severity = 'HIGH';
+      console.warn(`[SEVERITY] Error desconocido clasificado como HIGH: ${errorMessage}`);
+    }
+
+    const severityConfig = this.severities[severity];
+
+    return {
+      code: errorCode,
+      message: errorMessage,
+      severity: severity,
+      level: severityConfig.level,
+      canContinue: severityConfig.canContinue,
+      notifyImmediately: severityConfig.notifyImmediately,
+      requiresUserAction: severityConfig.requiresUserAction,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Extrae codigo de error
+   */
+  extractErrorCode(error) {
+    if (typeof error === 'string') {
+      return error.toUpperCase().replace(/\s+/g, '_');
+    }
+    return error.code || error.type || 'UNKNOWN_ERROR';
+  }
+
+  /**
+   * Extrae mensaje de error
+   */
+  extractErrorMessage(error) {
+    if (typeof error === 'string') {
+      return error;
+    }
+    return error.message || error.description || String(error);
+  }
+
+  /**
+   * Clasifica por patron de mensaje
+   */
+  classifyByPattern(message) {
+    for (const { pattern, severity } of this.errorPatterns) {
+      if (pattern.test(message)) {
+        return severity;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Genera display visual del error
+   * @param {Object} classifiedError - Error ya clasificado
+   * @returns {string} Display ASCII
+   */
+  generateDisplay(classifiedError) {
+    const severity = classifiedError.severity;
+    const severityConfig = this.severities[severity];
+
+    if (severity === 'CRITICAL' || severity === 'HIGH') {
+      return this.generateBoxDisplay(classifiedError);
+    }
+
+    if (severity === 'MEDIUM') {
+      return this.generateWarningDisplay(classifiedError);
+    }
+
+    return this.generateInfoDisplay(classifiedError);
+  }
+
+  /**
+   * Display para errores CRITICAL/HIGH
+   */
+  generateBoxDisplay(error) {
+    const icon = error.severity === 'CRITICAL' ? 'ERROR' : 'ERROR';
+    const lines = [
+      '+======================================================+',
+      `|  ${icon}: ${error.code}`.padEnd(55) + '|',
+      `|  Severity: ${error.severity}`.padEnd(55) + '|',
+      '+======================================================+',
+      '|'.padEnd(55) + '|'
+    ];
+
+    // Dividir mensaje en lineas de 50 caracteres
+    const messageLines = this.wrapText(error.message, 50);
+    for (const line of messageLines) {
+      lines.push(`|  ${line}`.padEnd(55) + '|');
+    }
+
+    lines.push('|'.padEnd(55) + '|');
+
+    if (error.requiresUserAction) {
+      lines.push('+------------------------------------------------------+');
+
+      if (error.severity === 'CRITICAL') {
+        lines.push('|  ACCION REQUERIDA:'.padEnd(55) + '|');
+        lines.push('|  -> Resolver el error antes de continuar'.padEnd(55) + '|');
+      } else {
+        lines.push('|  Opciones:'.padEnd(55) + '|');
+        lines.push('|  [d] Debug con /elsabro:debug'.padEnd(55) + '|');
+        lines.push('|  [s] Saltar (no recomendado)'.padEnd(55) + '|');
+        lines.push('|  [a] Abortar'.padEnd(55) + '|');
+      }
+    }
+
+    lines.push('+======================================================+');
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Display para warnings (MEDIUM)
+   */
+  generateWarningDisplay(error) {
+    const lines = [
+      '+------------------------------------------------------+',
+      `|  WARNING: ${error.code}`.padEnd(55) + '|',
+      '+------------------------------------------------------+'
+    ];
+
+    const messageLines = this.wrapText(error.message, 50);
+    for (const line of messageLines) {
+      lines.push(`|  ${line}`.padEnd(55) + '|');
+    }
+
+    lines.push('|  Continuando automaticamente...'.padEnd(55) + '|');
+    lines.push('+------------------------------------------------------+');
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Display para info (LOW)
+   */
+  generateInfoDisplay(error) {
+    return `[INFO] ${error.message}`;
+  }
+
+  /**
+   * Wrap texto a ancho especifico
+   */
+  wrapText(text, width) {
+    const words = text.split(' ');
+    const lines = [];
+    let currentLine = '';
+
+    for (const word of words) {
+      if ((currentLine + ' ' + word).trim().length <= width) {
+        currentLine = (currentLine + ' ' + word).trim();
+      } else {
+        if (currentLine) lines.push(currentLine);
+        currentLine = word;
+      }
+    }
+
+    if (currentLine) lines.push(currentLine);
+
+    return lines;
+  }
+
+  /**
+   * Compara severidades
+   * @param {string} sev1 - Primera severidad
+   * @param {string} sev2 - Segunda severidad
+   * @returns {number} -1, 0, o 1
+   */
+  compareSeverity(sev1, sev2) {
+    const level1 = this.severities[sev1]?.level || 0;
+    const level2 = this.severities[sev2]?.level || 0;
+    return level2 - level1;  // Mayor severidad primero
+  }
+
+  /**
+   * Obtiene la severidad mas alta de una lista
+   */
+  getHighestSeverity(errors) {
+    let highest = 'LOW';
+
+    for (const error of errors) {
+      const classified = this.classify(error);
+      if (this.severities[classified.severity].level > this.severities[highest].level) {
+        highest = classified.severity;
+      }
+    }
+
+    return highest;
+  }
+}
+
+// Ejemplo de uso
+const classifier = new ContractSeverityClassifier();
+
+// Clasificar varios errores
+const errors = [
+  { code: 'STATE_CORRUPTED', message: 'El archivo state.json esta corrupto' },
+  { code: 'TESTS_FAILED', message: '3 tests fallaron en el modulo de auth' },
+  { code: 'LINT_WARNINGS', message: '5 lint warnings encontrados' },
+  { code: 'RETRY_SUCCESS', message: 'Operacion exitosa despues de 2 reintentos' }
+];
+
+for (const error of errors) {
+  const classified = classifier.classify(error);
+  console.log(classifier.generateDisplay(classified));
+  console.log('');
+}
+```
+
+---
+
+## Contrato 7: ContractSessionValidator
+
+### Proposito
+
+Validar la integridad del archivo de estado `.elsabro/state.json` y detectar corrupcion o inconsistencias.
+
+### Cuando se Activa
+
+- Al inicio de cualquier comando ELSABRO
+- Al escribir estado
+- Periodicamente durante operaciones largas
+
+### Comportamiento en Fallo
+
+```
+SI estado corrupto:
+  1. Intentar recuperar de backup
+  2. Si no hay backup, reinicializar
+  3. Preservar contexto que se pueda salvar
+  4. Notificar al usuario
+```
+
+### Notificacion al Usuario
+
+```
++======================================================+
+|  ERROR: SESSION_CORRUPTED                            |
+|  Severity: CRITICAL                                  |
++======================================================+
+|                                                      |
+|  El archivo .elsabro/state.json esta corrupto       |
+|  o tiene estructura invalida                         |
+|                                                      |
+|  Detalles:                                           |
+|  - Campo 'version' faltante                          |
+|  - Campo 'current_flow' tiene tipo invalido          |
+|                                                      |
++------------------------------------------------------+
+|  Opciones de recuperacion:                           |
+|  [b] Restaurar desde backup                          |
+|  [r] Reinicializar estado (perdera historial)        |
+|  [m] Editar manualmente                              |
++======================================================+
+```
+
+### Codigo Ejecutable
+
+```javascript
+/**
+ * ContractSessionValidator
+ * Valida integridad del estado de sesion ELSABRO
+ */
+class ContractSessionValidator {
+  constructor() {
+    // Schema de validacion para state.json
+    this.stateSchema = {
+      required: ['version', 'updated_at'],
+      optional: ['created_at', 'current_flow', 'context', 'history', 'pending_tasks', 'blocked_on', 'errors', 'suggested_next'],
+      types: {
+        version: 'string',
+        created_at: 'string',
+        updated_at: 'string',
+        current_flow: ['object', 'null'],
+        context: 'object',
+        history: 'array',
+        pending_tasks: 'array',
+        blocked_on: ['string', 'null'],
+        errors: 'object',
+        suggested_next: ['string', 'null']
+      },
+      nested: {
+        current_flow: {
+          required: ['command', 'phase', 'started_at'],
+          types: {
+            command: 'string',
+            phase: 'string',
+            started_at: 'string'
+          }
+        },
+        context: {
+          optional: ['project_type', 'tech_stack', 'current_feature', 'plan_file'],
+          types: {
+            project_type: 'string',
+            tech_stack: 'array',
+            current_feature: 'string',
+            plan_file: 'string'
+          }
+        }
+      }
+    };
+
+    // Fases validas por comando
+    this.validPhases = {
+      start: ['initializing', 'detecting_context', 'greeting', 'transitioning', 'done'],
+      plan: ['initializing', 'exploring', 'researching', 'planning', 'validating', 'done'],
+      execute: ['initializing', 'exploring', 'executing_wave_1', 'executing_wave_2', 'executing_wave_3', 'verifying', 'done'],
+      'verify-work': ['initializing', 'verifying', 'aggregating', 'done'],
+      debug: ['initializing', 'diagnosing', 'fixing', 'verifying', 'done'],
+      quick: ['initializing', 'executing', 'done']
+    };
+
+    // Path al estado
+    this.statePath = '.elsabro/state.json';
+    this.backupPath = '.elsabro/state.backup.json';
+  }
+
+  /**
+   * Valida el estado completo
+   * @param {Object|string} state - Estado a validar (objeto o JSON string)
+   * @returns {Object} Resultado de validacion
+   */
+  validate(state) {
+    const errors = [];
+
+    // Parsear si es string
+    if (typeof state === 'string') {
+      try {
+        state = JSON.parse(state);
+      } catch (e) {
+        return {
+          valid: false,
+          error: {
+            code: 'JSON_PARSE_ERROR',
+            severity: 'CRITICAL',
+            message: 'El estado no es JSON valido',
+            parseError: e.message
+          }
+        };
+      }
+    }
+
+    // Validar tipo base
+    if (typeof state !== 'object' || state === null) {
+      return {
+        valid: false,
+        error: {
+          code: 'INVALID_STATE_TYPE',
+          severity: 'CRITICAL',
+          message: 'El estado debe ser un objeto'
+        }
+      };
+    }
+
+    // Validar campos requeridos
+    for (const field of this.stateSchema.required) {
+      if (!(field in state)) {
+        errors.push({
+          field: field,
+          type: 'MISSING_REQUIRED',
+          message: `Campo requerido '${field}' faltante`
+        });
+      }
+    }
+
+    // Validar tipos
+    for (const [field, expectedType] of Object.entries(this.stateSchema.types)) {
+      if (field in state) {
+        const typeError = this.validateType(state[field], expectedType, field);
+        if (typeError) {
+          errors.push(typeError);
+        }
+      }
+    }
+
+    // Validar current_flow si existe
+    if (state.current_flow !== null && state.current_flow !== undefined) {
+      const flowErrors = this.validateCurrentFlow(state.current_flow);
+      errors.push(...flowErrors);
+    }
+
+    // Validar historial si existe
+    if (state.history) {
+      const historyErrors = this.validateHistory(state.history);
+      errors.push(...historyErrors);
+    }
+
+    // Validar timestamps
+    const timestampErrors = this.validateTimestamps(state);
+    errors.push(...timestampErrors);
+
+    if (errors.length > 0) {
+      return {
+        valid: false,
+        errors: errors,
+        error: {
+          code: 'SESSION_VALIDATION_FAILED',
+          severity: errors.some(e => e.type === 'MISSING_REQUIRED') ? 'CRITICAL' : 'HIGH',
+          message: `${errors.length} errores de validacion encontrados`,
+          details: errors
+        }
+      };
+    }
+
+    return {
+      valid: true,
+      state: state
+    };
+  }
+
+  /**
+   * Valida el tipo de un valor
+   */
+  validateType(value, expectedType, field) {
+    const types = Array.isArray(expectedType) ? expectedType : [expectedType];
+
+    for (const type of types) {
+      if (type === 'null' && value === null) return null;
+      if (type === 'array' && Array.isArray(value)) return null;
+      if (type === 'object' && typeof value === 'object' && value !== null && !Array.isArray(value)) return null;
+      if (typeof value === type) return null;
+    }
+
+    return {
+      field: field,
+      type: 'TYPE_MISMATCH',
+      message: `Campo '${field}' tiene tipo invalido. Esperado: ${types.join(' | ')}, recibido: ${typeof value}`
+    };
+  }
+
+  /**
+   * Valida current_flow
+   */
+  validateCurrentFlow(flow) {
+    const errors = [];
+    const schema = this.stateSchema.nested.current_flow;
+
+    // Validar campos requeridos
+    for (const field of schema.required) {
+      if (!(field in flow)) {
+        errors.push({
+          field: `current_flow.${field}`,
+          type: 'MISSING_REQUIRED',
+          message: `Campo requerido 'current_flow.${field}' faltante`
+        });
+      }
+    }
+
+    // Validar fase valida para el comando
+    if (flow.command && flow.phase) {
+      const validPhases = this.validPhases[flow.command];
+      if (validPhases && !validPhases.includes(flow.phase)) {
+        errors.push({
+          field: 'current_flow.phase',
+          type: 'INVALID_PHASE',
+          message: `Fase '${flow.phase}' invalida para comando '${flow.command}'. Validas: ${validPhases.join(', ')}`
+        });
+      }
+    }
+
+    return errors;
+  }
+
+  /**
+   * Valida el historial
+   */
+  validateHistory(history) {
+    const errors = [];
+
+    if (!Array.isArray(history)) {
+      errors.push({
+        field: 'history',
+        type: 'TYPE_MISMATCH',
+        message: 'El historial debe ser un array'
+      });
+      return errors;
+    }
+
+    for (let i = 0; i < history.length; i++) {
+      const entry = history[i];
+
+      if (!entry.command) {
+        errors.push({
+          field: `history[${i}].command`,
+          type: 'MISSING_REQUIRED',
+          message: `Entrada de historial ${i} sin campo 'command'`
+        });
+      }
+
+      if (!entry.completed_at) {
+        errors.push({
+          field: `history[${i}].completed_at`,
+          type: 'MISSING_REQUIRED',
+          message: `Entrada de historial ${i} sin campo 'completed_at'`
+        });
+      }
+    }
+
+    return errors;
+  }
+
+  /**
+   * Valida timestamps
+   */
+  validateTimestamps(state) {
+    const errors = [];
+
+    const timestamps = ['created_at', 'updated_at'];
+
+    for (const field of timestamps) {
+      if (state[field]) {
+        const date = new Date(state[field]);
+        if (isNaN(date.getTime())) {
+          errors.push({
+            field: field,
+            type: 'INVALID_TIMESTAMP',
+            message: `Timestamp '${field}' no es una fecha valida: ${state[field]}`
+          });
+        }
+      }
+    }
+
+    // Verificar que updated_at >= created_at
+    if (state.created_at && state.updated_at) {
+      const created = new Date(state.created_at);
+      const updated = new Date(state.updated_at);
+
+      if (updated < created) {
+        errors.push({
+          field: 'timestamps',
+          type: 'INVALID_TIMESTAMP_ORDER',
+          message: 'updated_at es anterior a created_at'
+        });
+      }
+    }
+
+    return errors;
+  }
+
+  /**
+   * Intenta reparar un estado corrupto
+   * @param {Object} corruptState - Estado corrupto
+   * @returns {Object} Estado reparado o error
+   */
+  attemptRepair(corruptState) {
+    const repaired = {};
+    const repairs = [];
+
+    // Asegurar version
+    repaired.version = corruptState?.version || '1.0.0';
+    if (!corruptState?.version) {
+      repairs.push('Agregado version: 1.0.0');
+    }
+
+    // Asegurar timestamps
+    const now = new Date().toISOString();
+    repaired.created_at = corruptState?.created_at || now;
+    repaired.updated_at = now;
+    if (!corruptState?.created_at) {
+      repairs.push('Agregado created_at');
+    }
+    repairs.push('Actualizado updated_at');
+
+    // Preservar o inicializar current_flow
+    repaired.current_flow = null;  // Limpiar flujo corrupto
+
+    // Preservar contexto si es valido
+    if (corruptState?.context && typeof corruptState.context === 'object') {
+      repaired.context = corruptState.context;
+    } else {
+      repaired.context = {};
+      repairs.push('Reinicializado context');
+    }
+
+    // Preservar historial si es valido
+    if (Array.isArray(corruptState?.history)) {
+      repaired.history = corruptState.history.filter(h => h.command && h.completed_at);
+      if (repaired.history.length < corruptState.history.length) {
+        repairs.push(`Filtradas ${corruptState.history.length - repaired.history.length} entradas de historial invalidas`);
+      }
+    } else {
+      repaired.history = [];
+      repairs.push('Reinicializado history');
+    }
+
+    // Inicializar campos opcionales
+    repaired.pending_tasks = [];
+    repaired.blocked_on = null;
+    repaired.errors = { count: 0 };
+    repaired.suggested_next = null;
+
+    // Validar estado reparado
+    const validation = this.validate(repaired);
+
+    if (validation.valid) {
+      return {
+        success: true,
+        state: repaired,
+        repairs: repairs
+      };
+    }
+
+    return {
+      success: false,
+      error: {
+        code: 'REPAIR_FAILED',
+        severity: 'CRITICAL',
+        message: 'No se pudo reparar el estado',
+        validationErrors: validation.errors
+      }
+    };
+  }
+
+  /**
+   * Crea un estado inicial valido
+   */
+  createInitialState() {
+    const now = new Date().toISOString();
+
+    return {
+      version: '1.0.0',
+      created_at: now,
+      updated_at: now,
+      current_flow: null,
+      context: {},
+      history: [],
+      pending_tasks: [],
+      blocked_on: null,
+      errors: { count: 0 },
+      suggested_next: null
+    };
+  }
+
+  /**
+   * Genera display de error de validacion
+   */
+  generateValidationErrorDisplay(validationResult) {
+    if (validationResult.valid) {
+      return '[OK] Estado valido';
+    }
+
+    const error = validationResult.error;
+    const details = validationResult.errors || [];
+
+    const lines = [
+      '+======================================================+',
+      `|  ERROR: ${error.code}`.padEnd(55) + '|',
+      `|  Severity: ${error.severity}`.padEnd(55) + '|',
+      '+======================================================+',
+      '|'.padEnd(55) + '|',
+      `|  ${error.message}`.padEnd(55) + '|',
+      '|'.padEnd(55) + '|'
+    ];
+
+    if (details.length > 0) {
+      lines.push('|  Detalles:'.padEnd(55) + '|');
+      for (const detail of details.slice(0, 5)) {  // Mostrar max 5
+        lines.push(`|  - ${detail.field}: ${detail.type}`.padEnd(55) + '|');
+      }
+      if (details.length > 5) {
+        lines.push(`|  ... y ${details.length - 5} errores mas`.padEnd(55) + '|');
+      }
+    }
+
+    lines.push('|'.padEnd(55) + '|');
+    lines.push('+------------------------------------------------------+');
+    lines.push('|  Opciones de recuperacion:'.padEnd(55) + '|');
+    lines.push('|  [b] Restaurar desde backup'.padEnd(55) + '|');
+    lines.push('|  [r] Reinicializar estado (perdera historial)'.padEnd(55) + '|');
+    lines.push('|  [m] Editar manualmente'.padEnd(55) + '|');
+    lines.push('+======================================================+');
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Carga y valida el estado de sesion desde el archivo
+   * @returns {Object} Resultado con session y validacion
+   */
+  async load() {
+    try {
+      const content = await Read(this.statePath);
+      const session = JSON.parse(content);
+      const validation = await this.validate(session);
+      return { success: true, session, validation };
+    } catch (error) {
+      return {
+        success: false,
+        reason: error.code === 'ENOENT' ? 'SESSION_NOT_FOUND' : 'SESSION_CORRUPTED',
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Valida y guarda el estado de sesion
+   * @param {Object} session - Estado de sesion a guardar
+   * @returns {Object} Resultado de la operacion
+   */
+  async save(session) {
+    const validation = await this.validate(session);
+    if (!validation.valid) {
+      return { success: false, reason: "SESSION_INVALID", errors: validation.errors };
+    }
+    session.updatedAt = new Date().toISOString();
+    await Write(this.statePath, JSON.stringify(session, null, 2));
+    return { success: true, savedAt: session.updatedAt };
+  }
+}
+
+// Ejemplo de uso
+const sessionValidator = new ContractSessionValidator();
+
+// Estado valido
+const validState = {
+  version: '1.0.0',
+  created_at: '2024-01-20T10:00:00Z',
+  updated_at: '2024-01-20T15:30:00Z',
+  current_flow: {
+    command: 'execute',
+    phase: 'executing_wave_1',
+    started_at: '2024-01-20T15:00:00Z'
+  },
+  context: {
+    project_type: 'brownfield',
+    tech_stack: ['nextjs', 'prisma']
+  },
+  history: [
+    { command: 'plan', completed_at: '2024-01-20T14:50:00Z', result: 'created' }
+  ]
+};
+
+const validResult = sessionValidator.validate(validState);
+console.log('Estado valido:', validResult.valid);
+
+// Estado corrupto
+const corruptState = {
+  version: '1.0.0',
+  // Falta updated_at
+  current_flow: {
+    command: 'execute',
+    phase: 'invalid_phase'  // Fase invalida
+    // Falta started_at
+  }
+};
+
+const corruptResult = sessionValidator.validate(corruptState);
+if (!corruptResult.valid) {
+  console.log(sessionValidator.generateValidationErrorDisplay(corruptResult));
+
+  // Intentar reparar
+  const repairResult = sessionValidator.attemptRepair(corruptState);
+  if (repairResult.success) {
+    console.log('Estado reparado:', repairResult.state);
+    console.log('Reparaciones:', repairResult.repairs);
+  }
+}
+```
+
+---
+
+## Integracion
+
+### Flujo de Ejecucion Completo
+
+```
++============================================================================+
+|                    FLUJO DE CONTRATOS EN EJECUCION                         |
++============================================================================+
+|                                                                            |
+|  1. Usuario ejecuta /elsabro:execute                                       |
+|                                                                            |
+|  2. [ContractSessionValidator]                                             |
+|     Validar .elsabro/state.json                                            |
+|     -> OK: Continuar                                                       |
+|     -> ERROR: Reparar o abortar                                            |
+|                                                                            |
+|  3. [ContractRegistryValidator]                                            |
+|     Validar agentes necesarios existen                                     |
+|     -> OK: Continuar                                                       |
+|     -> ERROR: AGENT_NOT_FOUND - abortar                                    |
+|                                                                            |
+|  4. [ContractTaskLifecycle]                                                |
+|     Crear Tasks para cada agente                                           |
+|     INIT -> IN_PROGRESS                                                    |
+|                                                                            |
+|  5. [ContractTimeoutHandler]                                               |
+|     Iniciar tracking de timeout                                            |
+|     Health checks cada 5s                                                  |
+|                                                                            |
+|  6. EJECUTAR AGENTES EN PARALELO                                           |
+|     Task(haiku) | Task(haiku) | Task(haiku)                                |
+|                                                                            |
+|  7. [ContractRetryPolicy] (por cada agente)                                |
+|     Si falla: retry con backoff                                            |
+|     1s -> 2s -> 4s                                                         |
+|                                                                            |
+|  8. [ContractSeverityClassifier]                                           |
+|     Clasificar errores: CRITICAL/HIGH/MEDIUM/LOW                           |
+|                                                                            |
+|  9. [ContractErrorAggregator]                                              |
+|     Colectar resultados                                                    |
+|     Aplicar politica (quorum)                                              |
+|     -> QUORUM MET: Continuar                                               |
+|     -> QUORUM NOT MET: Abortar                                             |
+|                                                                            |
+| 10. [ContractTaskLifecycle]                                                |
+|     Marcar tasks: COMPLETED o ERROR                                        |
+|                                                                            |
+| 11. [ContractSessionValidator]                                             |
+|     Actualizar .elsabro/state.json                                         |
+|                                                                            |
++============================================================================+
+```
+
+### Dependencias entre Contratos
+
+```
+ContractSessionValidator
+    |
+    v (estado valido)
+ContractRegistryValidator
+    |
+    v (agentes validos)
+ContractTaskLifecycle
+    |
+    v (tasks creadas)
+ContractTimeoutHandler
+    |
+    v (tracking activo)
+    |
+    +--> ContractRetryPolicy (por agente)
+    |         |
+    |         v (resultado o retry exhausted)
+    |
+    +--> ContractSeverityClassifier
+              |
+              v (errores clasificados)
+ContractErrorAggregator
+    |
+    v (decision de continuar/abortar)
+ContractTaskLifecycle
+    |
+    v (tasks actualizadas)
+ContractSessionValidator
+    |
+    v (estado persistido)
+```
+
+### Ejemplo Completo de Integracion
+
+```javascript
+/**
+ * Ejemplo completo de integracion de todos los contratos
+ */
+class ElsabroErrorContracts {
+  constructor() {
+    this.sessionValidator = new ContractSessionValidator();
+    this.registryValidator = new ContractRegistryValidator();
+    this.taskLifecycle = new ContractTaskLifecycle();
+    this.timeoutHandler = new ContractTimeoutHandler();
+    this.retryPolicy = new ContractRetryPolicy();
+    this.severityClassifier = new ContractSeverityClassifier();
+    this.errorAggregator = new ContractErrorAggregator();
+  }
+
+  /**
+   * Ejecuta una operacion paralela con todos los contratos
+   */
+  async executeParallelOperation(agents, operations, policy = 'quorum') {
+    // 1. Validar sesion
+    const sessionResult = this.sessionValidator.validate(
+      this.readState()
+    );
+
+    if (!sessionResult.valid) {
+      const repair = this.sessionValidator.attemptRepair(sessionResult);
+      if (!repair.success) {
+        return this.handleCriticalError(sessionResult.error);
+      }
+    }
+
+    // 2. Validar agentes
+    const registryResult = this.registryValidator.validateAgents(agents);
+    if (!registryResult.valid) {
+      return this.handleCriticalError(registryResult.aggregatedError);
+    }
+
+    // 3. Crear tasks
+    const tasks = [];
+    for (let i = 0; i < agents.length; i++) {
+      const taskResult = this.taskLifecycle.registerTask(
+        `task-${Date.now()}-${i}`,
+        { agent: agents[i] }
+      );
+      tasks.push(taskResult.task);
+      this.taskLifecycle.transition(taskResult.task.id, 'in_progress');
+    }
+
+    // 4. Configurar agregador
+    this.errorAggregator.reset();
+    this.errorAggregator.setPolicy(policy);
+
+    // 5. Ejecutar operaciones en paralelo
+    const promises = tasks.map(async (task, index) => {
+      // Iniciar timeout tracking
+      this.timeoutHandler.startTracking(task.id);
+
+      try {
+        // Ejecutar con retry
+        const result = await this.retryPolicy.executeWithRetry(
+          () => operations[index]()
+        );
+
+        // Marcar completado
+        this.timeoutHandler.markComplete(task.id, result);
+        this.taskLifecycle.transition(task.id, 'completed');
+
+        // Agregar resultado
+        this.errorAggregator.addResult({
+          taskId: task.id,
+          agent: agents[index],
+          status: result.success ? 'success' : 'error',
+          duration: result.totalDuration,
+          error: result.error
+        });
+
+        return result;
+
+      } catch (error) {
+        // Clasificar error
+        const classified = this.severityClassifier.classify(error);
+
+        // Marcar error
+        this.taskLifecycle.transition(task.id, 'error');
+
+        // Agregar al agregador
+        this.errorAggregator.addResult({
+          taskId: task.id,
+          agent: agents[index],
+          status: 'error',
+          error: classified
+        });
+
+        return { success: false, error: classified };
+      }
+    });
+
+    // 6. Esperar todos los resultados
+    const results = await Promise.all(promises);
+
+    // 7. Evaluar politica
+    const evaluation = this.errorAggregator.evaluatePolicy();
+
+    // 8. Generar reporte
+    const report = this.errorAggregator.generateReport();
+    console.log(report);
+
+    // 9. Persistir estado
+    this.persistState(evaluation);
+
+    return {
+      success: evaluation.shouldContinue,
+      results: results,
+      evaluation: evaluation,
+      report: report
+    };
+  }
+
+  handleCriticalError(error) {
+    const display = this.severityClassifier.generateDisplay(
+      this.severityClassifier.classify(error)
+    );
+    console.log(display);
+
+    return {
+      success: false,
+      error: error,
+      aborted: true
+    };
+  }
+
+  readState() {
+    // En implementacion real, leer de .elsabro/state.json
+    return this.sessionValidator.createInitialState();
+  }
+
+  persistState(evaluation) {
+    // En implementacion real, escribir a .elsabro/state.json
+    console.log('Estado persistido:', evaluation);
+  }
+}
+
+// Uso
+const contracts = new ElsabroErrorContracts();
+
+// Simular operacion paralela
+contracts.executeParallelOperation(
+  ['elsabro-executor', 'feature-dev:code-explorer', 'elsabro-verifier'],
+  [
+    async () => ({ data: 'result1' }),
+    async () => ({ data: 'result2' }),
+    async () => { throw { code: 'TIMEOUT' }; }
+  ],
+  'quorum'
+).then(result => {
+  console.log('Resultado final:', result.success ? 'EXITO' : 'FALLO');
+});
+```
+
+---
+
+## Escenarios de Fallo Exhaustivos
+
+### Escenario 1: Estado Corrupto al Inicio
+
+```
+SITUACION:
+  Usuario ejecuta /elsabro:execute
+  .elsabro/state.json tiene JSON invalido
+
+CONTRATOS ACTIVADOS:
+  1. ContractSessionValidator -> JSON_PARSE_ERROR
+
+FLUJO:
+  1. Detectar corrupcion
+  2. Intentar leer backup
+  3. Si backup existe -> restaurar
+  4. Si no hay backup -> reinicializar
+  5. Notificar al usuario
+  6. Continuar con estado limpio
+
+DISPLAY:
+  +======================================================+
+  |  ERROR: SESSION_CORRUPTED                            |
+  |  Severity: CRITICAL                                  |
+  +======================================================+
+  |  El archivo .elsabro/state.json esta corrupto       |
+  |  Restaurando desde backup...                         |
+  +======================================================+
+```
+
+### Escenario 2: Agente No Encontrado
+
+```
+SITUACION:
+  Plan referencia agente "elsabro-nonexistent"
+
+CONTRATOS ACTIVADOS:
+  1. ContractRegistryValidator -> AGENT_NOT_FOUND
+
+FLUJO:
+  1. Validar agentes antes de lanzar
+  2. Detectar agente invalido
+  3. Buscar sugerencias similares
+  4. Abortar operacion
+  5. Mostrar alternativas al usuario
+
+DISPLAY:
+  +======================================================+
+  |  ERROR: AGENT_NOT_FOUND                              |
+  |  Severity: CRITICAL                                  |
+  +======================================================+
+  |  El agente "elsabro-nonexistent" no existe          |
+  |                                                      |
+  |  Agentes similares:                                  |
+  |  - elsabro-executor                                  |
+  |  - elsabro-verifier                                  |
+  +======================================================+
+```
+
+### Escenario 3: Timeout en Agente
+
+```
+SITUACION:
+  Agente tarda mas de 30 minutos
+
+CONTRATOS ACTIVADOS:
+  1. ContractTimeoutHandler -> TASK_TIMEOUT
+  2. ContractSeverityClassifier -> HIGH
+  3. ContractErrorAggregator -> Evaluar quorum
+
+FLUJO:
+  1. Health check detecta timeout inminente
+  2. Warning al usuario
+  3. Timeout alcanzado
+  4. Terminacion graceful
+  5. Clasificar como HIGH
+  6. Agregar al agregador
+  7. Evaluar si quorum se mantiene
+
+DISPLAY:
+  +======================================================+
+  |  WARNING: TASK_TIMEOUT                               |
+  |  Severity: HIGH                                      |
+  +======================================================+
+  |  La tarea "explore-codebase" excedio el timeout      |
+  |                                                      |
+  |  Opciones:                                           |
+  |  [e] Extender timeout (+15 min)                      |
+  |  [t] Terminar y usar output parcial                  |
+  +======================================================+
+```
+
+### Escenario 4: Retry Exhausted
+
+```
+SITUACION:
+  Operacion falla 3 veces consecutivas
+
+CONTRATOS ACTIVADOS:
+  1. ContractRetryPolicy -> RETRY_EXHAUSTED
+  2. ContractSeverityClassifier -> HIGH
+  3. ContractErrorAggregator -> Agregar error
+
+FLUJO:
+  1. Intento 1: Fallo (1s delay)
+  2. Intento 2: Fallo (2s delay)
+  3. Intento 3: Fallo
+  4. Crear error RETRY_EXHAUSTED
+  5. Clasificar severidad
+  6. Escalar a usuario
+
+DISPLAY:
+  +------------------------------------------------------+
+  |  RETRY: npm test                                     |
+  +------------------------------------------------------+
+  |  Attempt 1/3: FAILED (timeout)                       |
+  |  Waiting 1s...                                       |
+  |  Attempt 2/3: FAILED (exit code 1)                   |
+  |  Waiting 2s...                                       |
+  |  Attempt 3/3: FAILED (exit code 1)                   |
+  |                                                      |
+  |  X All attempts exhausted                            |
+  +------------------------------------------------------+
+```
+
+### Escenario 5: Quorum No Alcanzado
+
+```
+SITUACION:
+  3 de 4 agentes fallan
+
+CONTRATOS ACTIVADOS:
+  1. ContractErrorAggregator -> QUORUM_NOT_MET
+  2. ContractSeverityClassifier -> HIGH
+
+FLUJO:
+  1. Esperar todos los agentes
+  2. Contar exitos: 1/4 (25%)
+  3. Umbral quorum: 50%
+  4. Quorum NO alcanzado
+  5. Abortar operacion
+  6. Reportar fallos
+
+DISPLAY:
+  +======================================================+
+  |  PARALLEL EXECUTION COMPLETE                         |
+  +======================================================+
+  |  Policy: quorum                                      |
+  |  Total: 4 agents                                     |
+  |                                                      |
+  |  OK Agent 1 (code-reviewer): SUCCESS                 |
+  |  X  Agent 2 (typescript-pro): FAILED (timeout)       |
+  |  X  Agent 3 (silent-failure): FAILED (error)         |
+  |  X  Agent 4 (test-analyzer): FAILED (timeout)        |
+  |                                                      |
+  |  Result: 1/4 (25%) - QUORUM NOT MET                  |
+  |  Status: STOPPING                                    |
+  +======================================================+
+```
+
+### Escenario 6: Transicion de Estado Invalida
+
+```
+SITUACION:
+  Intento de marcar task como COMPLETED sin pasar por IN_PROGRESS
+
+CONTRATOS ACTIVADOS:
+  1. ContractTaskLifecycle -> INVALID_STATE_TRANSITION
+
+FLUJO:
+  1. Detectar transicion invalida
+  2. Rechazar operacion
+  3. Sugerir transicion correcta
+  4. Mantener estado anterior
+
+DISPLAY:
+  +======================================================+
+  |  ERROR: INVALID_STATE_TRANSITION                     |
+  |  Severity: HIGH                                      |
+  +======================================================+
+  |  Transicion invalida: INIT -> COMPLETED              |
+  |                                                      |
+  |  Flujo correcto:                                     |
+  |  INIT -> IN_PROGRESS -> COMPLETED                    |
+  +======================================================+
+```
+
+### Escenario 7: Multiples Errores Criticos Simultaneos
+
+```
+SITUACION:
+  Estado corrupto + Agente critico falla + Timeout
+
+CONTRATOS ACTIVADOS:
+  Todos los contratos en cascada
+
+FLUJO:
+  1. SessionValidator detecta corrupcion -> reparar
+  2. Continuar con estado reparado
+  3. Agente critico falla
+  4. CriticalPath policy activada
+  5. Abortar toda la operacion
+  6. Persistir estado de error
+  7. Reportar al usuario
+
+DISPLAY:
+  +======================================================+
+  |  MULTIPLE CRITICAL ERRORS                            |
+  |  Severity: CRITICAL                                  |
+  +======================================================+
+  |                                                      |
+  |  Errores encontrados:                                |
+  |  1. SESSION_CORRUPTED (reparado)                     |
+  |  2. CRITICAL_AGENT_FAILED: elsabro-executor          |
+  |  3. TASK_TIMEOUT: explore-codebase                   |
+  |                                                      |
+  |  La operacion fue abortada por errores criticos      |
+  |                                                      |
+  +------------------------------------------------------+
+  |  Estado guardado para recuperacion:                  |
+  |  -> /elsabro:resume-work para continuar              |
+  +======================================================+
+```
+
+---
+
+## Checklist de Implementacion
+
+Para implementar los contratos en un comando ELSABRO:
+
+- [ ] Importar/instanciar ContractSessionValidator
+- [ ] Validar estado al inicio del comando
+- [ ] Importar/instanciar ContractRegistryValidator
+- [ ] Validar agentes antes de lanzar
+- [ ] Importar/instanciar ContractTaskLifecycle
+- [ ] Crear Tasks para cada agente
+- [ ] Respetar transiciones INIT -> ACTIVE -> COMPLETE
+- [ ] Importar/instanciar ContractTimeoutHandler
+- [ ] Configurar timeout apropiado
+- [ ] Iniciar tracking para cada tarea
+- [ ] Importar/instanciar ContractRetryPolicy
+- [ ] Configurar reintentos para operaciones fallibles
+- [ ] Importar/instanciar ContractSeverityClassifier
+- [ ] Clasificar todos los errores
+- [ ] Generar displays apropiados
+- [ ] Importar/instanciar ContractErrorAggregator
+- [ ] Configurar politica (quorum, fail_fast, etc)
+- [ ] Agregar todos los resultados
+- [ ] Evaluar politica para decidir continuar/abortar
+- [ ] Persistir estado al finalizar
+- [ ] Generar reporte final